ftp: formatting and typos fixes
[ffmpeg.git] / libavformat / ftp.c
1 /*
2  * Copyright (c) 2013 Lukasz Marek <lukasz.m.luki@gmail.com>
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg 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 GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 #include <stdlib.h>
22 #include "libavutil/avstring.h"
23 #include "libavutil/avassert.h"
24 #include "avformat.h"
25 #include "internal.h"
26 #include "network.h"
27 #include "os_support.h"
28 #include "url.h"
29 #include "libavutil/opt.h"
30
31 #define CONTROL_BUFFER_SIZE 1024
32
33 typedef enum {
34     UNKNOWN,
35     READY,
36     DOWNLOADING,
37     UPLOADING,
38     DISCONNECTED
39 } FTPState;
40
41
42 typedef struct {
43     const AVClass *class;
44     URLContext *conn_control;                    /**< Control connection */
45     int conn_control_block_flag;                 /**< Controls block/unblock mode of data connection */
46     AVIOInterruptCB conn_control_interrupt_cb;   /**< Controls block/unblock mode of data connection */
47     URLContext *conn_data;                       /**< Data connection, NULL when not connected */
48     uint8_t control_buffer[CONTROL_BUFFER_SIZE]; /**< Control connection buffer */
49     uint8_t *control_buf_ptr, *control_buf_end;
50     int server_data_port;                        /**< Data connection port opened by server, -1 on error. */
51     char hostname[512];                          /**< Server address. */
52     char path[MAX_URL_SIZE];                     /**< Path to resource on server. */
53     int64_t filesize;                            /**< Size of file on server, -1 on error. */
54     int64_t position;                            /**< Current position, calculated. */
55     int rw_timeout;                              /**< Network timeout. */
56     const char *anonymous_password;              /**< Password to be used for anonymous user. An email should be used. */
57     int write_seekable;                          /**< Control seekability, 0 = disable, 1 = enable. */
58     FTPState state;                              /**< State of data connection */
59 } FTPContext;
60
61 #define OFFSET(x) offsetof(FTPContext, x)
62 #define D AV_OPT_FLAG_DECODING_PARAM
63 #define E AV_OPT_FLAG_ENCODING_PARAM
64 static const AVOption options[] = {
65     {"timeout", "set timeout of socket I/O operations", OFFSET(rw_timeout), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, D|E },
66     {"ftp-write-seekable", "control seekability of connection during encoding", OFFSET(write_seekable), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, E },
67     {"ftp-anonymous-password", "password for anonymous login. E-mail address should be used.", OFFSET(anonymous_password), AV_OPT_TYPE_STRING, { 0 }, 0, 0, D|E },
68     {NULL}
69 };
70
71 static const AVClass ftp_context_class = {
72     .class_name     = "ftp",
73     .item_name      = av_default_item_name,
74     .option         = options,
75     .version        = LIBAVUTIL_VERSION_INT,
76 };
77
78 static int ftp_conn_control_block_control(void *data)
79 {
80     FTPContext *s = data;
81     return s->conn_control_block_flag;
82 }
83
84 static int ftp_getc(FTPContext *s)
85 {
86     int len;
87     if (s->control_buf_ptr >= s->control_buf_end) {
88         if (s->conn_control_block_flag)
89             return AVERROR_EXIT;
90         len = ffurl_read(s->conn_control, s->control_buffer, CONTROL_BUFFER_SIZE);
91         if (len < 0) {
92             return len;
93         } else if (!len) {
94             return -1;
95         } else {
96             s->control_buf_ptr = s->control_buffer;
97             s->control_buf_end = s->control_buffer + len;
98         }
99     }
100     return *s->control_buf_ptr++;
101 }
102
103 static int ftp_get_line(FTPContext *s, char *line, int line_size)
104 {
105     int ch;
106     char *q = line;
107     int ori_block_flag = s->conn_control_block_flag;
108
109     for (;;) {
110         ch = ftp_getc(s);
111         if (ch < 0) {
112             s->conn_control_block_flag = ori_block_flag;
113             return ch;
114         }
115         if (ch == '\n') {
116             /* process line */
117             if (q > line && q[-1] == '\r')
118                 q--;
119             *q = '\0';
120
121             s->conn_control_block_flag = ori_block_flag;
122             return 0;
123         } else {
124             s->conn_control_block_flag = 0; /* line need to be finished */
125             if ((q - line) < line_size - 1)
126                 *q++ = ch;
127         }
128     }
129 }
130
131 /*
132  * This routine returns ftp server response code.
133  * Server may send more than one response for a certain command, following priorities are used:
134  *   - 5xx code is returned if occurred. (means error)
135  *   - When pref_code is set then pref_code is return if occurred. (expected result)
136  *   - The lowest code is returned. (means success)
137  */
138 static int ftp_status(FTPContext *s, int *major, int *minor, int *extra, char **line, int pref_code)
139 {
140     int err, result = -1, pref_code_found = 0;
141     char buf[CONTROL_BUFFER_SIZE];
142     unsigned char d_major, d_minor, d_extra;
143
144     /* Set blocking mode */
145     s->conn_control_block_flag = 0;
146     for (;;) {
147         if ((err = ftp_get_line(s, buf, CONTROL_BUFFER_SIZE)) < 0) {
148             if (err == AVERROR_EXIT)
149                 return result;
150             return err;
151         }
152
153         if (strlen(buf) < 3)
154             continue;
155         d_major = buf[0];
156         if (d_major < '1' || d_major > '6' || d_major == '4')
157             continue;
158         d_minor = buf[1];
159         if (d_minor < '0' || d_minor > '9')
160             continue;
161         d_extra = buf[2];
162         if (d_extra < '0' || d_extra > '9')
163             continue;
164
165         av_log(s, AV_LOG_DEBUG, "%s\n", buf);
166
167         err = d_major * 100 + d_minor * 10 + d_extra - 111 * '0';
168
169         if ((result < 0 || err < result || pref_code == err) && !pref_code_found || d_major == '5') {
170             if (pref_code == err || d_major == '5')
171                 pref_code_found = 1;
172             result = err;
173             if (major)
174                 *major = d_major - '0';
175             if (minor)
176                 *minor = d_minor - '0';
177             if (extra)
178                 *extra = d_extra - '0';
179             if (line)
180                 *line = av_strdup(buf);
181         }
182
183         /* first code received. Now get all lines in non blocking mode */
184         if (pref_code < 0 || pref_code_found)
185             s->conn_control_block_flag = 1;
186     }
187     return result;
188 }
189
190 static int ftp_auth(FTPContext *s, char *auth)
191 {
192     const char *user = NULL, *pass = NULL;
193     char *end = NULL, buf[CONTROL_BUFFER_SIZE];
194     int err;
195     av_assert2(auth);
196
197     user = av_strtok(auth, ":", &end);
198     pass = av_strtok(end, ":", &end);
199
200     if (user) {
201         snprintf(buf, sizeof(buf), "USER %s\r\n", user);
202         if ((err = ffurl_write(s->conn_control, buf, strlen(buf))) < 0)
203             return err;
204         ftp_status(s, &err, NULL, NULL, NULL, -1);
205         if (err == 3) {
206             if (pass) {
207                 snprintf(buf, sizeof(buf), "PASS %s\r\n", pass);
208                 if ((err = ffurl_write(s->conn_control, buf, strlen(buf))) < 0)
209                     return err;
210                 ftp_status(s, &err, NULL, NULL, NULL, -1);
211             } else
212                 return AVERROR(EACCES);
213         }
214         if (err != 2) {
215             return AVERROR(EACCES);
216         }
217     } else {
218         const char* command = "USER anonymous\r\n";
219         if ((err = ffurl_write(s->conn_control, command, strlen(command))) < 0)
220             return err;
221         ftp_status(s, &err, NULL, NULL, NULL, -1);
222         if (err == 3) {
223             if (s->anonymous_password) {
224                 snprintf(buf, sizeof(buf), "PASS %s\r\n", s->anonymous_password);
225             } else
226                 snprintf(buf, sizeof(buf), "PASS nopassword\r\n");
227             if ((err = ffurl_write(s->conn_control, buf, strlen(buf))) < 0)
228                 return err;
229             ftp_status(s, &err, NULL, NULL, NULL, -1);
230         }
231         if (err != 2) {
232             return AVERROR(EACCES);
233         }
234     }
235
236     return 0;
237 }
238
239 static int ftp_passive_mode(FTPContext *s)
240 {
241     char *res = NULL, *start, *end;
242     int err, i;
243     const char *command = "PASV\r\n";
244
245     if ((err = ffurl_write(s->conn_control, command, strlen(command))) < 0)
246         return err;
247     if (ftp_status(s, NULL, NULL, NULL, &res, 227) != 227)
248         goto fail;
249
250     start = NULL;
251     for (i = 0; i < strlen(res); ++i) {
252         if (res[i] == '(') {
253             start = res + i + 1;
254         } else if (res[i] == ')') {
255             end = res + i;
256             break;
257         }
258     }
259     if (!start || !end)
260         goto fail;
261
262     *end  = '\0';
263     /* skip ip */
264     if (!av_strtok(start, ",", &end)) goto fail;
265     if (!av_strtok(end, ",", &end)) goto fail;
266     if (!av_strtok(end, ",", &end)) goto fail;
267     if (!av_strtok(end, ",", &end)) goto fail;
268
269     /* parse port number */
270     start = av_strtok(end, ",", &end);
271     if (!start) goto fail;
272     s->server_data_port = atoi(start) * 256;
273     start = av_strtok(end, ",", &end);
274     if (!start) goto fail;
275     s->server_data_port += atoi(start);
276     av_dlog(s, "Server data port: %d\n", s->server_data_port);
277
278     av_free(res);
279     return 0;
280
281   fail:
282     av_free(res);
283     s->server_data_port = -1;
284     return AVERROR(EIO);
285 }
286
287 static int ftp_current_dir(FTPContext *s)
288 {
289     char *res = NULL, *start = NULL, *end = NULL;
290     int err, i;
291     const char *command = "PWD\r\n";
292
293     if ((err = ffurl_write(s->conn_control, command, strlen(command))) < 0)
294         return err;
295     if (ftp_status(s, NULL, NULL, NULL, &res, 257) != 257)
296         goto fail;
297
298     for (i = 0; res[i]; ++i) {
299         if (res[i] == '"') {
300             if (!start) {
301                 start = res + i + 1;
302                 continue;
303             }
304             end = res + i;
305             break;
306         }
307     }
308
309     if (!end)
310         goto fail;
311
312     if (end > res && end[-1] == '/') {
313         end[-1] = '\0';
314     } else
315         *end = '\0';
316     av_strlcpy(s->path, start, sizeof(s->path));
317
318     av_free(res);
319     return 0;
320
321   fail:
322     av_free(res);
323     return AVERROR(EIO);
324 }
325
326 static int ftp_file_size(FTPContext *s)
327 {
328     char buf[CONTROL_BUFFER_SIZE];
329     int err;
330     char *res = NULL;
331
332     snprintf(buf, sizeof(buf), "SIZE %s\r\n", s->path);
333     if ((err = ffurl_write(s->conn_control, buf, strlen(buf))) < 0)
334         return err;
335     if (ftp_status(s, NULL, NULL, NULL, &res, 213) == 213) {
336         s->filesize = strtoll(&res[4], NULL, 10);
337     } else {
338         s->filesize = -1;
339         av_free(res);
340         return AVERROR(EIO);
341     }
342
343     av_free(res);
344     return 0;
345 }
346
347 static int ftp_retrieve(FTPContext *s)
348 {
349     char buf[CONTROL_BUFFER_SIZE];
350     int err;
351
352     snprintf(buf, sizeof(buf), "RETR %s\r\n", s->path);
353     if ((err = ffurl_write(s->conn_control, buf, strlen(buf))) < 0)
354         return err;
355     if (ftp_status(s, NULL, NULL, NULL, NULL, 150) != 150)
356         return AVERROR(EIO);
357
358     s->state = DOWNLOADING;
359
360     return 0;
361 }
362
363 static int ftp_store(FTPContext *s)
364 {
365     char buf[CONTROL_BUFFER_SIZE];
366     int err;
367
368     snprintf(buf, sizeof(buf), "STOR %s\r\n", s->path);
369     if ((err = ffurl_write(s->conn_control, buf, strlen(buf))) < 0)
370         return err;
371     if (ftp_status(s, NULL, NULL, NULL, NULL, 150) != 150)
372         return AVERROR(EIO);
373
374     s->state = UPLOADING;
375
376     return 0;
377 }
378
379 static int ftp_send_command(FTPContext *s, const char* command)
380 {
381     int err;
382
383     if ((err = ffurl_write(s->conn_control, command, strlen(command))) < 0)
384         return err;
385     ftp_status(s, &err, NULL, NULL, NULL, -1);
386     if (err != 2)
387         return AVERROR(EIO);
388
389     return 0;
390 }
391
392 static int ftp_reconnect_data_connection(URLContext *h)
393 {
394     int err;
395     char buf[CONTROL_BUFFER_SIZE], opts_format[20];
396     AVDictionary *opts = NULL;
397     FTPContext *s = h->priv_data;
398
399     if (!s->conn_data) {
400         ff_url_join(buf, sizeof(buf), "tcp", NULL, s->hostname, s->server_data_port, NULL);
401         if (s->rw_timeout != -1) {
402             snprintf(opts_format, sizeof(opts_format), "%d", s->rw_timeout);
403             av_dict_set(&opts, "timeout", opts_format, 0);
404         } /* if option is not given, don't pass it and let tcp use its own default */
405         err = ffurl_open(&s->conn_data, buf, AVIO_FLAG_READ_WRITE,
406                          &h->interrupt_callback, &opts);
407         av_dict_free(&opts);
408         if (err < 0)
409             return err;
410     }
411     s->state = READY;
412     s->position = 0;
413     return 0;
414 }
415
416 static int ftp_open(URLContext *h, const char *url, int flags)
417 {
418     char proto[10], auth[1024], path[MAX_URL_SIZE], buf[CONTROL_BUFFER_SIZE], opts_format[20];
419     AVDictionary *opts = NULL;
420     int port, err;
421     FTPContext *s = h->priv_data;
422
423     av_dlog(h, "ftp protocol open\n");
424
425     s->state = DISCONNECTED;
426     s->filesize = -1;
427     s->conn_control_interrupt_cb.opaque = s;
428     s->conn_control_interrupt_cb.callback = ftp_conn_control_block_control;
429
430     av_url_split(proto, sizeof(proto),
431                  auth, sizeof(auth),
432                  s->hostname, sizeof(s->hostname),
433                  &port,
434                  path, sizeof(path),
435                  url);
436
437     if (port < 0)
438         port = 21;
439
440     if (!s->conn_control) {
441         ff_url_join(buf, sizeof(buf), "tcp", NULL, s->hostname, port, NULL);
442         if (s->rw_timeout != -1) {
443             snprintf(opts_format, sizeof(opts_format), "%d", s->rw_timeout);
444             av_dict_set(&opts, "timeout", opts_format, 0);
445         } /* if option is not given, don't pass it and let tcp use its own default */
446         err = ffurl_open(&s->conn_control, buf, AVIO_FLAG_READ_WRITE,
447                          &s->conn_control_interrupt_cb, &opts);
448         av_dict_free(&opts);
449         if (err < 0)
450             goto fail;
451
452         /* consume all messages from server */
453         if (ftp_status(s, NULL, NULL, NULL, NULL, 220) != 220) {
454             av_log(h, AV_LOG_ERROR, "Server not ready for new users\n");
455             err = AVERROR(EACCES);
456             goto fail;
457         }
458
459         if ((err = ftp_auth(s, auth)) < 0)
460             goto fail;
461
462         if ((err = ftp_send_command(s, "TYPE I\r\n")) < 0)
463             goto fail;
464
465         if ((err = ftp_current_dir(s)) < 0)
466             goto fail;
467         av_strlcat(s->path, path, sizeof(s->path));
468
469         if ((err = ftp_passive_mode(s)) < 0)
470             goto fail;
471
472         if (ftp_file_size(s) < 0 && flags & AVIO_FLAG_READ)
473             h->is_streamed = 1;
474         if (s->write_seekable != 1 && flags & AVIO_FLAG_WRITE)
475             h->is_streamed = 1;
476     }
477
478     if ((err = ftp_reconnect_data_connection(h)) < 0)
479         goto fail;
480
481     return 0;
482   fail:
483     av_log(h, AV_LOG_ERROR, "FTP open failed\n");
484     ffurl_closep(&s->conn_control);
485     ffurl_closep(&s->conn_data);
486     return err;
487 }
488
489 static int ftp_read(URLContext *h, unsigned char *buf, int size)
490 {
491     FTPContext *s = h->priv_data;
492     int read;
493
494     av_dlog(h, "ftp protocol read %d bytes\n", size);
495
496     if (s->state == READY) {
497         ftp_retrieve(s);
498     }
499     if (s->conn_data && s->state == DOWNLOADING) {
500         read = ffurl_read(s->conn_data, buf, size);
501         if (read >= 0) {
502             s->position += read;
503             if (s->position >= s->filesize) {
504                 ffurl_closep(&s->conn_data);
505                 s->state = DISCONNECTED;
506                 if (ftp_status(s, NULL, NULL, NULL,NULL, 226) != 226)
507                     return AVERROR(EIO);
508             }
509         }
510         return read;
511     }
512
513     av_log(h, AV_LOG_DEBUG, "FTP read failed\n");
514     return AVERROR(EIO);
515 }
516
517 static int ftp_write(URLContext *h, const unsigned char *buf, int size)
518 {
519     FTPContext *s = h->priv_data;
520     int written;
521
522     av_dlog(h, "ftp protocol write %d bytes\n", size);
523
524     if (s->state == READY) {
525         ftp_store(s);
526     }
527     if (s->conn_data && s->state == UPLOADING) {
528         written = ffurl_write(s->conn_data, buf, size);
529         if (written > 0) {
530             s->position += written;
531             s->filesize = FFMAX(s->filesize, s->position);
532         }
533         return written;
534     }
535
536     av_log(h, AV_LOG_ERROR, "FTP write failed\n");
537     return AVERROR(EIO);
538 }
539
540 static int64_t ftp_seek(URLContext *h, int64_t pos, int whence)
541 {
542     FTPContext *s = h->priv_data;
543     char buf[CONTROL_BUFFER_SIZE];
544     int err;
545     int64_t new_pos;
546
547     av_dlog(h, "ftp protocol seek %"PRId64" %d\n", pos, whence);
548
549     switch(whence) {
550     case AVSEEK_SIZE:
551         return s->filesize;
552     case SEEK_SET:
553         new_pos = pos;
554         break;
555     case SEEK_CUR:
556         new_pos = s->position + pos;
557         break;
558     case SEEK_END:
559         if (s->filesize < 0)
560             return AVERROR(EIO);
561         new_pos = s->filesize + pos;
562         break;
563     default:
564         return AVERROR(EINVAL);
565     }
566
567     if  (h->is_streamed)
568         return AVERROR(EIO);
569
570     if (new_pos < 0 || (s->filesize >= 0 && new_pos > s->filesize))
571         return AVERROR(EINVAL);
572
573     if (new_pos != s->position) {
574         /* close existing data connection */
575         if (s->state != READY) {
576             if (s->conn_data) {
577                 /* abort existing transfer */
578                 if (s->state == DOWNLOADING) {
579                     snprintf(buf, sizeof(buf), "ABOR\r\n");
580                     if ((err = ffurl_write(s->conn_control, buf, strlen(buf))) < 0)
581                         return err;
582                 }
583                 ffurl_closep(&s->conn_data);
584                 s->state = DISCONNECTED;
585                 /* Servers return 225 or 226 */
586                 ftp_status(s, &err, NULL, NULL, NULL, -1);
587                 if (err != 2)
588                     return AVERROR(EIO);
589             }
590
591             /* set passive */
592             if ((err = ftp_passive_mode(s)) < 0)
593                 return err;
594
595             /* open new data connection */
596             if ((err = ftp_reconnect_data_connection(h)) < 0)
597                 return err;
598         }
599
600         /* resume from pos position */
601         snprintf(buf, sizeof(buf), "REST %"PRId64"\r\n", pos);
602         if ((err = ffurl_write(s->conn_control, buf, strlen(buf))) < 0)
603             return err;
604         if (ftp_status(s, NULL, NULL, NULL, NULL, 350) != 350)
605             return AVERROR(EIO);
606
607         s->position = pos;
608     }
609     return new_pos;
610 }
611
612 static int ftp_close(URLContext *h)
613 {
614     FTPContext *s = h->priv_data;
615
616     av_dlog(h, "ftp protocol close\n");
617
618     ffurl_closep(&s->conn_control);
619     ffurl_closep(&s->conn_data);
620
621     return 0;
622 }
623
624 static int ftp_get_file_handle(URLContext *h)
625 {
626     FTPContext *s = h->priv_data;
627
628     av_dlog(h, "ftp protocol get_file_handle\n");
629
630     if (s->conn_data)
631         return ffurl_get_file_handle(s->conn_data);
632
633     return AVERROR(EIO);
634 }
635
636 static int ftp_shutdown(URLContext *h, int flags)
637 {
638     FTPContext *s = h->priv_data;
639
640     av_dlog(h, "ftp protocol shutdown\n");
641
642     if (s->conn_data)
643         return ffurl_shutdown(s->conn_data, flags);
644
645     return AVERROR(EIO);
646 }
647
648 URLProtocol ff_ftp_protocol = {
649     .name                = "ftp",
650     .url_open            = ftp_open,
651     .url_read            = ftp_read,
652     .url_write           = ftp_write,
653     .url_seek            = ftp_seek,
654     .url_close           = ftp_close,
655     .url_get_file_handle = ftp_get_file_handle,
656     .url_shutdown        = ftp_shutdown,
657     .priv_data_size      = sizeof(FTPContext),
658     .priv_data_class     = &ftp_context_class,
659     .flags               = URL_PROTOCOL_FLAG_NETWORK,
660 };