Merge commit 'fab8156b2f30666adabe227b3d7712fd193873b1'
[ffmpeg.git] / libavformat / ftp.c
index 3b69bc1..0663b47 100644 (file)
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include <stdlib.h>
 #include "libavutil/avstring.h"
-#include "libavutil/avassert.h"
+#include "libavutil/internal.h"
+#include "libavutil/parseutils.h"
 #include "avformat.h"
 #include "internal.h"
-#include "network.h"
-#include "os_support.h"
 #include "url.h"
 #include "libavutil/opt.h"
+#include "libavutil/bprint.h"
 
 #define CONTROL_BUFFER_SIZE 1024
+#define DIR_BUFFER_SIZE 4096
 
 typedef enum {
     UNKNOWN,
     READY,
     DOWNLOADING,
     UPLOADING,
+    LISTING_DIR,
     DISCONNECTED
 } FTPState;
 
+typedef enum {
+    UNKNOWN_METHOD,
+    NLST,
+    MLSD
+} FTPListingMethod;
 
 typedef struct {
     const AVClass *class;
     URLContext *conn_control;                    /**< Control connection */
-    int conn_control_block_flag;                 /**< Controls block/unblock mode of data connection */
-    AVIOInterruptCB conn_control_interrupt_cb;   /**< Controls block/unblock mode of data connection */
     URLContext *conn_data;                       /**< Data connection, NULL when not connected */
     uint8_t control_buffer[CONTROL_BUFFER_SIZE]; /**< Control connection buffer */
     uint8_t *control_buf_ptr, *control_buf_end;
     int server_data_port;                        /**< Data connection port opened by server, -1 on error. */
-    char hostname[512];                          /**< Server address. */
-    char path[MAX_URL_SIZE];                     /**< Path to resource on server. */
+    int server_control_port;                     /**< Control connection port, default is 21 */
+    char *hostname;                              /**< Server address. */
+    char *user;                                  /**< Server user */
+    char *password;                              /**< Server user's password */
+    char *path;                                  /**< Path to resource on server. */
     int64_t filesize;                            /**< Size of file on server, -1 on error. */
     int64_t position;                            /**< Current position, calculated. */
     int rw_timeout;                              /**< Network timeout. */
     const char *anonymous_password;              /**< Password to be used for anonymous user. An email should be used. */
     int write_seekable;                          /**< Control seekability, 0 = disable, 1 = enable. */
     FTPState state;                              /**< State of data connection */
+    FTPListingMethod listing_method;             /**< Called listing method */
+    char *features;                              /**< List of server's features represented as raw response */
+    char *dir_buffer;
+    size_t dir_buffer_size;
+    size_t dir_buffer_offset;
+    int utf8;
 } FTPContext;
 
 #define OFFSET(x) offsetof(FTPContext, x)
