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 "libavutil/avstring.h"
  22 #include "libavutil/internal.h"
  23 #include "libavutil/parseutils.h"
  24 #include "avformat.h"
  25 #include "internal.h"
  26 #include "url.h"
  27 #include "libavutil/opt.h"
  28 #include "libavutil/bprint.h"
  29
  30 #define CONTROL_BUFFER_SIZE 1024
  31 #define DIR_BUFFER_SIZE 4096
  32
  33 typedef enum {
  34     UNKNOWN,
  35     READY,
  36     DOWNLOADING,
  37     UPLOADING,
  38     LISTING_DIR,
  39     DISCONNECTED
  40 } FTPState;
  41
  42 typedef enum {
  43     UNKNOWN_METHOD,
  44     NLST,
  45     MLSD
  46 } FTPListingMethod;
  47
  48 typedef struct {
  49     const AVClass *class;
  50     URLContext *conn_control;                    /**< Control connection */
  51     URLContext *conn_data;                       /**< Data connection, NULL when not connected */
  52     uint8_t control_buffer[CONTROL_BUFFER_SIZE]; /**< Control connection buffer */
  53     uint8_t *control_buf_ptr, *control_buf_end;
  54     int server_data_port;                        /**< Data connection port opened by server, -1 on error. */
  55     int server_control_port;                     /**< Control connection port, default is 21 */
  56     char *hostname;                              /**< Server address. */
  57     char *user;                                  /**< Server user */
  58     char *password;                              /**< Server user's password */
  59     char *path;                                  /**< Path to resource on server. */
  60     int64_t filesize;                            /**< Size of file on server, -1 on error. */
  61     int64_t position;                            /**< Current position, calculated. */
  62     int rw_timeout;                              /**< Network timeout. */
  63     const char *anonymous_password;              /**< Password to be used for anonymous user. An email should be used. */
  64     int write_seekable;                          /**< Control seekability, 0 = disable, 1 = enable. */
  65     FTPState state;                              /**< State of data connection */
  66     FTPListingMethod listing_method;             /**< Called listing method */
  67     char *features;                              /**< List of server's features represented as raw response */
  68     char *dir_buffer;
  69     size_t dir_buffer_size;
  70     size_t dir_buffer_offset;
  71     int utf8;
  72 } FTPContext;
  73
  74 #define OFFSET(x) offsetof(FTPContext, x)
  75 #define D AV_OPT_FLAG_DECODING_PARAM
  76 #define E AV_OPT_FLAG_ENCODING_PARAM
  77 static const AVOption options[] = {
  78     {"timeout", "set timeout of socket I/O operations", OFFSET(rw_timeout), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, D|E },
  79     {"ftp-write-seekable", "control seekability of connection during encoding", OFFSET(write_seekable), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, E },
  80     {"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 },
  81     {NULL}
  82 };
  83
  84 static const AVClass ftp_context_class = {
  85     .class_name     = "ftp",
  86     .item_name      = av_default_item_name,
  87     .option         = options,
  88     .version        = LIBAVUTIL_VERSION_INT,
  89 };
  90
  91 static int ftp_close(URLContext *h);
  92
  93 static int ftp_getc(FTPContext *s)
  94 {
  95     int len;
  96     if (s->control_buf_ptr >= s->control_buf_end) {
  97         len = ffurl_read(s->conn_control, s->control_buffer, CONTROL_BUFFER_SIZE);
  98         if (len < 0) {
  99             return len;
 100         } else if (!len) {
 101             return -1;
 102         } else {
 103             s->control_buf_ptr = s->control_buffer;
 104             s->control_buf_end = s->control_buffer + len;
 105         }
 106     }
 107     return *s->control_buf_ptr++;
 108 }
 109
 110 static int ftp_get_line(FTPContext *s, char *line, int line_size)
 111 {
 112     int ch;
 113     char *q = line;
 114
 115     for (;;) {
 116         ch = ftp_getc(s);
 117         if (ch < 0) {
 118             return ch;
 119         }
 120         if (ch == '\n') {
 121             /* process line */
 122             if (q > line && q[-1] == '\r')
 123                 q--;
 124             *q = '\0';
 125             return 0;
 126         } else {
 127             if ((q - line) < line_size - 1)
 128                 *q++ = ch;
 129         }
 130     }
 131 }
 132
 133 /*
 134  * This routine returns ftp server response code.
 135  * Server may send more than one response for a certain command.
 136  * First expected code is returned.
 137  */
 138 static int ftp_status(FTPContext *s, char **line, const int response_codes[])
 139 {
 140     int err, i, dash = 0, result = 0, code_found = 0, linesize;
 141     char buf[CONTROL_BUFFER_SIZE];
 142     AVBPrint line_buffer;
 143
 144     if (line)
 145         av_bprint_init(&line_buffer, 0, AV_BPRINT_SIZE_AUTOMATIC);
 146
 147     while (!code_found || dash) {
 148         if ((err = ftp_get_line(s, buf, sizeof(buf))) < 0) {
 149             if (line)
 150                 av_bprint_finalize(&line_buffer, NULL);
 151             return err;
 152         }
 153
 154         av_log(s, AV_LOG_DEBUG, "%s\n", buf);
 155
 156         linesize = strlen(buf);
 157         err = 0;
 158         if (linesize >= 3) {
 159             for (i = 0; i < 3; ++i) {
 160                 if (buf[i] < '0' || buf[i] > '9') {
 161                     err = 0;
 162                     break;
 163                 }
 164                 err *= 10;
 165                 err += buf[i] - '0';
 166             }
 167         }
 168
 169         if (!code_found) {
 170             if (err >= 500) {
 171                 code_found = 1;
 172                 result = err;
 173             } else
 174                 for (i = 0; response_codes[i]; ++i) {
 175                     if (err == response_codes[i]) {
 176                         code_found = 1;
 177                         result = err;
 178                         break;
 179                     }
 180                 }
 181         }
 182         if (code_found) {
 183             if (line)
 184                 av_bprintf(&line_buffer, "%s\r\n", buf);
 185             if (linesize >= 4) {
 186                 if (!dash && buf[3] == '-')
 187                     dash = err;
 188                 else if (err == dash && buf[3] == ' ')
 189                     dash = 0;
 190             }
 191         }
 192     }
 193
 194     if (line)
 195         av_bprint_finalize(&line_buffer, line);
 196     return result;
 197 }
 198
 199 static int ftp_send_command(FTPContext *s, const char *command,
 200                             const int response_codes[], char **response)
 201 {
 202     int err;
 203
 204     ff_dlog(s, "%s", command);
 205
 206     if (response)
 207         *response = NULL;
 208
 209     if (!s->conn_control)
 210         return AVERROR(EIO);
 211
 212     if ((err = ffurl_write(s->conn_control, command, strlen(command))) < 0)
 213         return err;
 214     if (!err)
 215         return -1;
 216
 217     /* return status */
 218     if (response_codes) {
 219         return ftp_status(s, response, response_codes);
 220     }
 221     return 0;
 222 }
 223
 224 static void ftp_close_data_connection(FTPContext *s)
 225 {
 226     ffurl_closep(&s->conn_data);
 227     s->position = 0;
 228     s->state = DISCONNECTED;
 229 }
 230
 231 static void ftp_close_both_connections(FTPContext *s)
 232 {
 233     ffurl_closep(&s->conn_control);
 234     ftp_close_data_connection(s);
 235 }
 236
 237 static int ftp_auth(FTPContext *s)
 238 {
 239     char buf[CONTROL_BUFFER_SIZE];
 240     int err;
 241     static const int user_codes[] = {331, 230, 0};
 242     static const int pass_codes[] = {230, 0};
 243
 244     snprintf(buf, sizeof(buf), "USER %s\r\n", s->user);
 245     err = ftp_send_command(s, buf, user_codes, NULL);
 246     if (err == 331) {
 247         if (s->password) {
 248             snprintf(buf, sizeof(buf), "PASS %s\r\n", s->password);
 249             err = ftp_send_command(s, buf, pass_codes, NULL);
 250         } else
 251             return AVERROR(EACCES);
 252     }
 253     if (err != 230)
 254         return AVERROR(EACCES);
 255
 256     return 0;
 257 }
 258
 259 static int ftp_passive_mode_epsv(FTPContext *s)
 260 {
 261     char *res = NULL, *start = NULL, *end = NULL;
 262     int i;
 263     static const char d = '|';
 264     static const char *command = "EPSV\r\n";
 265     static const int epsv_codes[] = {229, 0};
 266
 267     if (ftp_send_command(s, command, epsv_codes, &res) != 229 || !res)
 268         goto fail;
 269
 270     for (i = 0; res[i]; ++i) {
 271         if (res[i] == '(') {
 272             start = res + i + 1;
 273         } else if (res[i] == ')') {
 274             end = res + i;
 275             break;
 276         }
 277     }
 278     if (!start || !end)
 279         goto fail;
 280
 281     *end = '\0';
 282     if (strlen(start) < 5)
 283         goto fail;
 284     if (start[0] != d || start[1] != d || start[2] != d || end[-1] != d)
 285         goto fail;
 286     start += 3;
 287     end[-1] = '\0';
 288
 289     s->server_data_port = atoi(start);
 290     ff_dlog(s, "Server data port: %d\n", s->server_data_port);
 291
 292     av_free(res);
 293     return 0;
 294
 295   fail:
 296     av_free(res);
 297     s->server_data_port = -1;
 298     return AVERROR(ENOSYS);
 299 }
 300
 301 static int ftp_passive_mode(FTPContext *s)
 302 {
 303     char *res = NULL, *start = NULL, *end = NULL;
 304     int i;
 305     static const char *command = "PASV\r\n";
 306     static const int pasv_codes[] = {227, 0};
 307
 308     if (ftp_send_command(s, command, pasv_codes, &res) != 227 || !res)
 309         goto fail;
 310
 311     for (i = 0; res[i]; ++i) {
 312         if (res[i] == '(') {
 313             start = res + i + 1;
 314         } else if (res[i] == ')') {
 315             end = res + i;
 316             break;
 317         }
 318     }
 319     if (!start || !end)
 320         goto fail;
 321
 322     *end  = '\0';
 323     /* skip ip */
 324     if (!av_strtok(start, ",", &end)) goto fail;
 325     if (!av_strtok(end, ",", &end)) goto fail;
 326     if (!av_strtok(end, ",", &end)) goto fail;
 327     if (!av_strtok(end, ",", &end)) goto fail;
 328
 329     /* parse port number */
 330     start = av_strtok(end, ",", &end);
 331     if (!start) goto fail;
 332     s->server_data_port = atoi(start) * 256;
 333     start = av_strtok(end, ",", &end);
 334     if (!start) goto fail;
 335     s->server_data_port += atoi(start);
 336     ff_dlog(s, "Server data port: %d\n", s->server_data_port);
 337
 338     av_free(res);
 339     return 0;
 340
 341   fail:
 342     av_free(res);
 343     s->server_data_port = -1;
 344     return AVERROR(EIO);
 345 }
 346
 347 static int ftp_current_dir(FTPContext *s)
 348 {
 349     char *res = NULL, *start = NULL, *end = NULL;
 350     int i;
 351     static const char *command = "PWD\r\n";
 352     static const int pwd_codes[] = {257, 0};
 353
 354     if (ftp_send_command(s, command, pwd_codes, &res) != 257 || !res)
 355         goto fail;
 356
 357     for (i = 0; res[i]; ++i) {
 358         if (res[i] == '"') {
 359             if (!start) {
 360                 start = res + i + 1;
 361                 continue;
 362             }
 363             end = res + i;
 364             break;
 365         }
 366     }
 367
 368     if (!end)
 369         goto fail;
 370
 371     *end = '\0';
 372     s->path = av_strdup(start);
 373
 374     av_free(res);
 375
 376     if (!s->path)
 377         return AVERROR(ENOMEM);
 378     return 0;
 379
 380   fail:
 381     av_free(res);
 382     return AVERROR(EIO);
 383 }
 384
 385 static int ftp_file_size(FTPContext *s)
 386 {
 387     char command[CONTROL_BUFFER_SIZE];
 388     char *res = NULL;
 389     static const int size_codes[] = {213, 0};
 390
 391     snprintf(command, sizeof(command), "SIZE %s\r\n", s->path);
 392     if (ftp_send_command(s, command, size_codes, &res) == 213 && res) {
 393         s->filesize = strtoll(&res[4], NULL, 10);
 394     } else {
 395         s->filesize = -1;
 396         av_free(res);
 397         return AVERROR(EIO);
 398     }
 399
 400     av_free(res);
 401     return 0;
 402 }
 403
 404 static int ftp_retrieve(FTPContext *s)
 405 {
 406     char command[CONTROL_BUFFER_SIZE];
 407     static const int retr_codes[] = {150, 125, 0};
 408     int resp_code;
 409
 410     snprintf(command, sizeof(command), "RETR %s\r\n", s->path);
 411     resp_code = ftp_send_command(s, command, retr_codes, NULL);
 412     if (resp_code != 125 && resp_code != 150)
 413         return AVERROR(EIO);
 414
 415     s->state = DOWNLOADING;
 416
 417     return 0;
 418 }
 419
 420 static int ftp_store(FTPContext *s)
 421 {
 422     char command[CONTROL_BUFFER_SIZE];
 423     static const int stor_codes[] = {150, 125, 0};
 424     int resp_code;
 425
 426     snprintf(command, sizeof(command), "STOR %s\r\n", s->path);
 427     resp_code = ftp_send_command(s, command, stor_codes, NULL);
 428     if (resp_code != 125 && resp_code != 150)
 429         return AVERROR(EIO);
 430
 431     s->state = UPLOADING;
 432
 433     return 0;
 434 }
 435
 436 static int ftp_type(FTPContext *s)
 437 {
 438     static const char *command = "TYPE I\r\n";
 439     static const int type_codes[] = {200, 0};
 440
 441     if (ftp_send_command(s, command, type_codes, NULL) != 200)
 442         return AVERROR(EIO);
 443
 444     return 0;
 445 }
 446
 447 static int ftp_restart(FTPContext *s, int64_t pos)
 448 {
 449     char command[CONTROL_BUFFER_SIZE];
 450     static const int rest_codes[] = {350, 0};
 451
 452     snprintf(command, sizeof(command), "REST %"PRId64"\r\n", pos);
 453     if (ftp_send_command(s, command, rest_codes, NULL) != 350)
 454         return AVERROR(EIO);
 455
 456     return 0;
 457 }
 458
 459 static int ftp_set_dir(FTPContext *s)
 460 {
 461     static const int cwd_codes[] = {250, 550, 0}; /* 550 is incorrect code */
 462     char command[MAX_URL_SIZE];
 463
 464     snprintf(command, sizeof(command), "CWD %s\r\n", s->path);
 465     if (ftp_send_command(s, command, cwd_codes, NULL) != 250)
 466         return AVERROR(EIO);
 467     return 0;
 468 }
 469
 470 static int ftp_list_mlsd(FTPContext *s)
 471 {
 472     static const char *command = "MLSD\r\n";
 473     static const int mlsd_codes[] = {150, 500, 0}; /* 500 is incorrect code */
 474
 475     if (ftp_send_command(s, command, mlsd_codes, NULL) != 150)
 476         return AVERROR(ENOSYS);
 477     s->listing_method = MLSD;
 478     return 0;
 479 }
 480
 481 static int ftp_list_nlst(FTPContext *s)
 482 {
 483     static const char *command = "NLST\r\n";
 484     static const int nlst_codes[] = {226, 425, 426, 451, 450, 550, 0};
 485
 486     if (ftp_send_command(s, command, nlst_codes, NULL) != 226)
 487         return AVERROR(ENOSYS);
 488     s->listing_method = NLST;
 489     return 0;
 490 }
 491
 492 static int ftp_has_feature(FTPContext *s, const char *feature_name);
 493
 494 static int ftp_list(FTPContext *s)
 495 {
 496     int ret;
 497     s->state = LISTING_DIR;
 498
 499     if ((ret = ftp_list_mlsd(s)) < 0)
 500         ret = ftp_list_nlst(s);
 501
 502     return ret;
 503 }
 504
 505 static int ftp_has_feature(FTPContext *s, const char *feature_name)
 506 {
 507     if (!s->features)
 508         return 0;
 509
 510     return av_stristr(s->features, feature_name) != NULL;
 511 }
 512
 513 static int ftp_features(FTPContext *s)
 514 {
 515     static const char *feat_command        = "FEAT\r\n";
 516     static const char *enable_utf8_command = "OPTS UTF8 ON\r\n";
 517     static const int feat_codes[] = {211, 0};
 518     static const int opts_codes[] = {200, 451, 0};
 519
 520     av_freep(&s->features);
 521     if (ftp_send_command(s, feat_command, feat_codes, &s->features) != 211) {
 522         av_freep(&s->features);
 523     }
 524
 525     if (ftp_has_feature(s, "UTF8")) {
 526         if (ftp_send_command(s, enable_utf8_command, opts_codes, NULL) == 200)
 527             s->utf8 = 1;
 528     }
 529
 530     return 0;
 531 }
 532
 533 static int ftp_connect_control_connection(URLContext *h)
 534 {
 535     char buf[CONTROL_BUFFER_SIZE], *response = NULL;
 536     int err;
 537     AVDictionary *opts = NULL;
 538     FTPContext *s = h->priv_data;
 539     static const int connect_codes[] = {220, 0};
 540
 541     if (!s->conn_control) {
 542         ff_url_join(buf, sizeof(buf), "tcp", NULL,
 543                     s->hostname, s->server_control_port, NULL);
 544         if (s->rw_timeout != -1) {
 545             av_dict_set_int(&opts, "timeout", s->rw_timeout, 0);
 546         } /* if option is not given, don't pass it and let tcp use its own default */
 547         err = ffurl_open_whitelist(&s->conn_control, buf, AVIO_FLAG_READ_WRITE,
 548                                    &h->interrupt_callback, &opts,
 549                                    h->protocol_whitelist, h->protocol_blacklist, h);
 550         av_dict_free(&opts);
 551         if (err < 0) {
 552             av_log(h, AV_LOG_ERROR, "Cannot open control connection\n");
 553             return err;
 554         }
 555
 556         /* check if server is ready */
 557         if (ftp_status(s, ((h->flags & AVIO_FLAG_WRITE) ? &response : NULL), connect_codes) != 220) {
 558             av_log(h, AV_LOG_ERROR, "FTP server not ready for new users\n");
 559             return AVERROR(EACCES);
 560         }
 561
 562         if ((h->flags & AVIO_FLAG_WRITE) && av_stristr(response, "pure-ftpd")) {
 563             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.");
 564         }
 565         av_free(response);
 566
 567         if ((err = ftp_auth(s)) < 0) {
 568             av_log(h, AV_LOG_ERROR, "FTP authentication failed\n");
 569             return err;
 570         }
 571
 572         if ((err = ftp_type(s)) < 0) {
 573             av_log(h, AV_LOG_ERROR, "Set content type failed\n");
 574             return err;
 575         }
 576
 577         ftp_features(s);
 578     }
 579     return 0;
 580 }
 581
 582 static int ftp_connect_data_connection(URLContext *h)
 583 {
 584     int err;
 585     char buf[CONTROL_BUFFER_SIZE];
 586     AVDictionary *opts = NULL;
 587     FTPContext *s = h->priv_data;
 588
 589     if (!s->conn_data) {
 590         /* Enter passive mode */
 591         if (ftp_passive_mode_epsv(s) < 0) {
 592             /* Use PASV as fallback */
 593             if ((err = ftp_passive_mode(s)) < 0)
 594                 return err;
 595         }
 596         /* Open data connection */
 597         ff_url_join(buf, sizeof(buf), "tcp", NULL, s->hostname, s->server_data_port, NULL);
 598         if (s->rw_timeout != -1) {
 599             av_dict_set_int(&opts, "timeout", s->rw_timeout, 0);
 600         } /* if option is not given, don't pass it and let tcp use its own default */
 601         err = ffurl_open_whitelist(&s->conn_data, buf, h->flags,
 602                                    &h->interrupt_callback, &opts,
 603                                    h->protocol_whitelist, h->protocol_blacklist, h);
 604         av_dict_free(&opts);
 605         if (err < 0)
 606             return err;
 607
 608         if (s->position)
 609             if ((err = ftp_restart(s, s->position)) < 0)
 610                 return err;
 611     }
 612     s->state = READY;
 613     return 0;
 614 }
 615
 616 static int ftp_abort(URLContext *h)
 617 {
 618     static const char *command = "ABOR\r\n";
 619     int err;
 620     static const int abor_codes[] = {225, 226, 0};
 621     FTPContext *s = h->priv_data;
 622
 623     /* According to RCF 959:
 624        "ABOR command tells the server to abort the previous FTP
 625        service command and any associated transfer of data."
 626
 627        There are FTP server implementations that don't response
 628        to any commands during data transfer in passive mode (including ABOR).
 629
 630        This implementation closes data connection by force.
 631     */
 632
 633     if (ftp_send_command(s, command, NULL, NULL) < 0) {
 634         ftp_close_both_connections(s);
 635         if ((err = ftp_connect_control_connection(h)) < 0) {
 636             av_log(h, AV_LOG_ERROR, "Reconnect failed.\n");
 637             return err;
 638         }
 639     } else {
 640         ftp_close_data_connection(s);
 641         if (ftp_status(s, NULL, abor_codes) < 225) {
 642             /* wu-ftpd also closes control connection after data connection closing */
 643             ffurl_closep(&s->conn_control);
 644             if ((err = ftp_connect_control_connection(h)) < 0) {
 645                 av_log(h, AV_LOG_ERROR, "Reconnect failed.\n");
 646                 return err;
 647             }
 648         }
 649     }
 650
 651     return 0;
 652 }
 653
 654 static int ftp_connect(URLContext *h, const char *url)
 655 {
 656     char proto[10], path[MAX_URL_SIZE], credencials[MAX_URL_SIZE], hostname[MAX_URL_SIZE];
 657     const char *tok_user = NULL, *tok_pass = NULL;
 658     char *end = NULL, *newpath = NULL;
 659     int err;
 660     FTPContext *s = h->priv_data;
 661
 662     s->state = DISCONNECTED;
 663     s->listing_method = UNKNOWN_METHOD;
 664     s->filesize = -1;
 665     s->position = 0;
 666     s->features = NULL;
 667
 668     av_url_split(proto, sizeof(proto),
 669                  credencials, sizeof(credencials),
 670                  hostname, sizeof(hostname),
 671                  &s->server_control_port,
 672                  path, sizeof(path),
 673                  url);
 674
 675     tok_user = av_strtok(credencials, ":", &end);
 676     tok_pass = av_strtok(end, ":", &end);
 677     if (!tok_user) {
 678         tok_user = "anonymous";
 679         tok_pass = av_x_if_null(s->anonymous_password, "nopassword");
 680     }
 681     s->user = av_strdup(tok_user);
 682     s->password = av_strdup(tok_pass);
 683     s->hostname = av_strdup(hostname);
 684     if (!s->hostname || !s->user || (tok_pass && !s->password)) {
 685         return AVERROR(ENOMEM);
 686     }
 687
 688     if (s->server_control_port < 0 || s->server_control_port > 65535)
 689         s->server_control_port = 21;
 690
 691     if ((err = ftp_connect_control_connection(h)) < 0)
 692         return err;
 693
 694     if ((err = ftp_current_dir(s)) < 0)
 695         return err;
 696
 697     newpath = av_append_path_component(s->path, path);
 698     if (!newpath)
 699         return AVERROR(ENOMEM);
 700     av_free(s->path);
 701     s->path = newpath;
 702
 703     return 0;
 704 }
 705
 706 static int ftp_open(URLContext *h, const char *url, int flags)
 707 {
 708     FTPContext *s = h->priv_data;
 709     int err;
 710
 711     ff_dlog(h, "ftp protocol open\n");
 712
 713     if ((err = ftp_connect(h, url)) < 0)
 714         goto fail;
 715
 716     if (ftp_restart(s, 0) < 0) {
 717         h->is_streamed = 1;
 718     } else {
 719         if (ftp_file_size(s) < 0 && flags & AVIO_FLAG_READ)
 720             h->is_streamed = 1;
 721         if (s->write_seekable != 1 && flags & AVIO_FLAG_WRITE)
 722             h->is_streamed = 1;
 723     }
 724
 725     return 0;
 726
 727   fail:
 728     av_log(h, AV_LOG_ERROR, "FTP open failed\n");
 729     ftp_close(h);
 730     return err;
 731 }
 732
 733 static int64_t ftp_seek(URLContext *h, int64_t pos, int whence)
 734 {
 735     FTPContext *s = h->priv_data;
 736     int err;
 737     int64_t new_pos, fake_pos;
 738
 739     ff_dlog(h, "ftp protocol seek %"PRId64" %d\n", pos, whence);
 740
 741     switch(whence) {
 742     case AVSEEK_SIZE:
 743         return s->filesize;
 744     case SEEK_SET:
 745         new_pos = pos;
 746         break;
 747     case SEEK_CUR:
 748         new_pos = s->position + pos;
 749         break;
 750     case SEEK_END:
 751         if (s->filesize < 0)
 752             return AVERROR(EIO);
 753         new_pos = s->filesize + pos;
 754         break;
 755     default:
 756         return AVERROR(EINVAL);
 757     }
 758
 759     if (h->is_streamed)
 760         return AVERROR(EIO);
 761
 762     if (new_pos < 0) {
 763         av_log(h, AV_LOG_ERROR, "Seeking to nagative position.\n");
 764         return AVERROR(EINVAL);
 765     }
 766
 767     fake_pos = s->filesize != -1 ? FFMIN(new_pos, s->filesize) : new_pos;
 768     if (fake_pos != s->position) {
 769         if ((err = ftp_abort(h)) < 0)
 770             return err;
 771         s->position = fake_pos;
 772     }
 773     return new_pos;
 774 }
 775
 776 static int ftp_read(URLContext *h, unsigned char *buf, int size)
 777 {
 778     FTPContext *s = h->priv_data;
 779     int read, err, retry_done = 0;
 780
 781     ff_dlog(h, "ftp protocol read %d bytes\n", size);
 782   retry:
 783     if (s->state == DISCONNECTED) {
 784         /* optimization */
 785         if (s->position >= s->filesize)
 786             return 0;
 787         if ((err = ftp_connect_data_connection(h)) < 0)
 788             return err;
 789     }
 790     if (s->state == READY) {
 791         if (s->position >= s->filesize)
 792             return 0;
 793         if ((err = ftp_retrieve(s)) < 0)
 794             return err;
 795     }
 796     if (s->conn_data && s->state == DOWNLOADING) {
 797         read = ffurl_read(s->conn_data, buf, size);
 798         if (read >= 0) {
 799             s->position += read;
 800             if (s->position >= s->filesize) {
 801                 /* server will terminate, but keep current position to avoid madness */
 802                 /* save position to restart from it */
 803                 int64_t pos = s->position;
 804                 if (ftp_abort(h) < 0) {
 805                     s->position = pos;
 806                     return AVERROR(EIO);
 807                 }
 808                 s->position = pos;
 809             }
 810         }
 811         if (read <= 0 && s->position < s->filesize && !h->is_streamed) {
 812             /* Server closed connection. Probably due to inactivity */
 813             int64_t pos = s->position;
 814             av_log(h, AV_LOG_INFO, "Reconnect to FTP server.\n");
 815             if ((err = ftp_abort(h)) < 0)
 816                 return err;
 817             if ((err = ftp_seek(h, pos, SEEK_SET)) < 0) {
 818                 av_log(h, AV_LOG_ERROR, "Position cannot be restored.\n");
 819                 return err;
 820             }
 821             if (!retry_done) {
 822                 retry_done = 1;
 823                 goto retry;
 824             }
 825         }
 826         return read;
 827     }
 828
 829     av_log(h, AV_LOG_DEBUG, "FTP read failed\n");
 830     return AVERROR(EIO);
 831 }
 832
 833 static int ftp_write(URLContext *h, const unsigned char *buf, int size)
 834 {
 835     int err;
 836     FTPContext *s = h->priv_data;
 837     int written;
 838
 839     ff_dlog(h, "ftp protocol write %d bytes\n", size);
 840
 841     if (s->state == DISCONNECTED) {
 842         if ((err = ftp_connect_data_connection(h)) < 0)
 843             return err;
 844     }
 845     if (s->state == READY) {
 846         if ((err = ftp_store(s)) < 0)
 847             return err;
 848     }
 849     if (s->conn_data && s->state == UPLOADING) {
 850         written = ffurl_write(s->conn_data, buf, size);
 851         if (written > 0) {
 852             s->position += written;
 853             s->filesize = FFMAX(s->filesize, s->position);
 854         }
 855         return written;
 856     }
 857
 858     av_log(h, AV_LOG_ERROR, "FTP write failed\n");
 859     return AVERROR(EIO);
 860 }
 861
 862 static int ftp_close(URLContext *h)
 863 {
 864     FTPContext *s = h->priv_data;
 865
 866     ff_dlog(h, "ftp protocol close\n");
 867
 868     ftp_close_both_connections(s);
 869     av_freep(&s->user);
 870     av_freep(&s->password);
 871     av_freep(&s->hostname);
 872     av_freep(&s->path);
 873     av_freep(&s->features);
 874
 875     return 0;
 876 }
 877
 878 static int ftp_get_file_handle(URLContext *h)
 879 {
 880     FTPContext *s = h->priv_data;
 881
 882     ff_dlog(h, "ftp protocol get_file_handle\n");
 883
 884     if (s->conn_data)
 885         return ffurl_get_file_handle(s->conn_data);
 886
 887     return AVERROR(EIO);
 888 }
 889
 890 static int ftp_shutdown(URLContext *h, int flags)
 891 {
 892     FTPContext *s = h->priv_data;
 893
 894     ff_dlog(h, "ftp protocol shutdown\n");
 895
 896     if (s->conn_data)
 897         return ffurl_shutdown(s->conn_data, flags);
 898
 899     return AVERROR(EIO);
 900 }
 901
 902 static int ftp_open_dir(URLContext *h)
 903 {
 904     FTPContext *s = h->priv_data;
 905     int ret;
 906
 907     if ((ret = ftp_connect(h, h->filename)) < 0)
 908         goto fail;
 909     if ((ret = ftp_set_dir(s)) < 0)
 910         goto fail;
 911     if ((ret = ftp_connect_data_connection(h)) < 0)
 912         goto fail;
 913     if ((ret = ftp_list(s)) < 0)
 914         goto fail;
 915     s->dir_buffer = av_malloc(DIR_BUFFER_SIZE);
 916     if (!s->dir_buffer) {
 917         ret = AVERROR(ENOMEM);
 918         goto fail;
 919     }
 920     s->dir_buffer[0] = 0;
 921     if (s->conn_data && s->state == LISTING_DIR)
 922         return 0;
 923   fail:
 924     ffurl_closep(&s->conn_control);
 925     ffurl_closep(&s->conn_data);
 926     return ret;
 927 }
 928
 929 static int64_t ftp_parse_date(const char *date)
 930 {
 931     struct tm tv;
 932     memset(&tv, 0, sizeof(struct tm));
 933     av_small_strptime(date, "%Y%m%d%H%M%S", &tv);
 934     return INT64_C(1000000) * av_timegm(&tv);
 935 }
 936
 937 static int ftp_parse_entry_nlst(char *line, AVIODirEntry *next)
 938 {
 939     next->name = av_strdup(line);
 940     return 0;
 941 }
 942
 943 static int ftp_parse_entry_mlsd(char *mlsd, AVIODirEntry *next)
 944 {
 945     char *fact, *value;
 946     ff_dlog(NULL, "%s\n", mlsd);
 947     while(fact = av_strtok(mlsd, ";", &mlsd)) {
 948         if (fact[0] == ' ') {
 949             next->name = av_strdup(&fact[1]);
 950             continue;
 951         }
 952         fact = av_strtok(fact, "=", &value);
 953         if (!av_strcasecmp(fact, "type")) {
 954             if (!av_strcasecmp(value, "cdir") || !av_strcasecmp(value, "pdir"))
 955                 return 1;
 956             if (!av_strcasecmp(value, "dir"))
 957                 next->type = AVIO_ENTRY_DIRECTORY;
 958             else if (!av_strcasecmp(value, "file"))
 959                 next->type = AVIO_ENTRY_FILE;
 960             else if (!av_strcasecmp(value, "OS.unix=slink:"))
 961                 next->type = AVIO_ENTRY_SYMBOLIC_LINK;
 962         } else if (!av_strcasecmp(fact, "modify")) {
 963             next->modification_timestamp = ftp_parse_date(value);
 964         } else if (!av_strcasecmp(fact, "UNIX.mode")) {
 965             next->filemode = strtoumax(value, NULL, 8);
 966         } else if (!av_strcasecmp(fact, "UNIX.uid") || !av_strcasecmp(fact, "UNIX.owner"))
 967             next->user_id = strtoumax(value, NULL, 10);
 968         else if (!av_strcasecmp(fact, "UNIX.gid") || !av_strcasecmp(fact, "UNIX.group"))
 969             next->group_id = strtoumax(value, NULL, 10);
 970         else if (!av_strcasecmp(fact, "size") || !av_strcasecmp(fact, "sizd"))
 971             next->size = strtoll(value, NULL, 10);
 972     }
 973     return 0;
 974 }
 975
 976 /**
 977  * @return 0 on success, negative on error, positive on entry to discard.
 978  */
 979 static int ftp_parse_entry(URLContext *h, char *line, AVIODirEntry *next)
 980 {
 981     FTPContext *s = h->priv_data;
 982
 983     switch (s->listing_method) {
 984     case MLSD:
 985         return ftp_parse_entry_mlsd(line, next);
 986     case NLST:
 987         return ftp_parse_entry_nlst(line, next);
 988     case UNKNOWN_METHOD:
 989     default:
 990         return -1;
 991     }
 992 }
 993
 994 static int ftp_read_dir(URLContext *h, AVIODirEntry **next)
 995 {
 996     FTPContext *s = h->priv_data;
 997     char *start, *found;
 998     int ret, retried;
 999
1000     do {
1001         retried = 0;
1002         start = s->dir_buffer + s->dir_buffer_offset;
1003         while (!(found = strstr(start, "\n"))) {
1004             if (retried)
1005                 return AVERROR(EIO);
1006             s->dir_buffer_size -= s->dir_buffer_offset;
1007             s->dir_buffer_offset = 0;
1008             if (s->dir_buffer_size)
1009                 memmove(s->dir_buffer, start, s->dir_buffer_size);
1010             ret = ffurl_read(s->conn_data, s->dir_buffer + s->dir_buffer_size, DIR_BUFFER_SIZE - (s->dir_buffer_size + 1));
1011             if (ret < 0)
1012                 return ret;
1013             if (!ret) {
1014                 *next = NULL;
1015                 return 0;
1016             }
1017             s->dir_buffer_size += ret;
1018             s->dir_buffer[s->dir_buffer_size] = 0;
1019             start = s->dir_buffer;
1020             retried = 1;
1021         }
1022         s->dir_buffer_offset += (found + 1 - start);
1023         found[0] = 0;
1024         if (found > start && found[-1] == '\r')
1025             found[-1] = 0;
1026
1027         *next = ff_alloc_dir_entry();
1028         if (!*next)
1029             return AVERROR(ENOMEM);
1030         (*next)->utf8 = s->utf8;
1031         ret = ftp_parse_entry(h, start, *next);
1032         if (ret) {
1033             avio_free_directory_entry(next);
1034             if (ret < 0)
1035                 return ret;
1036         }
1037     } while (ret > 0);
1038     return 0;
1039 }
1040
1041 static int ftp_close_dir(URLContext *h)
1042 {
1043     FTPContext *s = h->priv_data;
1044     av_freep(&s->dir_buffer);
1045     ffurl_closep(&s->conn_control);
1046     ffurl_closep(&s->conn_data);
1047     return 0;
1048 }
1049
1050 static int ftp_delete(URLContext *h)
1051 {
1052     FTPContext *s = h->priv_data;
1053     char command[MAX_URL_SIZE];
1054     static const int del_codes[] = {250, 421, 450, 500, 501, 502, 530, 550, 0};
1055     static const int rmd_codes[] = {250, 421, 500, 501, 502, 530, 550, 0};
1056     int ret;
1057
1058     if ((ret = ftp_connect(h, h->filename)) < 0)
1059         goto cleanup;
1060
1061     snprintf(command, sizeof(command), "DELE %s\r\n", s->path);
1062     if (ftp_send_command(s, command, del_codes, NULL) == 250) {
1063         ret = 0;
1064         goto cleanup;
1065     }
1066
1067     snprintf(command, sizeof(command), "RMD %s\r\n", s->path);
1068     if (ftp_send_command(s, command, rmd_codes, NULL) == 250)
1069         ret = 0;
1070     else
1071         ret = AVERROR(EIO);
1072
1073 cleanup:
1074     ftp_close(h);
1075     return ret;
1076 }
1077
1078 static int ftp_move(URLContext *h_src, URLContext *h_dst)
1079 {
1080     FTPContext *s = h_src->priv_data;
1081     char command[MAX_URL_SIZE], path[MAX_URL_SIZE];
1082     static const int rnfr_codes[] = {350, 421, 450, 500, 501, 502, 503, 530, 0};
1083     static const int rnto_codes[] = {250, 421, 500, 501, 502, 503, 530, 532, 553, 0};
1084     int ret;
1085
1086     if ((ret = ftp_connect(h_src, h_src->filename)) < 0)
1087         goto cleanup;
1088
1089     snprintf(command, sizeof(command), "RNFR %s\r\n", s->path);
1090     if (ftp_send_command(s, command, rnfr_codes, NULL) != 350) {
1091         ret = AVERROR(EIO);
1092         goto cleanup;
1093     }
1094
1095     av_url_split(0, 0, 0, 0, 0, 0, 0,
1096                  path, sizeof(path),
1097                  h_dst->filename);
1098     snprintf(command, sizeof(command), "RNTO %s\r\n", path);
1099     if (ftp_send_command(s, command, rnto_codes, NULL) == 250)
1100         ret = 0;
1101     else
1102         ret = AVERROR(EIO);
1103
1104 cleanup:
1105     ftp_close(h_src);
1106     return ret;
1107 }
1108
1109 const URLProtocol ff_ftp_protocol = {
1110     .name                = "ftp",
1111     .url_open            = ftp_open,
1112     .url_read            = ftp_read,
1113     .url_write           = ftp_write,
1114     .url_seek            = ftp_seek,
1115     .url_close           = ftp_close,
1116     .url_get_file_handle = ftp_get_file_handle,
1117     .url_shutdown        = ftp_shutdown,
1118     .priv_data_size      = sizeof(FTPContext),
1119     .priv_data_class     = &ftp_context_class,
1120     .url_open_dir        = ftp_open_dir,
1121     .url_read_dir        = ftp_read_dir,
1122     .url_close_dir       = ftp_close_dir,
1123     .url_delete          = ftp_delete,
1124     .url_move            = ftp_move,
1125     .flags               = URL_PROTOCOL_FLAG_NETWORK,
1126     .default_whitelist   = "tcp",
1127 };