cinelerra-5.0/cinelerra/renderfarmfsserver.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #include "format.inc"
  23 #include "renderfarm.h"
  24 #include "renderfarmfsserver.h"
  25 #include "units.h"
  26
  27
  28 #include <string.h>
  29 #include <sys/stat.h>
  30
  31 #define DEBUG 0
  32
  33 RenderFarmFSServer::RenderFarmFSServer(RenderFarmServerThread *server)
  34 {
  35         this->server = server;
  36 }
  37
  38
  39
  40 RenderFarmFSServer::~RenderFarmFSServer()
  41 {
  42 }
  43
  44 void RenderFarmFSServer::initialize()
  45 {
  46 }
  47
  48 int RenderFarmFSServer::handle_request(int request_id, int request_size, unsigned char *buffer)
  49 {
  50         int result = 0;
  51
  52 if(DEBUG)
  53 printf("RenderFarmFSServer::handle_request request_id=%d\n", request_id);
  54         switch(request_id)
  55         {
  56                 case RENDERFARM_FOPEN:
  57                 {
  58                         char *path;
  59                         char *mode;
  60                         FILE *file;
  61                         unsigned char datagram[8];
  62                         int i = 0;
  63                         int64_t file_int64;
  64
  65
  66                         path = (char*)buffer;
  67                         mode = (char*)buffer + strlen(path) + 1;
  68
  69
  70                         file = fopen64(path, mode);
  71                         file_int64 = Units::ptr_to_int64(file);
  72                         STORE_INT64(file_int64);
  73                         server->write_socket((char*)datagram, 8, RENDERFARM_TIMEOUT);
  74 if(DEBUG)
  75 printf("RenderFarmFSServer::handle_request RENDERFARM_FOPEN file=%p file_int64=%llx datagram=%02x%02x%02x%02x%02x%02x%02x%02x path=%s mode=%s\n",
  76 file, file_int64, datagram[0], datagram[1], datagram[2], datagram[3], datagram[4], datagram[5], datagram[6], datagram[7], path, mode);
  77                         result = 1;
  78                         break;
  79                 }
  80
  81                 case RENDERFARM_FCLOSE:
  82                 {
  83                         int64_t pointer = READ_INT64((unsigned char*)buffer);
  84                         FILE *file = (FILE*)Units::int64_to_ptr(pointer);
  85 if(DEBUG)
  86 printf("RenderFarmFSServer::handle_request RENDERFARM_FCLOSE file=%p\n", file);
  87                         fclose(file);
  88                         result = 1;
  89                         break;
  90                 }
  91
  92                 case RENDERFARM_REMOVE:
  93                 {
  94                         remove((char*)buffer);
  95 if(DEBUG)
  96 printf("RenderFarmFSServer::handle_request path=%s\n", buffer);
  97                         result = 1;
  98                         break;
  99                 }
 100
 101                 case RENDERFARM_RENAME:
 102                 {
 103                         char *oldpath = (char*)buffer;
 104                         char *newpath = (char*)buffer + strlen(oldpath) + 1;
 105                         rename(oldpath, newpath);
 106 if(DEBUG)
 107 printf("RenderFarmFSServer::handle_request old=%s new=%s\n", oldpath, newpath);
 108                         result = 1;
 109                         break;
 110                 }
 111
 112                 case RENDERFARM_FGETC:
 113                 {
 114                         int64_t pointer = READ_INT64((unsigned char*)buffer);
 115                         FILE *file = (FILE*)Units::int64_to_ptr(pointer);
 116                         unsigned char datagram[1];
 117                         datagram[0] = fgetc(file);
 118                         server->write_socket((char*)datagram, 1, RENDERFARM_TIMEOUT);
 119 if(DEBUG)
 120 printf("RenderFarmFSServer::handle_request file=%p\n", file);
 121                         result = 1;
 122                         break;
 123                 }
 124
 125                 case RENDERFARM_FPUTC:
 126                 {
 127                         int64_t pointer = READ_INT64((unsigned char*)buffer);
 128                         FILE *file = (FILE*)Units::int64_to_ptr(pointer);
 129                         fputc(buffer[8], file);
 130                         result = 1;
 131 if(DEBUG)
 132 printf("RenderFarmFSServer::handle_request file=%p\n", file);
 133                         break;
 134                 }
 135
 136                 case RENDERFARM_FREAD:
 137                 {
 138                         int64_t pointer = READ_INT64((unsigned char*)buffer);
 139                         FILE *file = (FILE*)Units::int64_to_ptr(pointer);
 140                         int size = READ_INT32((unsigned char*)buffer + 8);
 141                         int num = READ_INT32((unsigned char*)buffer + 12);
 142                         unsigned char datagram[4];
 143                         int i = 0;
 144                         int bytes;
 145 // printf("RenderFarmFSServer::handle_request RENDERFARM_FREAD %02x%02x%02x%02x%02x%02x%02x%02x %p %d %d\n",
 146 // buffer[0], buffer[1], buffer[2], buffer[3], buffer[4], buffer[5], buffer[6], buffer[7],
 147 // pointer,
 148 // file,
 149 // size,
 150 // num);
 151
 152                         server->reallocate_buffer(size * num);
 153                         bytes = fread(server->buffer, size, num, file);
 154                         STORE_INT32(bytes);
 155                         server->write_socket((char*)datagram, 4, RENDERFARM_TIMEOUT);
 156                         server->write_socket((char*)server->buffer, size * bytes, RENDERFARM_TIMEOUT);
 157                         result = 1;
 158 if(DEBUG)
 159 printf("RenderFarmFSServer::handle_request file=%p size=%d num=%d bytes=%d\n",
 160 file, size, num, bytes);
 161                         break;
 162                 }
 163
 164                 case RENDERFARM_FGETS:
 165                 {
 166                         int64_t pointer = READ_INT64((unsigned char*)buffer);
 167                         FILE *file = (FILE*)Units::int64_to_ptr(pointer);
 168                         int size = READ_INT32((unsigned char*)buffer + 8);
 169                         unsigned char datagram[4];
 170                         int i = 0;
 171
 172                         server->reallocate_buffer(size);
 173                         char *return_value = fgets((char*)server->buffer, size, file);
 174                         int bytes = 0;
 175                         if(return_value)
 176                         {
 177                                 bytes = strlen(return_value) + 1;
 178                         }
 179                         STORE_INT32(bytes);
 180                         server->write_socket((char*)datagram, 4, RENDERFARM_TIMEOUT);
 181                         server->write_socket((char*)server->buffer, bytes, RENDERFARM_TIMEOUT);
 182                         result = 1;
 183                         break;
 184                 }
 185
 186                 case RENDERFARM_FILENO:
 187                 {
 188                         int64_t pointer = READ_INT64((unsigned char*)buffer);
 189                         FILE *file = (FILE*)Units::int64_to_ptr(pointer);
 190                         unsigned char datagram[4];
 191                         int i = 0;
 192
 193                         int return_value = fileno(file);
 194                         STORE_INT32(return_value);
 195                         server->write_socket((char*)datagram, 4, RENDERFARM_TIMEOUT);
 196 if(DEBUG)
 197 printf("RenderFarmFSServer::handle_request file=%p fileno=%d\n",
 198 file, return_value);
 199                         result = 1;
 200                         break;
 201                 }
 202
 203                 case RENDERFARM_FWRITE:
 204                 {
 205                         int64_t pointer = READ_INT64((unsigned char*)buffer);
 206                         FILE *file = (FILE*)Units::int64_to_ptr(pointer);
 207                         int size = READ_INT32((unsigned char*)buffer + 8);
 208                         int num = READ_INT32((unsigned char*)buffer + 12);
 209                         unsigned char datagram[4];
 210                         int i = 0;
 211                         int bytes;
 212
 213                         server->reallocate_buffer(size * num);
 214                         server->read_socket((char*)server->buffer, size * num, RENDERFARM_TIMEOUT);
 215                         bytes = fwrite(server->buffer, size, num, file);
 216                         STORE_INT32(bytes);
 217                         server->write_socket((char*)datagram, 4, RENDERFARM_TIMEOUT);
 218                         result = 1;
 219 if(DEBUG)
 220 printf("RenderFarmFSServer::handle_request RENDERFARM_FWRITE file=%p size=%d num=%d bytes=%d\n",
 221 file, size, num, bytes);
 222                         break;
 223                 }
 224
 225                 case RENDERFARM_FSEEK:
 226                 {
 227                         int64_t pointer = READ_INT64((unsigned char*)buffer);
 228                         FILE *file = (FILE*)Units::int64_to_ptr(pointer);
 229 // printf("RENDERFARM_FSEEK 1 buffer=%02x%02x%02x%02x%02x%02x%02x%02x %p %llx\n",
 230 // buffer[0], buffer[1], buffer[2], buffer[3], buffer[4], buffer[5], buffer[6], buffer[7],  file, pointer);
 231                         int64_t offset = READ_INT64((unsigned char*)buffer + 8);
 232                         int whence = READ_INT32((unsigned char*)buffer + 16);
 233                         int return_value;
 234                         unsigned char datagram[4];
 235                         int i = 0;
 236
 237                         return_value = fseeko64(file, offset, whence);
 238                         STORE_INT32(return_value);
 239                         server->write_socket((char*)datagram, 4, RENDERFARM_TIMEOUT);
 240                         result = 1;
 241 if(DEBUG)
 242 printf("RenderFarmFSServer::handle_request file=%p offset=" _LD " whence=%d result=%d\n",
 243 file, offset, whence, result);
 244                         break;
 245                 }
 246
 247                 case RENDERFARM_FTELL:
 248                 {
 249                         int64_t pointer = READ_INT64((unsigned char*)buffer);
 250                         FILE *file = (FILE*)Units::int64_to_ptr(pointer);
 251                         unsigned char datagram[8];
 252                         int i = 0;
 253                         int64_t return_value = ftello64(file);
 254                         STORE_INT64(return_value);
 255                         server->write_socket((char*)datagram, 8, RENDERFARM_TIMEOUT);
 256                         result = 1;
 257 if(DEBUG)
 258 printf("RenderFarmFSServer::handle_request file=%p result=" _LD "\n",
 259 file, return_value);
 260                         break;
 261                 }
 262
 263                 case RENDERFARM_STAT:
 264                 {
 265                         struct stat stat_buf;
 266                         int return_value = stat((char*)buffer, &stat_buf);
 267                         server->write_socket((char*)&stat_buf, sizeof(struct stat), RENDERFARM_TIMEOUT);
 268                         result = 1;
 269 if(DEBUG)
 270 printf("RenderFarmFSServer::handle_request path=%s result=%d\n",
 271 buffer, return_value);
 272                         break;
 273                 }
 274
 275                 case RENDERFARM_STAT64:
 276                 {
 277                         struct stat64 stat_buf;
 278                         int return_value = stat64((char*)buffer, &stat_buf);
 279                         vfs_stat_t arg;
 280                         arg.dev = stat_buf.st_dev;
 281 //                      arg.ino32 = stat_buf.__st_ino;
 282                         arg.ino = stat_buf.st_ino;
 283                         arg.nlink = stat_buf.st_nlink;
 284                         arg.mode = stat_buf.st_mode;
 285                         arg.uid = stat_buf.st_uid;
 286                         arg.gid = stat_buf.st_gid;
 287                         arg.rdev = stat_buf.st_rdev;
 288                         arg.size = stat_buf.st_size;
 289                         arg.blksize = stat_buf.st_blksize;
 290                         arg.blocks = stat_buf.st_blocks;
 291                         arg.atim = stat_buf.st_atim.tv_sec;
 292                         arg.mtim = stat_buf.st_mtim.tv_sec;
 293                         arg.ctim = stat_buf.st_ctim.tv_sec;
 294                         server->write_socket((char*)&arg, sizeof(arg), RENDERFARM_TIMEOUT);
 295                         result = 1;
 296 if(DEBUG)
 297 printf("RenderFarmFSServer::handle_request path=%s result=%d\n",
 298 buffer, return_value);
 299                         break;
 300                 }
 301         }
 302
 303         return result;
 304 }