2 * Copyright (c) 2013 Lukasz Marek <lukasz.m.luki@gmail.com>
4 * This file is part of FFmpeg.
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.
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.
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
22 #include "libavutil/avstring.h"
23 #include "libavutil/time.h"
27 #include "os_support.h"
29 #include "libavutil/opt.h"
31 #define CONTROL_BUFFER_SIZE 1024
32 #define CREDENTIALS_BUFFER_SIZE 128
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 int server_control_port; /**< Control connection port, default is 21 */
52 char hostname[512]; /**< Server address. */
53 char credencials[CREDENTIALS_BUFFER_SIZE]; /**< Authentication data */
54 char path[MAX_URL_SIZE]; /**< Path to resource on server. */
55 int64_t filesize; /**< Size of file on server, -1 on error. */
56 int64_t position; /**< Current position, calculated. */
57 int rw_timeout; /**< Network timeout. */
58 const char *anonymous_password; /**< Password to be used for anonymous user. An email should be used. */
59 int write_seekable; /**< Control seekability, 0 = disable, 1 = enable. */
60 FTPState state; /**< State of data connection */
63 #define OFFSET(x) offsetof(FTPContext, x)
64 #define D AV_OPT_FLAG_DECODING_PARAM
65 #define E AV_OPT_FLAG_ENCODING_PARAM
66 static const AVOption options[] = {
67 {"timeout", "set timeout of socket I/O operations", OFFSET(rw_timeout), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, D|E },
68 {"ftp-write-seekable", "control seekability of connection during encoding", OFFSET(write_seekable), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, E },
69 {"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 },
73 static const AVClass ftp_context_class = {
75 .item_name = av_default_item_name,
77 .version = LIBAVUTIL_VERSION_INT,
80 static int ftp_conn_control_block_control(void *data)
83 return s->conn_control_block_flag;
86 static int ftp_getc(FTPContext *s)
89 if (s->control_buf_ptr >= s->control_buf_end) {
90 if (s->conn_control_block_flag)
92 len = ffurl_read(s->conn_control, s->control_buffer, CONTROL_BUFFER_SIZE);
98 s->control_buf_ptr = s->control_buffer;
99 s->control_buf_end = s->control_buffer + len;
102 return *s->control_buf_ptr++;
105 static int ftp_get_line(FTPContext *s, char *line, int line_size)
109 int ori_block_flag = s->conn_control_block_flag;
114 s->conn_control_block_flag = ori_block_flag;
119 if (q > line && q[-1] == '\r')
123 s->conn_control_block_flag = ori_block_flag;
126 s->conn_control_block_flag = 0; /* line need to be finished */
127 if ((q - line) < line_size - 1)
133 static int ftp_flush_control_input(FTPContext *s)
135 char buf[CONTROL_BUFFER_SIZE];
136 int err, ori_block_flag = s->conn_control_block_flag;
138 s->conn_control_block_flag = 1;
140 err = ftp_get_line(s, buf, sizeof(buf));
143 s->conn_control_block_flag = ori_block_flag;
145 if (err < 0 && err != AVERROR_EXIT)
152 * This routine returns ftp server response code.
153 * Server may send more than one response for a certain command, following priorities are used:
154 * - When pref_codes are set then pref_code is return if occurred. (expected result)
155 * - 0 is returned when no pref_codes or not occurred
157 static int ftp_status(FTPContext *s, char **line, const int response_codes[])
159 int err, i, result = 0, pref_code_found = 0, wait_count = 100;
160 char buf[CONTROL_BUFFER_SIZE];
162 /* Set blocking mode */
163 s->conn_control_block_flag = 0;
165 if ((err = ftp_get_line(s, buf, sizeof(buf))) < 0) {
166 if (err == AVERROR_EXIT) {
167 if (!pref_code_found && wait_count--) {
175 av_log(s, AV_LOG_DEBUG, "%s\n", buf);
177 if (!pref_code_found) {
182 for (i = 0; i < 3; ++i) {
183 if (buf[i] < '0' || buf[i] > '9')
189 for (i = 0; response_codes[i]; ++i) {
190 if (err == response_codes[i]) {
191 /* first code received. Now get all lines in non blocking mode */
192 s->conn_control_block_flag = 1;
196 *line = av_strdup(buf);
205 static int ftp_send_command(FTPContext *s, const char *command,
206 const int response_codes[], char **response)
210 /* Flush control connection input to get rid of non relevant responses if any */
211 if ((err = ftp_flush_control_input(s)) < 0)
214 /* send command in blocking mode */
215 s->conn_control_block_flag = 0;
216 if ((err = ffurl_write(s->conn_control, command, strlen(command))) < 0)
222 if (response_codes) {
223 return ftp_status(s, response, response_codes);
228 static void ftp_close_data_connection(FTPContext *s)
230 ffurl_closep(&s->conn_data);
232 s->state = DISCONNECTED;
235 static void ftp_close_both_connections(FTPContext *s)
237 ffurl_closep(&s->conn_control);
238 ftp_close_data_connection(s);
241 static int ftp_auth(FTPContext *s)
243 const char *user = NULL, *pass = NULL;
244 char *end = NULL, buf[CONTROL_BUFFER_SIZE], credencials[CREDENTIALS_BUFFER_SIZE];
246 const int user_codes[] = {331, 230, 500, 530, 0}; /* 500, 530 are incorrect codes */
247 const int pass_codes[] = {230, 503, 530, 0}; /* 503, 530 are incorrect codes */
249 /* Authentication may be repeated, original string has to be saved */
250 av_strlcpy(credencials, s->credencials, sizeof(credencials));
252 user = av_strtok(credencials, ":", &end);
253 pass = av_strtok(end, ":", &end);
257 pass = s->anonymous_password ? s->anonymous_password : "nopassword";
260 snprintf(buf, sizeof(buf), "USER %s\r\n", user);
261 err = ftp_send_command(s, buf, user_codes, NULL);
264 snprintf(buf, sizeof(buf), "PASS %s\r\n", pass);
265 err = ftp_send_command(s, buf, pass_codes, NULL);
267 return AVERROR(EACCES);
270 return AVERROR(EACCES);
275 static int ftp_passive_mode(FTPContext *s)
277 char *res = NULL, *start = NULL, *end = NULL;
279 const char *command = "PASV\r\n";
280 const int pasv_codes[] = {227, 501, 0}; /* 501 is incorrect code */
282 if (ftp_send_command(s, command, pasv_codes, &res) != 227 || !res)
285 for (i = 0; res[i]; ++i) {
288 } else if (res[i] == ')') {
298 if (!av_strtok(start, ",", &end)) goto fail;
299 if (!av_strtok(end, ",", &end)) goto fail;
300 if (!av_strtok(end, ",", &end)) goto fail;
301 if (!av_strtok(end, ",", &end)) goto fail;
303 /* parse port number */
304 start = av_strtok(end, ",", &end);
305 if (!start) goto fail;
306 s->server_data_port = atoi(start) * 256;
307 start = av_strtok(end, ",", &end);
308 if (!start) goto fail;
309 s->server_data_port += atoi(start);
310 av_dlog(s, "Server data port: %d\n", s->server_data_port);
317 s->server_data_port = -1;
321 static int ftp_current_dir(FTPContext *s)
323 char *res = NULL, *start = NULL, *end = NULL;
325 const char *command = "PWD\r\n";
326 const int pwd_codes[] = {257, 0};
328 if (ftp_send_command(s, command, pwd_codes, &res) != 257 || !res)
331 for (i = 0; res[i]; ++i) {
345 if (end > res && end[-1] == '/') {
349 av_strlcpy(s->path, start, sizeof(s->path));
359 static int ftp_file_size(FTPContext *s)
361 char command[CONTROL_BUFFER_SIZE];
363 const int size_codes[] = {213, 501, 550, 0}; /* 501, 550 are incorrect codes */
365 snprintf(command, sizeof(command), "SIZE %s\r\n", s->path);
366 if (ftp_send_command(s, command, size_codes, &res) == 213 && res) {
367 s->filesize = strtoll(&res[4], NULL, 10);
378 static int ftp_retrieve(FTPContext *s)
380 char command[CONTROL_BUFFER_SIZE];
381 const int retr_codes[] = {150, 550, 554, 0}; /* 550, 554 are incorrect codes */
383 snprintf(command, sizeof(command), "RETR %s\r\n", s->path);
384 if (ftp_send_command(s, command, retr_codes, NULL) != 150)
387 s->state = DOWNLOADING;
392 static int ftp_store(FTPContext *s)
394 char command[CONTROL_BUFFER_SIZE];
395 const int stor_codes[] = {150, 0};
397 snprintf(command, sizeof(command), "STOR %s\r\n", s->path);
398 if (ftp_send_command(s, command, stor_codes, NULL) != 150)
401 s->state = UPLOADING;
406 static int ftp_type(FTPContext *s)
408 const char *command = "TYPE I\r\n";
409 const int type_codes[] = {200, 500, 504, 0}; /* 500, 504 are incorrect codes */
411 if (ftp_send_command(s, command, type_codes, NULL) != 200)
417 static int ftp_restart(FTPContext *s, int64_t pos)
419 char command[CONTROL_BUFFER_SIZE];
420 const int rest_codes[] = {350, 500, 501, 0}; /* 500, 501 are incorrect codes */
422 snprintf(command, sizeof(command), "REST %"PRId64"\r\n", pos);
423 if (ftp_send_command(s, command, rest_codes, NULL) != 350)
429 static int ftp_connect_control_connection(URLContext *h)
431 char buf[CONTROL_BUFFER_SIZE], opts_format[20];
433 AVDictionary *opts = NULL;
434 FTPContext *s = h->priv_data;
435 const int connect_codes[] = {220, 0};
437 s->conn_control_block_flag = 0;
439 if (!s->conn_control) {
440 ff_url_join(buf, sizeof(buf), "tcp", NULL,
441 s->hostname, s->server_control_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);
450 av_log(h, AV_LOG_ERROR, "Cannot open control connection\n");
454 /* consume all messages from server */
455 if (ftp_status(s, NULL, connect_codes) != 220) {
456 av_log(h, AV_LOG_ERROR, "FTP server not ready for new users\n");
457 return AVERROR(EACCES);
460 if ((err = ftp_auth(s)) < 0) {
461 av_log(h, AV_LOG_ERROR, "FTP authentication failed\n");
465 if ((err = ftp_type(s)) < 0) {
466 av_dlog(h, "Set content type failed\n");
473 static int ftp_connect_data_connection(URLContext *h)
476 char buf[CONTROL_BUFFER_SIZE], opts_format[20];
477 AVDictionary *opts = NULL;
478 FTPContext *s = h->priv_data;
481 /* Enter passive mode */
482 if ((err = ftp_passive_mode(s)) < 0) {
483 av_dlog(h, "Set passive mode failed\n");
486 /* Open data connection */
487 ff_url_join(buf, sizeof(buf), "tcp", NULL, s->hostname, s->server_data_port, NULL);
488 if (s->rw_timeout != -1) {
489 snprintf(opts_format, sizeof(opts_format), "%d", s->rw_timeout);
490 av_dict_set(&opts, "timeout", opts_format, 0);
491 } /* if option is not given, don't pass it and let tcp use its own default */
492 err = ffurl_open(&s->conn_data, buf, AVIO_FLAG_READ_WRITE,
493 &h->interrupt_callback, &opts);
499 if ((err = ftp_restart(s, s->position)) < 0)
506 static int ftp_abort(URLContext *h)
508 const char *command = "ABOR\r\n";
510 const int abor_codes[] = {225, 226, 0};
511 FTPContext *s = h->priv_data;
513 /* According to RCF 959:
514 "ABOR command tells the server to abort the previous FTP
515 service command and any associated transfer of data."
517 There are FTP server implementations that don't response
518 to any commands during data transfer in passive mode (including ABOR).
520 This implementation closes data connection by force.
523 if (ftp_send_command(s, command, NULL, NULL) < 0) {
524 ftp_close_both_connections(s);
525 if ((err = ftp_connect_control_connection(h)) < 0) {
526 av_log(h, AV_LOG_ERROR, "Reconnect failed.\n");
530 ftp_close_data_connection(s);
533 if (ftp_status(s, NULL, abor_codes) < 225) {
534 /* wu-ftpd also closes control connection after data connection closing */
535 ffurl_closep(&s->conn_control);
536 if ((err = ftp_connect_control_connection(h)) < 0) {
537 av_log(h, AV_LOG_ERROR, "Reconnect failed.\n");
545 static int ftp_open(URLContext *h, const char *url, int flags)
547 char proto[10], path[MAX_URL_SIZE];
549 FTPContext *s = h->priv_data;
551 av_dlog(h, "ftp protocol open\n");
553 s->state = DISCONNECTED;
556 s->conn_control_interrupt_cb.opaque = s;
557 s->conn_control_interrupt_cb.callback = ftp_conn_control_block_control;
559 av_url_split(proto, sizeof(proto),
560 s->credencials, sizeof(s->credencials),
561 s->hostname, sizeof(s->hostname),
562 &s->server_control_port,
566 if (s->server_control_port < 0 || s->server_control_port > 65535)
567 s->server_control_port = 21;
569 if ((err = ftp_connect_control_connection(h)) < 0)
572 if ((err = ftp_current_dir(s)) < 0)
574 av_strlcat(s->path, path, sizeof(s->path));
576 if (ftp_restart(s, 0) < 0) {
579 if (ftp_file_size(s) < 0 && flags & AVIO_FLAG_READ)
581 if (s->write_seekable != 1 && flags & AVIO_FLAG_WRITE)
588 av_log(h, AV_LOG_ERROR, "FTP open failed\n");
589 ffurl_closep(&s->conn_control);
590 ffurl_closep(&s->conn_data);
594 static int64_t ftp_seek(URLContext *h, int64_t pos, int whence)
596 FTPContext *s = h->priv_data;
598 int64_t new_pos, fake_pos;
600 av_dlog(h, "ftp protocol seek %"PRId64" %d\n", pos, whence);
609 new_pos = s->position + pos;
614 new_pos = s->filesize + pos;
617 return AVERROR(EINVAL);
623 new_pos = FFMAX(0, new_pos);
624 fake_pos = s->filesize != -1 ? FFMIN(new_pos, s->filesize) : new_pos;
626 if (fake_pos != s->position) {
627 if ((err = ftp_abort(h)) < 0)
629 s->position = fake_pos;
634 static int ftp_read(URLContext *h, unsigned char *buf, int size)
636 FTPContext *s = h->priv_data;
637 int read, err, retry_done = 0;
639 av_dlog(h, "ftp protocol read %d bytes\n", size);
641 if (s->state == DISCONNECTED) {
642 if (s->position >= s->filesize)
644 if ((err = ftp_connect_data_connection(h)) < 0)
647 if (s->state == READY) {
648 if (s->position >= s->filesize)
650 if ((err = ftp_retrieve(s)) < 0)
653 if (s->conn_data && s->state == DOWNLOADING) {
654 read = ffurl_read(s->conn_data, buf, size);
657 if (s->position >= s->filesize) {
658 /* server will terminate, but keep current position to avoid madness */
659 int64_t pos = s->position;
660 if (ftp_abort(h) < 0) {
667 if (read <= 0 && s->position < s->filesize && !h->is_streamed) {
668 /* Server closed connection. Probably due to inactivity */
669 int64_t pos = s->position;
670 av_log(h, AV_LOG_INFO, "Reconnect to FTP server.\n");
671 if ((err = ftp_abort(h)) < 0)
673 if ((err = ftp_seek(h, pos, SEEK_SET)) < 0) {
674 av_log(h, AV_LOG_ERROR, "Position cannot be restored.\n");
685 av_log(h, AV_LOG_DEBUG, "FTP read failed\n");
689 static int ftp_write(URLContext *h, const unsigned char *buf, int size)
692 FTPContext *s = h->priv_data;
695 av_dlog(h, "ftp protocol write %d bytes\n", size);
697 if (s->state == DISCONNECTED) {
698 if ((err = ftp_connect_data_connection(h)) < 0)
701 if (s->state == READY) {
702 if ((err = ftp_store(s)) < 0)
705 if (s->conn_data && s->state == UPLOADING) {
706 written = ffurl_write(s->conn_data, buf, size);
708 s->position += written;
709 s->filesize = FFMAX(s->filesize, s->position);
714 av_log(h, AV_LOG_ERROR, "FTP write failed\n");
718 static int ftp_close(URLContext *h)
720 av_dlog(h, "ftp protocol close\n");
722 ftp_close_both_connections(h->priv_data);
727 static int ftp_get_file_handle(URLContext *h)
729 FTPContext *s = h->priv_data;
731 av_dlog(h, "ftp protocol get_file_handle\n");
734 return ffurl_get_file_handle(s->conn_data);
739 static int ftp_shutdown(URLContext *h, int flags)
741 FTPContext *s = h->priv_data;
743 av_dlog(h, "ftp protocol shutdown\n");
746 return ffurl_shutdown(s->conn_data, flags);
751 URLProtocol ff_ftp_protocol = {
753 .url_open = ftp_open,
754 .url_read = ftp_read,
755 .url_write = ftp_write,
756 .url_seek = ftp_seek,
757 .url_close = ftp_close,
758 .url_get_file_handle = ftp_get_file_handle,
759 .url_shutdown = ftp_shutdown,
760 .priv_data_size = sizeof(FTPContext),
761 .priv_data_class = &ftp_context_class,
762 .flags = URL_PROTOCOL_FLAG_NETWORK,