diff options
author | Lukasz Marek <lukasz.m.luki@gmail.com> | 2013-05-15 18:08:11 +0400 |
---|---|---|
committer | Michael Niedermayer <michaelni@gmx.at> | 2013-05-19 00:16:02 +0400 |
commit | c86d3a54dedc4dbf37a84a3559facb7e7ad8ef9f (patch) | |
tree | 3ca1d0184cbc7c2aa32a2153729bcefa3e04744e /libavformat/ftp.c | |
parent | 9f88db5df1410c6b9f08be77fa119009f63106a6 (diff) |
FTP protocol support
Implementation of ftp protocol.
Fixes #1672
Signed-off-by: Lukasz Marek <lukasz.m.luki@gmail.com>
Signed-off-by: Michael Niedermayer <michaelni@gmx.at>
Diffstat (limited to 'libavformat/ftp.c')
-rw-r--r-- | libavformat/ftp.c | 659 |
1 files changed, 659 insertions, 0 deletions
diff --git a/libavformat/ftp.c b/libavformat/ftp.c new file mode 100644 index 0000000000..62b396c0f1 --- /dev/null +++ b/libavformat/ftp.c @@ -0,0 +1,659 @@ +/* + * Copyright (c) 2013 Lukasz Marek <lukasz.m.luki@gmail.com> + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include <stdlib.h> +#include "libavutil/avstring.h" +#include "libavutil/avassert.h" +#include "avformat.h" +#include "internal.h" +#include "network.h" +#include "os_support.h" +#include "url.h" +#include "libavutil/opt.h" + +#define CONTROL_BUFFER_SIZE 1024 + +typedef enum { + UNKNOWN, + READY, + DOWNLOADING, + UPLOADING, + DISCONNECTED +} FTPState; + + +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_buf_ptr, *control_buf_end; /**< Control connection buffer */ + 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. */ + 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 */ +} FTPContext; + +#define OFFSET(x) offsetof(FTPContext, x) +#define D AV_OPT_FLAG_DECODING_PARAM +#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-anonymous-password", "password for anonynous login. E-mail address should be used.", OFFSET(anonymous_password), AV_OPT_TYPE_STRING, { 0 }, 0, 0, D|E }, + {NULL} +}; + +static const AVClass ftp_context_class = { + .class_name = "ftp", + .item_name = av_default_item_name, + .option = options, + .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_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; + } else if (!len) { + return -1; + } else { + s->control_buf_ptr = s->control_buffer; + s->control_buf_end = s->control_buffer + len; + } + } + return *s->control_buf_ptr++; +} + +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') { + /* process line */ + 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; + } + } +} + +/* + * This routine returns ftp server response code. + * Server may send more than one response for a certain command, following priorites 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) + */ +static int ftp_status(FTPContext *s, int *major, int *minor, int *extra, char **line, int pref_code) +{ + int err, result = -1, pref_code_found = 0; + char buf[CONTROL_BUFFER_SIZE]; + unsigned char d_major, d_minor, d_extra; + + /* 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; + 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); + } + + /* first code received. Now get all lines in non blocking mode */ + if (pref_code < 0 || pref_code_found) + s->conn_control_block_flag = 1; + } + return result; +} + +static int ftp_auth(FTPContext *s, char *auth) +{ + 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); + + 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) { + return AVERROR(EACCES); + } + } + + return 0; +} + +static int ftp_passive_mode(FTPContext *s) +{ + char *res = NULL, *start, *end; + int err, i; + const char *command = "PASV\r\n"; + + if ((err = ffurl_write(s->conn_control, command, strlen(command))) < 0) + return err; + if (ftp_status(s, NULL, NULL, NULL, &res, 227) != 227) + goto fail; + + start = NULL; + for (i = 0; i < strlen(res); ++i) { + if (res[i] == '(') { + start = res + i + 1; + } else if (res[i] == ')') { + end = res + i; + break; + } + } + if (!start || !end) + goto fail; + + *end = '\0'; + /* skip ip */ + if (!av_strtok(start, ",", &end)) goto fail; + if (!av_strtok(end, ",", &end)) goto fail; + if (!av_strtok(end, ",", &end)) goto fail; + if (!av_strtok(end, ",", &end)) goto fail; + + /* parse port number */ + start = av_strtok(end, ",", &end); + if (!start) goto fail; + s->server_data_port = atoi(start) * 256; + 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); + + av_free(res); + return 0; + + fail: + av_free(res); + s->server_data_port = -1; + return AVERROR(EIO); +} + +static int ftp_current_dir(FTPContext *s) +{ + char *res = NULL, *start = NULL, *end = NULL; + int err, i; + const char *command = "PWD\r\n"; + + if ((err = ffurl_write(s->conn_control, command, strlen(command))) < 0) + return err; + if (ftp_status(s, NULL, NULL, NULL, &res, 257) != 257) + goto fail; + + for (i = 0; res[i]; ++i) { + if (res[i] == '"') { + if (!start) { + start = res + i + 1; + continue; + } + end = res + i; + break; + } + } + + if (!end) + goto fail; + + if (end > res && end[-1] == '/') { + end[-1] = '\0'; + } else + *end = '\0'; + av_strlcpy(s->path, start, sizeof(s->path)); + + av_free(res); + return 0; + + fail: + av_free(res); + return AVERROR(EIO); +} + +static int ftp_file_size(FTPContext *s) +{ + char buf[CONTROL_BUFFER_SIZE]; + int err; + char *res = NULL; + + 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) { + s->filesize = atoll(&res[4]); + } else { + s->filesize = -1; + av_free(res); + return AVERROR(EIO); + } + + av_free(res); + return 0; +} + +static int ftp_retrieve(FTPContext *s) +{ + char buf[CONTROL_BUFFER_SIZE]; + int err; + + 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) + return AVERROR(EIO); + + s->state = DOWNLOADING; + + return 0; +} + +static int ftp_store(FTPContext *s) +{ + char buf[CONTROL_BUFFER_SIZE]; + int err; + + 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) + return AVERROR(EIO); + + s->state = UPLOADING; + + return 0; +} + +static int ftp_send_command(FTPContext *s, const char* command) +{ + int err; + + if ((err = ffurl_write(s->conn_control, command, strlen(command))) < 0) + return err; + ftp_status(s, &err, NULL, NULL, NULL, -1); + if (err != 2) + return AVERROR(EIO); + + return 0; +} + +static int ftp_reconnect_data_connection(URLContext *h) +{ + int err; + char buf[CONTROL_BUFFER_SIZE], opts_format[20]; + AVDictionary *opts = NULL; + FTPContext *s = h->priv_data; + + if (!s->conn_data) { + 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); + } /* 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); + av_dict_free(&opts); + if (err < 0) + return err; + } + s->state = READY; + s->position = 0; + return 0; +} + +static int ftp_open(URLContext *h, const char *url, int flags) +{ + char proto[10], auth[1024], path[MAX_URL_SIZE], buf[CONTROL_BUFFER_SIZE], opts_format[20]; + AVDictionary *opts = NULL; + int port, err; + FTPContext *s = h->priv_data; + + av_dlog(h, "ftp protocol open\n"); + + s->state = DISCONNECTED; + s->filesize = -1; + s->conn_control_interrupt_cb.opaque = s; + s->conn_control_interrupt_cb.callback = ftp_conn_control_block_control; + + av_url_split(proto, sizeof(proto), + auth, sizeof(auth), + s->hostname, sizeof(s->hostname), + &port, + path, sizeof(path), + url); + + if (port < 0) + port = 21; + + 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; + + /* 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_auth(s, auth)) < 0) + goto fail; + + if ((err = ftp_send_command(s, "TYPE I\r\n")) < 0) + goto fail; + + if ((err = ftp_current_dir(s)) < 0) + goto fail; + av_strlcat(s->path, path, sizeof(s->path)); + + if ((err = ftp_passive_mode(s)) < 0) + goto fail; + + 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); + return err; +} + +static int ftp_read(URLContext *h, unsigned char *buf, int size) +{ + FTPContext *s = h->priv_data; + int read; + + av_dlog(h, "ftp protocol read %d bytes\n", size); + + if (s->state == READY) { + ftp_retrieve(s); + } + 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) + return AVERROR(EIO); + } + } + return read; + } + + av_log(h, AV_LOG_DEBUG, "FTP read failed\n"); + return AVERROR(EIO); +} + +static int ftp_write(URLContext *h, const unsigned char *buf, int size) +{ + FTPContext *s = h->priv_data; + int written; + + av_dlog(h, "ftp protocol write %d bytes\n", size); + + if (s->state == READY) { + ftp_store(s); + } + if (s->conn_data && s->state == UPLOADING) { + written = ffurl_write(s->conn_data, buf, size); + if (written > 0) { + s->position += written; + s->filesize = FFMAX(s->filesize, s->position); + } + return written; + } + + av_log(h, AV_LOG_ERROR, "FTP write failed\n"); + return AVERROR(EIO); +} + +static int64_t ftp_seek(URLContext *h, int64_t pos, int whence) +{ + 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); + + 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 || (s->filesize >= 0 && new_pos > s->filesize)) + return AVERROR(EINVAL); + + 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); + } + + /* set passive */ + if ((err = ftp_passive_mode(s)) < 0) + return err; + + /* open new data connection */ + if ((err = ftp_reconnect_data_connection(h)) < 0) + return err; + } + + /* 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); + + s->position = pos; + } + return new_pos; +} + +static int ftp_close(URLContext *h) +{ + FTPContext *s = h->priv_data; + + av_dlog(h, "ftp protocol close\n"); + + ffurl_closep(&s->conn_control); + ffurl_closep(&s->conn_data); + + return 0; +} + +static int ftp_get_file_handle(URLContext *h) +{ + FTPContext *s = h->priv_data; + + av_dlog(h, "ftp protocol get_file_handle\n"); + + if (s->conn_data) + return ffurl_get_file_handle(s->conn_data); + + return AVERROR(EIO); +} + +static int ftp_shutdown(URLContext *h, int flags) +{ + FTPContext *s = h->priv_data; + + av_dlog(h, "ftp protocol shutdown\n"); + + if (s->conn_data) + return ffurl_shutdown(s->conn_data, flags); + + return AVERROR(EIO); +} + +URLProtocol ff_ftp_protocol = { + .name = "ftp", + .url_open = ftp_open, + .url_read = ftp_read, + .url_write = ftp_write, + .url_seek = ftp_seek, + .url_close = ftp_close, + .url_get_file_handle = ftp_get_file_handle, + .url_shutdown = ftp_shutdown, + .priv_data_size = sizeof(FTPContext), + .priv_data_class = &ftp_context_class, + .flags = URL_PROTOCOL_FLAG_NETWORK, +}; |