add bluray dv, misc fixes
[goodguy/history.git] / cinelerra-5.1 / 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 "renderfarm.h"
23 #include "renderfarmfsserver.h"
24 #include "units.h"
25
26
27 #include <string.h>
28 #include <sys/stat.h>
29
30 #define DEBUG 0
31
32 RenderFarmFSServer::RenderFarmFSServer(RenderFarmServerThread *server)
33 {
34         this->server = server;
35 }
36
37
38
39 RenderFarmFSServer::~RenderFarmFSServer()
40 {
41 }
42
43 void RenderFarmFSServer::initialize()
44 {
45 }
46
47 int RenderFarmFSServer::handle_request(int request_id, int request_size, unsigned char *buffer)
48 {
49         int result = 0;
50
51 if(DEBUG)
52 printf("RenderFarmFSServer::handle_request request_id=%d\n", request_id);
53         switch(request_id)
54         {
55                 case RENDERFARM_FOPEN:
56                 {
57                         char *path;
58                         char *mode;
59                         FILE *file;
60                         unsigned char datagram[8];
61                         int i = 0;
62                         int64_t file_int64;
63
64
65                         path = (char*)buffer;
66                         mode = (char*)buffer + strlen(path) + 1;
67
68
69                         file = fopen64(path, mode);
70                         file_int64 = Units::ptr_to_int64(file);
71                         STORE_INT64(file_int64);
72                         server->write_socket((char*)datagram, 8, RENDERFARM_TIMEOUT);
73 if(DEBUG)
74 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",
75 file, file_int64, datagram[0], datagram[1], datagram[2], datagram[3], datagram[4], datagram[5], datagram[6], datagram[7], path, mode);
76                         result = 1;
77                         break;
78                 }
79
80                 case RENDERFARM_FCLOSE:
81                 {
82                         int64_t pointer = READ_INT64((unsigned char*)buffer);
83                         FILE *file = (FILE*)Units::int64_to_ptr(pointer);
84 if(DEBUG)
85 printf("RenderFarmFSServer::handle_request RENDERFARM_FCLOSE file=%p\n", file);
86                         fclose(file);
87                         result = 1;
88                         break;
89                 }
90
91                 case RENDERFARM_REMOVE:
92                 {
93                         remove((char*)buffer);
94 if(DEBUG)
95 printf("RenderFarmFSServer::handle_request path=%s\n", buffer);
96                         result = 1;
97                         break;
98                 }
99
100                 case RENDERFARM_RENAME:
101                 {
102                         char *oldpath = (char*)buffer;
103                         char *newpath = (char*)buffer + strlen(oldpath) + 1;
104                         rename(oldpath, newpath);
105 if(DEBUG)
106 printf("RenderFarmFSServer::handle_request old=%s new=%s\n", oldpath, newpath);
107                         result = 1;
108                         break;
109                 }
110
111                 case RENDERFARM_FGETC:
112                 {
113                         int64_t pointer = READ_INT64((unsigned char*)buffer);
114                         FILE *file = (FILE*)Units::int64_to_ptr(pointer);
115                         unsigned char datagram[1];
116                         datagram[0] = fgetc(file);
117                         server->write_socket((char*)datagram, 1, RENDERFARM_TIMEOUT);
118 if(DEBUG)
119 printf("RenderFarmFSServer::handle_request file=%p\n", file);
120                         result = 1;
121                         break;
122                 }
123
124                 case RENDERFARM_FPUTC:
125                 {
126                         int64_t pointer = READ_INT64((unsigned char*)buffer);
127                         FILE *file = (FILE*)Units::int64_to_ptr(pointer);
128                         fputc(buffer[8], file);
129                         result = 1;
130 if(DEBUG)
131 printf("RenderFarmFSServer::handle_request file=%p\n", file);
132                         break;
133                 }
134
135                 case RENDERFARM_FREAD:
136                 {
137                         int64_t pointer = READ_INT64((unsigned char*)buffer);
138                         FILE *file = (FILE*)Units::int64_to_ptr(pointer);
139                         int size = READ_INT32((unsigned char*)buffer + 8);
140                         int num = READ_INT32((unsigned char*)buffer + 12);
141                         unsigned char datagram[4];
142                         int i = 0;
143                         int bytes;
144 // printf("RenderFarmFSServer::handle_request RENDERFARM_FREAD %02x%02x%02x%02x%02x%02x%02x%02x %p %d %d\n",
145 // buffer[0], buffer[1], buffer[2], buffer[3], buffer[4], buffer[5], buffer[6], buffer[7],
146 // pointer,
147 // file,
148 // size,
149 // num);
150
151                         server->reallocate_buffer(size * num);
152                         bytes = fread(server->buffer, size, num, file);
153                         STORE_INT32(bytes);
154                         server->write_socket((char*)datagram, 4, RENDERFARM_TIMEOUT);
155                         server->write_socket((char*)server->buffer, size * bytes, RENDERFARM_TIMEOUT);
156                         result = 1;
157 if(DEBUG)
158 printf("RenderFarmFSServer::handle_request file=%p size=%d num=%d bytes=%d\n",
159 file, size, num, bytes);
160                         break;
161                 }
162
163                 case RENDERFARM_FGETS:
164                 {
165                         int64_t pointer = READ_INT64((unsigned char*)buffer);
166                         FILE *file = (FILE*)Units::int64_to_ptr(pointer);
167                         int size = READ_INT32((unsigned char*)buffer + 8);
168                         unsigned char datagram[4];
169                         int i = 0;
170
171                         server->reallocate_buffer(size);
172                         char *return_value = fgets((char*)server->buffer, size, file);
173                         int bytes = 0;
174                         if(return_value)
175                         {
176                                 bytes = strlen(return_value) + 1;
177                         }
178                         STORE_INT32(bytes);
179                         server->write_socket((char*)datagram, 4, RENDERFARM_TIMEOUT);
180                         server->write_socket((char*)server->buffer, bytes, RENDERFARM_TIMEOUT);
181                         result = 1;
182                         break;
183                 }
184
185                 case RENDERFARM_FILENO:
186                 {
187                         int64_t pointer = READ_INT64((unsigned char*)buffer);
188                         FILE *file = (FILE*)Units::int64_to_ptr(pointer);
189                         unsigned char datagram[4];
190                         int i = 0;
191
192                         int return_value = fileno(file);
193                         STORE_INT32(return_value);
194                         server->write_socket((char*)datagram, 4, RENDERFARM_TIMEOUT);
195 if(DEBUG)
196 printf("RenderFarmFSServer::handle_request file=%p fileno=%d\n",
197 file, return_value);
198                         result = 1;
199                         break;
200                 }
201
202                 case RENDERFARM_FWRITE:
203                 {
204                         int64_t pointer = READ_INT64((unsigned char*)buffer);
205                         FILE *file = (FILE*)Units::int64_to_ptr(pointer);
206                         int size = READ_INT32((unsigned char*)buffer + 8);
207                         int num = READ_INT32((unsigned char*)buffer + 12);
208                         unsigned char datagram[4];
209                         int i = 0;
210                         int bytes;
211
212                         server->reallocate_buffer(size * num);
213                         server->read_socket((char*)server->buffer, size * num, RENDERFARM_TIMEOUT);
214                         bytes = fwrite(server->buffer, size, num, file);
215                         STORE_INT32(bytes);
216                         server->write_socket((char*)datagram, 4, RENDERFARM_TIMEOUT);
217                         result = 1;
218 if(DEBUG)
219 printf("RenderFarmFSServer::handle_request RENDERFARM_FWRITE file=%p size=%d num=%d bytes=%d\n",
220 file, size, num, bytes);
221                         break;
222                 }
223
224                 case RENDERFARM_FSEEK:
225                 {
226                         int64_t pointer = READ_INT64((unsigned char*)buffer);
227                         FILE *file = (FILE*)Units::int64_to_ptr(pointer);
228 // printf("RENDERFARM_FSEEK 1 buffer=%02x%02x%02x%02x%02x%02x%02x%02x %p %llx\n",
229 // buffer[0], buffer[1], buffer[2], buffer[3], buffer[4], buffer[5], buffer[6], buffer[7],  file, pointer);
230                         int64_t offset = READ_INT64((unsigned char*)buffer + 8);
231                         int whence = READ_INT32((unsigned char*)buffer + 16);
232                         int return_value;
233                         unsigned char datagram[4];
234                         int i = 0;
235
236                         return_value = fseeko64(file, offset, whence);
237                         STORE_INT32(return_value);
238                         server->write_socket((char*)datagram, 4, RENDERFARM_TIMEOUT);
239                         result = 1;
240 if(DEBUG)
241 printf("RenderFarmFSServer::handle_request file=%p offset=%jd whence=%d result=%d\n",
242 file, offset, whence, result);
243                         break;
244                 }
245
246                 case RENDERFARM_FTELL:
247                 {
248                         int64_t pointer = READ_INT64((unsigned char*)buffer);
249                         FILE *file = (FILE*)Units::int64_to_ptr(pointer);
250                         unsigned char datagram[8];
251                         int i = 0;
252                         int64_t return_value = ftello64(file);
253                         STORE_INT64(return_value);
254                         server->write_socket((char*)datagram, 8, RENDERFARM_TIMEOUT);
255                         result = 1;
256 if(DEBUG)
257 printf("RenderFarmFSServer::handle_request file=%p result=%jd\n",
258 file, return_value);
259                         break;
260                 }
261
262                 case RENDERFARM_STAT:
263                 {
264                         struct stat stat_buf;
265                         int return_value = stat((char*)buffer, &stat_buf);
266                         server->write_socket((char*)&stat_buf, sizeof(struct stat), RENDERFARM_TIMEOUT);
267                         result = 1;
268 if(DEBUG)
269 printf("RenderFarmFSServer::handle_request path=%s result=%d\n",
270 buffer, return_value);
271                         break;
272                 }
273
274                 case RENDERFARM_STAT64:
275                 {
276                         struct stat64 stat_buf;
277                         int return_value = stat64((char*)buffer, &stat_buf);
278                         vfs_stat_t arg;
279                         arg.dev = stat_buf.st_dev;
280 //                      arg.ino32 = stat_buf.__st_ino;
281                         arg.ino = stat_buf.st_ino;
282                         arg.nlink = stat_buf.st_nlink;
283                         arg.mode = stat_buf.st_mode;
284                         arg.uid = stat_buf.st_uid;
285                         arg.gid = stat_buf.st_gid;
286                         arg.rdev = stat_buf.st_rdev;
287                         arg.size = stat_buf.st_size;
288                         arg.blksize = stat_buf.st_blksize;
289                         arg.blocks = stat_buf.st_blocks;
290                         arg.atim = stat_buf.st_atim.tv_sec;
291                         arg.mtim = stat_buf.st_mtim.tv_sec;
292                         arg.ctim = stat_buf.st_ctim.tv_sec;
293                         server->write_socket((char*)&arg, sizeof(arg), RENDERFARM_TIMEOUT);
294                         result = 1;
295 if(DEBUG)
296 printf("RenderFarmFSServer::handle_request path=%s result=%d\n",
297 buffer, return_value);
298                         break;
299                 }
300         }
301
302         return result;
303 }