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