@@ -63,7 +76,7 @@ typedef struct {
 #define E AV_OPT_FLAG_ENCODING_PARAM
 static const AVOption options[] = {
     {"timeout", "set timeout of socket I/O operations", OFFSET(rw_timeout), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, D|E },
-    {"ftp-write-seekable", "control seekability of connection during encoding", OFFSET(write_seekable), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, E },
+    {"ftp-write-seekable", "control seekability of connection during encoding", OFFSET(write_seekable), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, E },
     {"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 },
     {NULL}
 };
@@ -75,18 +88,12 @@ static const AVClass ftp_context_class = {
     .version        = LIBAVUTIL_VERSION_INT,
 };
 
-static int ftp_conn_control_block_control(void *data)
-{
-    FTPContext *s = data;
-    return s->conn_control_block_flag;
-}
+static int ftp_close(URLContext *h);
 
 static int ftp_getc(FTPContext *s)
 {
     int len;
     if (s->control_buf_ptr >= s->control_buf_end) {
-        if (s->conn_control_block_flag)
-            return AVERROR_EXIT;
         len = ffurl_read(s->conn_control, s->control_buffer, CONTROL_BUFFER_SIZE);
         if (len < 0) {
             return len;
@@ -104,12 +111,10 @@ static int ftp_get_line(FTPContext *s, char *line, int line_size)
 {
     int ch;
     char *q = line;
-    int ori_block_flag = s->conn_control_block_flag;
 
     for (;;) {
         ch = ftp_getc(s);
         if (ch < 0) {
-            s->conn_control_block_flag = ori_block_flag;
             return ch;
         }
         if (ch == '\n') {
@@ -117,11 +122,8 @@ static int ftp_get_line(FTPContext *s, char *line, int line_size)
             if (q > line && q[-1] == '\r')
                 q--;
             *q = '\0';
-
-            s->conn_control_block_flag = ori_block_flag;
             return 0;
         } else {
-            s->conn_control_block_flag = 0; /* line need to be finished */
             if ((q - line) < line_size - 1)
                 *q++ = ch;
         }
@@ -130,125 +132,180 @@ static int ftp_get_line(FTPContext *s, char *line, int line_size)
 
 /*
  * This routine returns ftp server response code.
- * Server may send more than one response for a certain command, following priorities are used:
- *   - 5xx code is returned if occurred. (means error)
- *   - When pref_code is set then pref_code is return if occurred. (expected result)
- *   - The lowest code is returned. (means success)
+ * Server may send more than one response for a certain command.
+ * First expected code is returned.
  */
-static int ftp_status(FTPContext *s, int *major, int *minor, int *extra, char **line, int pref_code)
+static int ftp_status(FTPContext *s, char **line, const int response_codes[])
 {
-    int err, result = -1, pref_code_found = 0;
+    int err, i, dash = 0, result = 0, code_found = 0, linesize;
     char buf[CONTROL_BUFFER_SIZE];
-    unsigned char d_major, d_minor, d_extra;
+    AVBPrint line_buffer;
 
-    /* Set blocking mode */
-    s->conn_control_block_flag = 0;
-    for (;;) {
-        if ((err = ftp_get_line(s, buf, CONTROL_BUFFER_SIZE)) < 0) {
-            if (err == AVERROR_EXIT)
-                return result;
+    if (line)
+        av_bprint_init(&line_buffer, 0, AV_BPRINT_SIZE_AUTOMATIC);
+
+    while (!code_found || dash) {
+        if ((err = ftp_get_line(s, buf, sizeof(buf))) < 0) {
+            if (line)
+                av_bprint_finalize(&line_buffer, NULL);
             return err;
         }
 
-        if (strlen(buf) < 3)
-            continue;
-        d_major = buf[0];
-        if (d_major < '1' || d_major > '6' || d_major == '4')
-            continue;
-        d_minor = buf[1];
-        if (d_minor < '0' || d_minor > '9')
-            continue;
-        d_extra = buf[2];
-        if (d_extra < '0' || d_extra > '9')
-            continue;
-
         av_log(s, AV_LOG_DEBUG, "%s\n", buf);
 
-        err = d_major * 100 + d_minor * 10 + d_extra - 111 * '0';
-
-        if ((result < 0 || err < result || pref_code == err) && !pref_code_found || d_major == '5') {
-            if (pref_code == err || d_major == '5')
-                pref_code_found = 1;
-            result = err;
-            if (major)
-                *major = d_major - '0';
-            if (minor)
-                *minor = d_minor - '0';
-            if (extra)
-                *extra = d_extra - '0';
-            if (line)
-                *line = av_strdup(buf);
+        linesize = strlen(buf);
+        err = 0;
+        if (linesize >= 3) {
+            for (i = 0; i < 3; ++i) {
+                if (buf[i] < '0' || buf[i] > '9') {
+                    err = 0;
+                    break;
+                }
+                err *= 10;
+                err += buf[i] - '0';
+            }
         }
 
-        /* first code received. Now get all lines in non blocking mode */
-        if (pref_code < 0 || pref_code_found)
-            s->conn_control_block_flag = 1;
+        if (!code_found) {
+            if (err >= 500) {
+                code_found = 1;
+                result = err;
+            } else
+                for (i = 0; response_codes[i]; ++i) {
+                    if (err == response_codes[i]) {
+                        code_found = 1;
+                        result = err;
+                        break;
+                    }
+                }
+        }
+        if (code_found) {
+            if (line)
+                av_bprintf(&line_buffer, "%s\r\n", buf);
+            if (linesize >= 4) {
+                if (!dash && buf[3] == '-')
+                    dash = err;
+                else if (err == dash && buf[3] == ' ')
+                    dash = 0;
+            }
+        }
     }
+
+    if (line)
+        av_bprint_finalize(&line_buffer, line);
     return result;
 }
 
-static int ftp_auth(FTPContext *s, char *auth)
+static int ftp_send_command(FTPContext *s, const char *command,
+                            const int response_codes[], char **response)
 {
-    const char *user = NULL, *pass = NULL;
-    char *end = NULL, buf[CONTROL_BUFFER_SIZE];
     int err;
-    av_assert2(auth);
 
-    user = av_strtok(auth, ":", &end);
-    pass = av_strtok(end, ":", &end);
+    ff_dlog(s, "%s", command);
 
-    if (user) {
-        snprintf(buf, sizeof(buf), "USER %s\r\n", user);
-        if ((err = ffurl_write(s->conn_control, buf, strlen(buf))) < 0)
-            return err;
-        ftp_status(s, &err, NULL, NULL, NULL, -1);
-        if (err == 3) {
-            if (pass) {
-                snprintf(buf, sizeof(buf), "PASS %s\r\n", pass);
-                if ((err = ffurl_write(s->conn_control, buf, strlen(buf))) < 0)
-                    return err;
-                ftp_status(s, &err, NULL, NULL, NULL, -1);
-            } else
-                return AVERROR(EACCES);
-        }
-        if (err != 2) {
-            return AVERROR(EACCES);
-        }
-    } else {
-        const char* command = "USER anonymous\r\n";
-        if ((err = ffurl_write(s->conn_control, command, strlen(command))) < 0)
-            return err;
-        ftp_status(s, &err, NULL, NULL, NULL, -1);
-        if (err == 3) {
-            if (s->anonymous_password) {
-                snprintf(buf, sizeof(buf), "PASS %s\r\n", s->anonymous_password);
-            } else
-                snprintf(buf, sizeof(buf), "PASS nopassword\r\n");
-            if ((err = ffurl_write(s->conn_control, buf, strlen(buf))) < 0)
-                return err;
-            ftp_status(s, &err, NULL, NULL, NULL, -1);
-        }
-        if (err != 2) {
+    if (response)
+        *response = NULL;
+
+    if ((err = ffurl_write(s->conn_control, command, strlen(command))) < 0)
+        return err;
+    if (!err)
+        return -1;
+
+    /* return status */
+    if (response_codes) {
+        return ftp_status(s, response, response_codes);
+    }
+    return 0;
+}
+
+static void ftp_close_data_connection(FTPContext *s)
+{
+    ffurl_closep(&s->conn_data);
+    s->position = 0;
+    s->state = DISCONNECTED;
+}
+
+static void ftp_close_both_connections(FTPContext *s)
+{
+    ffurl_closep(&s->conn_control);
+    ftp_close_data_connection(s);
+}
+
+static int ftp_auth(FTPContext *s)
+{
+    char buf[CONTROL_BUFFER_SIZE];
+    int err;
+    static const int user_codes[] = {331, 230, 0};
+    static const int pass_codes[] = {230, 0};
+
+    snprintf(buf, sizeof(buf), "USER %s\r\n", s->user);
+    err = ftp_send_command(s, buf, user_codes, NULL);
+    if (err == 331) {
+        if (s->password) {
+            snprintf(buf, sizeof(buf), "PASS %s\r\n", s->password);
+            err = ftp_send_command(s, buf, pass_codes, NULL);
+        } else
             return AVERROR(EACCES);
+    }
+    if (err != 230)
+        return AVERROR(EACCES);
+
+    return 0;
+}
+
+static int ftp_passive_mode_epsv(FTPContext *s)
+{
+    char *res = NULL, *start = NULL, *end = NULL;
+    int i;
+    static const char d = '|';
+    static const char *command = "EPSV\r\n";
+    static const int epsv_codes[] = {229, 0};
+
+    if (ftp_send_command(s, command, epsv_codes, &res) != 229 || !res)
+        goto fail;
+
+    for (i = 0; res[i]; ++i) {
+        if (res[i] == '(') {
+            start = res + i + 1;
+        } else if (res[i] == ')') {
+            end = res + i;
+            break;
         }
     }
+    if (!start || !end)
+        goto fail;
+
+    *end = '\0';
+    if (strlen(start) < 5)
+        goto fail;
+    if (start[0] != d || start[1] != d || start[2] != d || end[-1] != d)
+        goto fail;
+    start += 3;
+    end[-1] = '\0';
+
+    s->server_data_port = atoi(start);
+    ff_dlog(s, "Server data port: %d\n", s->server_data_port);
 
+    av_free(res);
     return 0;
+
+  fail:
+    av_free(res);
+    s->server_data_port = -1;
+    return AVERROR(ENOSYS);
 }
 
 static int ftp_passive_mode(FTPContext *s)
 {
-    char *res = NULL, *start, *end;
-    int err, i;
-    const char *command = "PASV\r\n";
+    char *res = NULL, *start = NULL, *end = NULL;
+    int i;
+    static const char *command = "PASV\r\n";
+    static const int pasv_codes[] = {227, 0};
 
-    if ((err = ffurl_write(s->conn_control, command, strlen(command))) < 0)
-        return err;
-    if (ftp_status(s, NULL, NULL, NULL, &res, 227) != 227)
+    if (ftp_send_command(s, command, pasv_codes, &res) != 227 || !res)
         goto fail;
 
-    start = NULL;
-    for (i = 0; i < strlen(res); ++i) {
+    for (i = 0; res[i]; ++i) {
         if (res[i] == '(') {
             start = res + i + 1;
         } else if (res[i] == ')') {
@@ -273,7 +330,7 @@ static int ftp_passive_mode(FTPContext *s)
     start = av_strtok(end, ",", &end);
     if (!start) goto fail;
     s->server_data_port += atoi(start);
-    av_dlog(s, "Server data port: %d\n", s->server_data_port);
+    ff_dlog(s, "Server data port: %d\n", s->server_data_port);
 
     av_free(res);
     return 0;
@@ -287,12 +344,11 @@ static int ftp_passive_mode(FTPContext *s)
 static int ftp_current_dir(FTPContext *s)
 {
     char *res = NULL, *start = NULL, *end = NULL;
-    int err, i;
-    const char *command = "PWD\r\n";
+    int i;
+    static const char *command = "PWD\r\n";
+    static const int pwd_codes[] = {257, 0};
 
-    if ((err = ffurl_write(s->conn_control, command, strlen(command))) < 0)
-        return err;
-    if (ftp_status(s, NULL, NULL, NULL, &res, 257) != 257)
+    if (ftp_send_command(s, command, pwd_codes, &res) != 257 || !res)
         goto fail;
 
     for (i = 0; res[i]; ++i) {
@@ -309,13 +365,13 @@ static int ftp_current_dir(FTPContext *s)
     if (!end)
         goto fail;
 
-    if (end > res && end[-1] == '/') {
-        end[-1] = '\0';
-    } else
-        *end = '\0';
-    av_strlcpy(s->path, start, sizeof(s->path));
+    *end = '\0';
+    s->path = av_strdup(start);
 
     av_free(res);
+
+    if (!s->path)
+        return AVERROR(ENOMEM);
     return 0;
 
   fail:
@@ -325,14 +381,12 @@ static int ftp_current_dir(FTPContext *s)
 
 static int ftp_file_size(FTPContext *s)
 {
-    char buf[CONTROL_BUFFER_SIZE];
-    int err;
+    char command[CONTROL_BUFFER_SIZE];
     char *res = NULL;
+    static const int size_codes[] = {213, 0};
 
-    snprintf(buf, sizeof(buf), "SIZE %s\r\n", s->path);
-    if ((err = ffurl_write(s->conn_control, buf, strlen(buf))) < 0)
-        return err;
-    if (ftp_status(s, NULL, NULL, NULL, &res, 213) == 213) {
+    snprintf(command, sizeof(command), "SIZE %s\r\n", s->path);
+    if (ftp_send_command(s, command, size_codes, &res) == 213 && res) {
         s->filesize = strtoll(&res[4], NULL, 10);
     } else {
         s->filesize = -1;
@@ -346,13 +400,13 @@ static int ftp_file_size(FTPContext *s)
 
 static int ftp_retrieve(FTPContext *s)
 {
-    char buf[CONTROL_BUFFER_SIZE];
-    int err;
+    char command[CONTROL_BUFFER_SIZE];
+    static const int retr_codes[] = {150, 125, 0};
+    int resp_code;
 
-    snprintf(buf, sizeof(buf), "RETR %s\r\n", s->path);
-    if ((err = ffurl_write(s->conn_control, buf, strlen(buf))) < 0)
-        return err;
-    if (ftp_status(s, NULL, NULL, NULL, NULL, 150) != 150)
+    snprintf(command, sizeof(command), "RETR %s\r\n", s->path);
+    resp_code = ftp_send_command(s, command, retr_codes, NULL);
+    if (resp_code != 125 && resp_code != 150)
         return AVERROR(EIO);
 
     s->state = DOWNLOADING;
@@ -362,13 +416,13 @@ static int ftp_retrieve(FTPContext *s)
 
 static int ftp_store(FTPContext *s)
 {
-    char buf[CONTROL_BUFFER_SIZE];
-    int err;
+    char command[CONTROL_BUFFER_SIZE];
+    static const int stor_codes[] = {150, 125, 0};
+    int resp_code;
 
-    snprintf(buf, sizeof(buf), "STOR %s\r\n", s->path);
-    if ((err = ffurl_write(s->conn_control, buf, strlen(buf))) < 0)
-        return err;
-    if (ftp_status(s, NULL, NULL, NULL, NULL, 150) != 150)
+    snprintf(command, sizeof(command), "STOR %s\r\n", s->path);
+    resp_code = ftp_send_command(s, command, stor_codes, NULL);
+    if (resp_code != 125 && resp_code != 150)
         return AVERROR(EIO);
 
     s->state = UPLOADING;
@@ -378,133 +432,392 @@ static int ftp_store(FTPContext *s)
 
 static int ftp_type(FTPContext *s)
 {
-    int err;
-    const char *command = "TYPE I\r\n";
+    static const char *command = "TYPE I\r\n";
+    static const int type_codes[] = {200, 0};
 
-    if ((err = ffurl_write(s->conn_control, command, strlen(command))) < 0)
-        return err;
-    if (ftp_status(s, NULL, NULL, NULL, NULL, 200) != 200)
+    if (ftp_send_command(s, command, type_codes, NULL) != 200)
+        return AVERROR(EIO);
+
+    return 0;
+}
+
+static int ftp_restart(FTPContext *s, int64_t pos)
+{
+    char command[CONTROL_BUFFER_SIZE];
+    static const int rest_codes[] = {350, 0};
+
+    snprintf(command, sizeof(command), "REST %"PRId64"\r\n", pos);
+    if (ftp_send_command(s, command, rest_codes, NULL) != 350)
+        return AVERROR(EIO);
+
+    return 0;
+}
+
+static int ftp_set_dir(FTPContext *s)
+{
+    static const int cwd_codes[] = {250, 550, 0}; /* 550 is incorrect code */
+    char command[MAX_URL_SIZE];
+
+    snprintf(command, sizeof(command), "CWD %s\r\n", s->path);
+    if (ftp_send_command(s, command, cwd_codes, NULL) != 250)
         return AVERROR(EIO);
+    return 0;
+}
+
+static int ftp_list_mlsd(FTPContext *s)
+{
+    static const char *command = "MLSD\r\n";
+    static const int mlsd_codes[] = {150, 500, 0}; /* 500 is incorrect code */
+
+    if (ftp_send_command(s, command, mlsd_codes, NULL) != 150)
+        return AVERROR(ENOSYS);
+    s->listing_method = MLSD;
+    return 0;
+}
+
+static int ftp_list_nlst(FTPContext *s)
+{
+    static const char *command = "NLST\r\n";
+    static const int nlst_codes[] = {226, 425, 426, 451, 450, 550, 0};
+
+    if (ftp_send_command(s, command, nlst_codes, NULL) != 226)
+        return AVERROR(ENOSYS);
+    s->listing_method = NLST;
+    return 0;
+}
+
+static int ftp_has_feature(FTPContext *s, const char *feature_name);
+
+static int ftp_list(FTPContext *s)
+{
+    int ret;
+    s->state = LISTING_DIR;
+
+    if ((ret = ftp_list_mlsd(s)) < 0)
+        ret = ftp_list_nlst(s);
+
+    return ret;
+}
+
+static int ftp_has_feature(FTPContext *s, const char *feature_name)
+{
+    if (!s->features)
+        return 0;
+
+    return av_stristr(s->features, feature_name) != NULL;
+}
+
+static int ftp_features(FTPContext *s)
+{
+    static const char *feat_command        = "FEAT\r\n";
+    static const char *enable_utf8_command = "OPTS UTF8 ON\r\n";
+    static const int feat_codes[] = {211, 0};
+    static const int opts_codes[] = {200, 451, 0};
+
+    av_freep(&s->features);
+    if (ftp_send_command(s, feat_command, feat_codes, &s->features) != 211) {
+        av_freep(&s->features);
+    }
+
+    if (ftp_has_feature(s, "UTF8")) {
+        if (ftp_send_command(s, enable_utf8_command, opts_codes, NULL) == 200)
+            s->utf8 = 1;
+    }
 
     return 0;
 }
 
-static int ftp_reconnect_data_connection(URLContext *h)
+static int ftp_connect_control_connection(URLContext *h)
 {
+    char buf[CONTROL_BUFFER_SIZE], *response = NULL;
     int err;
-    char buf[CONTROL_BUFFER_SIZE], opts_format[20];
+    AVDictionary *opts = NULL;
+    FTPContext *s = h->priv_data;
+    static const int connect_codes[] = {220, 0};
+
+    if (!s->conn_control) {
+        ff_url_join(buf, sizeof(buf), "tcp", NULL,
+                    s->hostname, s->server_control_port, NULL);
+        if (s->rw_timeout != -1) {
+            av_dict_set_int(&opts, "timeout", s->rw_timeout, 0);
+        } /* if option is not given, don't pass it and let tcp use its own default */
+        err = ffurl_open_whitelist(&s->conn_control, buf, AVIO_FLAG_READ_WRITE,
+                                   &h->interrupt_callback, &opts,
+                                   h->protocol_whitelist, h->protocol_blacklist, h);
+        av_dict_free(&opts);
+        if (err < 0) {
+            av_log(h, AV_LOG_ERROR, "Cannot open control connection\n");
+            return err;
+        }
+
+        /* check if server is ready */
+        if (ftp_status(s, ((h->flags & AVIO_FLAG_WRITE) ? &response : NULL), connect_codes) != 220) {
+            av_log(h, AV_LOG_ERROR, "FTP server not ready for new users\n");
+            return AVERROR(EACCES);
+        }
+
+        if ((h->flags & AVIO_FLAG_WRITE) && av_stristr(response, "pure-ftpd")) {
+            av_log(h, AV_LOG_WARNING, "Pure-FTPd server is used as an output protocol. It is known issue this implementation may produce incorrect content and it cannot be fixed at this moment.");
+        }
+        av_free(response);
+
+        if ((err = ftp_auth(s)) < 0) {
+            av_log(h, AV_LOG_ERROR, "FTP authentication failed\n");
+            return err;
+        }
+
+        if ((err = ftp_type(s)) < 0) {
+            av_log(h, AV_LOG_ERROR, "Set content type failed\n");
+            return err;
+        }
+
+        ftp_features(s);
+    }
+    return 0;
+}
+
+static int ftp_connect_data_connection(URLContext *h)
+{
+    int err;
+    char buf[CONTROL_BUFFER_SIZE];
     AVDictionary *opts = NULL;
     FTPContext *s = h->priv_data;
 
     if (!s->conn_data) {
+        /* Enter passive mode */
+        if (ftp_passive_mode_epsv(s) < 0) {
+            /* Use PASV as fallback */
+            if ((err = ftp_passive_mode(s)) < 0)
+                return err;
+        }
+        /* Open data connection */
         ff_url_join(buf, sizeof(buf), "tcp", NULL, s->hostname, s->server_data_port, NULL);
         if (s->rw_timeout != -1) {
-            snprintf(opts_format, sizeof(opts_format), "%d", s->rw_timeout);
-            av_dict_set(&opts, "timeout", opts_format, 0);
+            av_dict_set_int(&opts, "timeout", s->rw_timeout, 0);
         } /* if option is not given, don't pass it and let tcp use its own default */
-        err = ffurl_open(&s->conn_data, buf, AVIO_FLAG_READ_WRITE,
-                         &h->interrupt_callback, &opts);
+        err = ffurl_open_whitelist(&s->conn_data, buf, h->flags,
+                                   &h->interrupt_callback, &opts,
+                                   h->protocol_whitelist, h->protocol_blacklist, h);
         av_dict_free(&opts);
         if (err < 0)
             return err;
+
+        if (s->position)
+            if ((err = ftp_restart(s, s->position)) < 0)
+                return err;
     }
     s->state = READY;
-    s->position = 0;
     return 0;
 }
 
-static int ftp_open(URLContext *h, const char *url, int flags)
+static int ftp_abort(URLContext *h)
 {
-    char proto[10], auth[1024], path[MAX_URL_SIZE], buf[CONTROL_BUFFER_SIZE], opts_format[20];
-    AVDictionary *opts = NULL;
-    int port, err;
+    static const char *command = "ABOR\r\n";
+    int err;
+    static const int abor_codes[] = {225, 226, 0};
     FTPContext *s = h->priv_data;
 
-    av_dlog(h, "ftp protocol open\n");
+    /* According to RCF 959:
+       "ABOR command tells the server to abort the previous FTP
+       service command and any associated transfer of data."
+
+       There are FTP server implementations that don't response
+       to any commands during data transfer in passive mode (including ABOR).
+
+       This implementation closes data connection by force.
+    */
+
+    if (ftp_send_command(s, command, NULL, NULL) < 0) {
+        ftp_close_both_connections(s);
+        if ((err = ftp_connect_control_connection(h)) < 0) {
+            av_log(h, AV_LOG_ERROR, "Reconnect failed.\n");
+            return err;
+        }
+    } else {
+        ftp_close_data_connection(s);
+        if (ftp_status(s, NULL, abor_codes) < 225) {
+            /* wu-ftpd also closes control connection after data connection closing */
+            ffurl_closep(&s->conn_control);
+            if ((err = ftp_connect_control_connection(h)) < 0) {
+                av_log(h, AV_LOG_ERROR, "Reconnect failed.\n");
+                return err;
+            }
+        }
+    }
+
+    return 0;
+}
+
+static int ftp_connect(URLContext *h, const char *url)
+{
+    char proto[10], path[MAX_URL_SIZE], credencials[MAX_URL_SIZE], hostname[MAX_URL_SIZE];
+    const char *tok_user = NULL, *tok_pass = NULL;
+    char *end = NULL, *newpath = NULL;
+    int err;
+    FTPContext *s = h->priv_data;
 
     s->state = DISCONNECTED;
+    s->listing_method = UNKNOWN_METHOD;
     s->filesize = -1;
-    s->conn_control_interrupt_cb.opaque = s;
-    s->conn_control_interrupt_cb.callback = ftp_conn_control_block_control;
+    s->position = 0;
+    s->features = NULL;
 
     av_url_split(proto, sizeof(proto),
-                 auth, sizeof(auth),
-                 s->hostname, sizeof(s->hostname),
-                 &port,
+                 credencials, sizeof(credencials),
+                 hostname, sizeof(hostname),
+                 &s->server_control_port,
                  path, sizeof(path),
                  url);
 
-    if (port < 0)
-        port = 21;
+    tok_user = av_strtok(credencials, ":", &end);
+    tok_pass = av_strtok(end, ":", &end);
+    if (!tok_user) {
+        tok_user = "anonymous";
+        tok_pass = av_x_if_null(s->anonymous_password, "nopassword");
+    }
+    s->user = av_strdup(tok_user);
+    s->password = av_strdup(tok_pass);
+    s->hostname = av_strdup(hostname);
+    if (!s->hostname || !s->user || (tok_pass && !s->password)) {
+        return AVERROR(ENOMEM);
+    }
 
-    if (!s->conn_control) {
-        ff_url_join(buf, sizeof(buf), "tcp", NULL, s->hostname, port, NULL);
-        if (s->rw_timeout != -1) {
-            snprintf(opts_format, sizeof(opts_format), "%d", s->rw_timeout);
-            av_dict_set(&opts, "timeout", opts_format, 0);
-        } /* if option is not given, don't pass it and let tcp use its own default */
-        err = ffurl_open(&s->conn_control, buf, AVIO_FLAG_READ_WRITE,
-                         &s->conn_control_interrupt_cb, &opts);
-        av_dict_free(&opts);
-        if (err < 0)
-            goto fail;
+    if (s->server_control_port < 0 || s->server_control_port > 65535)
+        s->server_control_port = 21;
 
-        /* consume all messages from server */
-        if (ftp_status(s, NULL, NULL, NULL, NULL, 220) != 220) {
-            av_log(h, AV_LOG_ERROR, "Server not ready for new users\n");
-            err = AVERROR(EACCES);
-            goto fail;
-        }
+    if ((err = ftp_connect_control_connection(h)) < 0)
+        return err;
 
-        if ((err = ftp_auth(s, auth)) < 0)
-            goto fail;
+    if ((err = ftp_current_dir(s)) < 0)
+        return err;
 
-        if ((err = ftp_type(s)) < 0)
-            goto fail;
+    newpath = av_append_path_component(s->path, path);
+    if (!newpath)
+        return AVERROR(ENOMEM);
+    av_free(s->path);
+    s->path = newpath;
 
-        if ((err = ftp_current_dir(s)) < 0)
-            goto fail;
-        av_strlcat(s->path, path, sizeof(s->path));
+    return 0;
+}
 
-        if ((err = ftp_passive_mode(s)) < 0)
-            goto fail;
+static int ftp_open(URLContext *h, const char *url, int flags)
+{
+    FTPContext *s = h->priv_data;
+    int err;
+
+    ff_dlog(h, "ftp protocol open\n");
+
+    if ((err = ftp_connect(h, url)) < 0)
+        goto fail;
 
+    if (ftp_restart(s, 0) < 0) {
+        h->is_streamed = 1;
+    } else {
         if (ftp_file_size(s) < 0 && flags & AVIO_FLAG_READ)
             h->is_streamed = 1;
         if (s->write_seekable != 1 && flags & AVIO_FLAG_WRITE)
             h->is_streamed = 1;
     }
 
-    if ((err = ftp_reconnect_data_connection(h)) < 0)
-        goto fail;
-
     return 0;
+
   fail:
     av_log(h, AV_LOG_ERROR, "FTP open failed\n");
-    ffurl_closep(&s->conn_control);
-    ffurl_closep(&s->conn_data);
+    ftp_close(h);
     return err;
 }
 
-static int ftp_read(URLContext *h, unsigned char *buf, int size)
+static int64_t ftp_seek(URLContext *h, int64_t pos, int whence)
 {
     FTPContext *s = h->priv_data;
-    int read;
+    int err;
+    int64_t new_pos, fake_pos;
 
-    av_dlog(h, "ftp protocol read %d bytes\n", size);
+    ff_dlog(h, "ftp protocol seek %"PRId64" %d\n", pos, whence);
 
+    switch(whence) {
+    case AVSEEK_SIZE:
+        return s->filesize;
+    case SEEK_SET:
+        new_pos = pos;
+        break;
+    case SEEK_CUR:
+        new_pos = s->position + pos;
+        break;
+    case SEEK_END:
+        if (s->filesize < 0)
+            return AVERROR(EIO);
+        new_pos = s->filesize + pos;
+        break;
+    default:
+        return AVERROR(EINVAL);
+    }
+
+    if (h->is_streamed)
+        return AVERROR(EIO);
+
+    if (new_pos < 0) {
+        av_log(h, AV_LOG_ERROR, "Seeking to nagative position.\n");
+        return AVERROR(EINVAL);
+    }
+
+    fake_pos = s->filesize != -1 ? FFMIN(new_pos, s->filesize) : new_pos;
+    if (fake_pos != s->position) {
+        if ((err = ftp_abort(h)) < 0)
+            return err;
+        s->position = fake_pos;
+    }
+    return new_pos;
+}
+
+static int ftp_read(URLContext *h, unsigned char *buf, int size)
+{
+    FTPContext *s = h->priv_data;
+    int read, err, retry_done = 0;
+
+    ff_dlog(h, "ftp protocol read %d bytes\n", size);
+  retry:
+    if (s->state == DISCONNECTED) {
+        /* optimization */
+        if (s->position >= s->filesize)
+            return 0;
+        if ((err = ftp_connect_data_connection(h)) < 0)
+            return err;
+    }
     if (s->state == READY) {
-        ftp_retrieve(s);
+        if (s->position >= s->filesize)
+            return 0;
+        if ((err = ftp_retrieve(s)) < 0)
+            return err;
     }
     if (s->conn_data && s->state == DOWNLOADING) {
         read = ffurl_read(s->conn_data, buf, size);
         if (read >= 0) {
             s->position += read;
             if (s->position >= s->filesize) {
-                ffurl_closep(&s->conn_data);
-                s->state = DISCONNECTED;
-                if (ftp_status(s, NULL, NULL, NULL,NULL, 226) != 226)
+                /* server will terminate, but keep current position to avoid madness */
+                /* save position to restart from it */
+                int64_t pos = s->position;
+                if (ftp_abort(h) < 0) {
+                    s->position = pos;
                     return AVERROR(EIO);
+                }
+                s->position = pos;
+            }
+        }
+        if (read <= 0 && s->position < s->filesize && !h->is_streamed) {
+            /* Server closed connection. Probably due to inactivity */
+            int64_t pos = s->position;
+            av_log(h, AV_LOG_INFO, "Reconnect to FTP server.\n");
+            if ((err = ftp_abort(h)) < 0)
+                return err;
+            if ((err = ftp_seek(h, pos, SEEK_SET)) < 0) {
+                av_log(h, AV_LOG_ERROR, "Position cannot be restored.\n");
+                return err;
+            }
+            if (!retry_done) {
+                retry_done = 1;
+                goto retry;
             }
         }
         return read;
@@ -516,13 +829,19 @@ static int ftp_read(URLContext *h, unsigned char *buf, int size)
 
 static int ftp_write(URLContext *h, const unsigned char *buf, int size)
 {
+    int err;
     FTPContext *s = h->priv_data;
     int written;
 
-    av_dlog(h, "ftp protocol write %d bytes\n", size);
+    ff_dlog(h, "ftp protocol write %d bytes\n", size);
 
+    if (s->state == DISCONNECTED) {
+        if ((err = ftp_connect_data_connection(h)) < 0)
+            return err;
+    }
     if (s->state == READY) {
-        ftp_store(s);
+        if ((err = ftp_store(s)) < 0)
+            return err;
     }
     if (s->conn_data && s->state == UPLOADING) {
         written = ffurl_write(s->conn_data, buf, size);
@@ -537,115 +856,254 @@ static int ftp_write(URLContext *h, const unsigned char *buf, int size)
     return AVERROR(EIO);
 }
 
-static int64_t ftp_seek(URLContext *h, int64_t pos, int whence)
+static int ftp_close(URLContext *h)
 {
     FTPContext *s = h->priv_data;
-    char buf[CONTROL_BUFFER_SIZE];
-    int err;
-    int64_t new_pos;
 
-    av_dlog(h, "ftp protocol seek %"PRId64" %d\n", pos, whence);
+    ff_dlog(h, "ftp protocol close\n");
 
-    switch(whence) {
-    case AVSEEK_SIZE:
-        return s->filesize;
-    case SEEK_SET:
-        new_pos = pos;
-        break;
-    case SEEK_CUR:
-        new_pos = s->position + pos;
-        break;
-    case SEEK_END:
-        if (s->filesize < 0)
-            return AVERROR(EIO);
-        new_pos = s->filesize + pos;
-        break;
-    default:
-        return AVERROR(EINVAL);
-    }
+    ftp_close_both_connections(s);
+    av_freep(&s->user);
+    av_freep(&s->password);
+    av_freep(&s->hostname);
+    av_freep(&s->path);
+    av_freep(&s->features);
 
-    if  (h->is_streamed)
-        return AVERROR(EIO);
+    return 0;
+}
 
-    if (new_pos < 0 || (s->filesize >= 0 && new_pos > s->filesize))
-        return AVERROR(EINVAL);
+static int ftp_get_file_handle(URLContext *h)
+{
+    FTPContext *s = h->priv_data;
 
-    if (new_pos != s->position) {
-        /* close existing data connection */
-        if (s->state != READY) {
-            if (s->conn_data) {
-                /* abort existing transfer */
-                if (s->state == DOWNLOADING) {
-                    snprintf(buf, sizeof(buf), "ABOR\r\n");
-                    if ((err = ffurl_write(s->conn_control, buf, strlen(buf))) < 0)
-                        return err;
-                }
-                ffurl_closep(&s->conn_data);
-                s->state = DISCONNECTED;
-                /* Servers return 225 or 226 */
-                ftp_status(s, &err, NULL, NULL, NULL, -1);
-                if (err != 2)
-                    return AVERROR(EIO);
-            }
+    ff_dlog(h, "ftp protocol get_file_handle\n");
 
-            /* set passive */
-            if ((err = ftp_passive_mode(s)) < 0)
-                return err;
+    if (s->conn_data)
+        return ffurl_get_file_handle(s->conn_data);
 
-            /* open new data connection */
-            if ((err = ftp_reconnect_data_connection(h)) < 0)
-                return err;
-        }
+    return AVERROR(EIO);
+}
 
-        /* resume from pos position */
-        snprintf(buf, sizeof(buf), "REST %"PRId64"\r\n", pos);
-        if ((err = ffurl_write(s->conn_control, buf, strlen(buf))) < 0)
-            return err;
-        if (ftp_status(s, NULL, NULL, NULL, NULL, 350) != 350)
-            return AVERROR(EIO);
+static int ftp_shutdown(URLContext *h, int flags)
+{
+    FTPContext *s = h->priv_data;
 
-        s->position = pos;
-    }
-    return new_pos;
+    ff_dlog(h, "ftp protocol shutdown\n");
+
+    if (s->conn_data)
+        return ffurl_shutdown(s->conn_data, flags);
+
+    return AVERROR(EIO);
 }
 
-static int ftp_close(URLContext *h)
+static int ftp_open_dir(URLContext *h)
 {
     FTPContext *s = h->priv_data;
+    int ret;
 
-    av_dlog(h, "ftp protocol close\n");
-
+    if ((ret = ftp_connect(h, h->filename)) < 0)
+        goto fail;
+    if ((ret = ftp_set_dir(s)) < 0)
+        goto fail;
+    if ((ret = ftp_connect_data_connection(h)) < 0)
+        goto fail;
+    if ((ret = ftp_list(s)) < 0)
+        goto fail;
+    s->dir_buffer = av_malloc(DIR_BUFFER_SIZE);
+    if (!s->dir_buffer) {
+        ret = AVERROR(ENOMEM);
+        goto fail;
+    }
+    s->dir_buffer[0] = 0;
+    if (s->conn_data && s->state == LISTING_DIR)
+        return 0;
+  fail:
     ffurl_closep(&s->conn_control);
     ffurl_closep(&s->conn_data);
+    return ret;
+}
+
+static int64_t ftp_parse_date(const char *date)
+{
+    struct tm tv;
+    memset(&tv, 0, sizeof(struct tm));
+    av_small_strptime(date, "%Y%m%d%H%M%S", &tv);
+    return INT64_C(1000000) * av_timegm(&tv);
+}
 
+static int ftp_parse_entry_nlst(char *line, AVIODirEntry *next)
+{
+    next->name = av_strdup(line);
     return 0;
 }
 
-static int ftp_get_file_handle(URLContext *h)
+static int ftp_parse_entry_mlsd(char *mlsd, AVIODirEntry *next)
+{
+    char *fact, *value;
+    ff_dlog(NULL, "%s\n", mlsd);
+    while(fact = av_strtok(mlsd, ";", &mlsd)) {
+        if (fact[0] == ' ') {
+            next->name = av_strdup(&fact[1]);
+            continue;
+        }
+        fact = av_strtok(fact, "=", &value);
+        if (!av_strcasecmp(fact, "type")) {
+            if (!av_strcasecmp(value, "cdir") || !av_strcasecmp(value, "pdir"))
+                return 1;
+            if (!av_strcasecmp(value, "dir"))
+                next->type = AVIO_ENTRY_DIRECTORY;
+            else if (!av_strcasecmp(value, "file"))
+                next->type = AVIO_ENTRY_FILE;
+            else if (!av_strcasecmp(value, "OS.unix=slink:"))
+                next->type = AVIO_ENTRY_SYMBOLIC_LINK;
+        } else if (!av_strcasecmp(fact, "modify")) {
+            next->modification_timestamp = ftp_parse_date(value);
+        } else if (!av_strcasecmp(fact, "UNIX.mode")) {
+            next->filemode = strtoumax(value, NULL, 8);
+        } else if (!av_strcasecmp(fact, "UNIX.uid") || !av_strcasecmp(fact, "UNIX.owner"))
+            next->user_id = strtoumax(value, NULL, 10);
+        else if (!av_strcasecmp(fact, "UNIX.gid") || !av_strcasecmp(fact, "UNIX.group"))
+            next->group_id = strtoumax(value, NULL, 10);
+        else if (!av_strcasecmp(fact, "size") || !av_strcasecmp(fact, "sizd"))
+            next->size = strtoll(value, NULL, 10);
+    }
+    return 0;
+}
+
+/**
+ * @return 0 on success, negative on error, positive on entry to discard.
+ */
+static int ftp_parse_entry(URLContext *h, char *line, AVIODirEntry *next)
 {
     FTPContext *s = h->priv_data;
 
-    av_dlog(h, "ftp protocol get_file_handle\n");
+    switch (s->listing_method) {
+    case MLSD:
+        return ftp_parse_entry_mlsd(line, next);
+    case NLST:
+        return ftp_parse_entry_nlst(line, next);
+    case UNKNOWN_METHOD:
+    default:
+        return -1;
+    }
+}
 
-    if (s->conn_data)
-        return ffurl_get_file_handle(s->conn_data);
+static int ftp_read_dir(URLContext *h, AVIODirEntry **next)
+{
+    FTPContext *s = h->priv_data;
+    char *start, *found;
+    int ret, retried;
+
+    do {
+        retried = 0;
+        start = s->dir_buffer + s->dir_buffer_offset;
+        while (!(found = strstr(start, "\n"))) {
+            if (retried)
+                return AVERROR(EIO);
+            s->dir_buffer_size -= s->dir_buffer_offset;
+            s->dir_buffer_offset = 0;
+            if (s->dir_buffer_size)
+                memmove(s->dir_buffer, start, s->dir_buffer_size);
+            ret = ffurl_read(s->conn_data, s->dir_buffer + s->dir_buffer_size, DIR_BUFFER_SIZE - (s->dir_buffer_size + 1));
+            if (ret < 0)
+                return ret;
+            if (!ret) {
+                *next = NULL;
+                return 0;
+            }
+            s->dir_buffer_size += ret;
+            s->dir_buffer[s->dir_buffer_size] = 0;
+            start = s->dir_buffer;
+            retried = 1;
+        }
+        s->dir_buffer_offset += (found + 1 - start);
+        found[0] = 0;
+        if (found > start && found[-1] == '\r')
+            found[-1] = 0;
+
+        *next = ff_alloc_dir_entry();
+        if (!*next)
+            return AVERROR(ENOMEM);
+        (*next)->utf8 = s->utf8;
+        ret = ftp_parse_entry(h, start, *next);
+        if (ret) {
+            avio_free_directory_entry(next);
+            if (ret < 0)
+                return ret;
+        }
+    } while (ret > 0);
+    return 0;
+}
 
-    return AVERROR(EIO);
+static int ftp_close_dir(URLContext *h)
+{
+    FTPContext *s = h->priv_data;
+    av_freep(&s->dir_buffer);
+    ffurl_closep(&s->conn_control);
+    ffurl_closep(&s->conn_data);
+    return 0;
 }
 
-static int ftp_shutdown(URLContext *h, int flags)
+static int ftp_delete(URLContext *h)
 {
     FTPContext *s = h->priv_data;
+    char command[MAX_URL_SIZE];
+    static const int del_codes[] = {250, 421, 450, 500, 501, 502, 530, 550, 0};
+    static const int rmd_codes[] = {250, 421, 500, 501, 502, 530, 550, 0};
+    int ret;
+
+    if ((ret = ftp_connect(h, h->filename)) < 0)
+        goto cleanup;
+
+    snprintf(command, sizeof(command), "DELE %s\r\n", s->path);
+    if (ftp_send_command(s, command, del_codes, NULL) == 250) {
+        ret = 0;
+        goto cleanup;
+    }
 
-    av_dlog(h, "ftp protocol shutdown\n");
+    snprintf(command, sizeof(command), "RMD %s\r\n", s->path);
+    if (ftp_send_command(s, command, rmd_codes, NULL) == 250)
+        ret = 0;
+    else
+        ret = AVERROR(EIO);
 
-    if (s->conn_data)
-        return ffurl_shutdown(s->conn_data, flags);
+cleanup:
+    ftp_close(h);
+    return ret;
+}
 
-    return AVERROR(EIO);
+static int ftp_move(URLContext *h_src, URLContext *h_dst)
+{
+    FTPContext *s = h_src->priv_data;
+    char command[MAX_URL_SIZE], path[MAX_URL_SIZE];
+    static const int rnfr_codes[] = {350, 421, 450, 500, 501, 502, 503, 530, 0};
+    static const int rnto_codes[] = {250, 421, 500, 501, 502, 503, 530, 532, 553, 0};
+    int ret;
+
+    if ((ret = ftp_connect(h_src, h_src->filename)) < 0)
+        goto cleanup;
+
+    snprintf(command, sizeof(command), "RNFR %s\r\n", s->path);
+    if (ftp_send_command(s, command, rnfr_codes, NULL) != 350) {
+        ret = AVERROR(EIO);
+        goto cleanup;
+    }
+
+    av_url_split(0, 0, 0, 0, 0, 0, 0,
+                 path, sizeof(path),
+                 h_dst->filename);
+    snprintf(command, sizeof(command), "RNTO %s\r\n", path);
+    if (ftp_send_command(s, command, rnto_codes, NULL) == 250)
+        ret = 0;
+    else
+        ret = AVERROR(EIO);
+
+cleanup:
+    ftp_close(h_src);
+    return ret;
 }
 
-URLProtocol ff_ftp_protocol = {
+const URLProtocol ff_ftp_protocol = {
     .name                = "ftp",
     .url_open            = ftp_open,
     .url_read            = ftp_read,
@@ -656,5 +1114,11 @@ URLProtocol ff_ftp_protocol = {
     .url_shutdown        = ftp_shutdown,
     .priv_data_size      = sizeof(FTPContext),
     .priv_data_class     = &ftp_context_class,
+    .url_open_dir        = ftp_open_dir,
+    .url_read_dir        = ftp_read_dir,
+    .url_close_dir       = ftp_close_dir,
+    .url_delete          = ftp_delete,
+    .url_move            = ftp_move,
     .flags               = URL_PROTOCOL_FLAG_NETWORK,
+    .default_whitelist   = "tcp",
 };