[FFmpeg-cvslog] FTP protocol support
Lukasz Marek
git at videolan.org
Sat May 18 23:16:26 CEST 2013
ffmpeg | branch: master | Lukasz Marek <lukasz.m.luki at gmail.com> | Wed May 15 16:08:11 2013 +0200| [c86d3a54dedc4dbf37a84a3559facb7e7ad8ef9f] | committer: Michael Niedermayer
FTP protocol support
Implementation of ftp protocol.
Fixes #1672
Signed-off-by: Lukasz Marek <lukasz.m.luki at gmail.com>
Signed-off-by: Michael Niedermayer <michaelni at gmx.at>
> http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=c86d3a54dedc4dbf37a84a3559facb7e7ad8ef9f
---
Changelog | 1 +
MAINTAINERS | 1 +
configure | 1 +
doc/protocols.texi | 34 +++
libavformat/Makefile | 1 +
libavformat/allformats.c | 1 +
libavformat/ftp.c | 659 ++++++++++++++++++++++++++++++++++++++++++++++
7 files changed, 698 insertions(+)
diff --git a/Changelog b/Changelog
index 4929176..249e8c3 100644
--- a/Changelog
+++ b/Changelog
@@ -50,6 +50,7 @@ version <next>:
- Wavelet denoiser filter ported from libmpcodecs as owdenoise (formerly "ow")
- Apple Intermediate Codec decoder
- Escape 130 video decoder
+- FTP protocol support
version 1.2:
diff --git a/MAINTAINERS b/MAINTAINERS
index cec22d8..9f4301d 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -411,6 +411,7 @@ Muxers/Demuxers:
Protocols:
bluray.c Petri Hintukainen
+ ftp.c Lukasz Marek
http.c Ronald S. Bultje
mms*.c Ronald S. Bultje
udp.c Luca Abeni
diff --git a/configure b/configure
index 1e44408..1b7a847 100755
--- a/configure
+++ b/configure
@@ -2090,6 +2090,7 @@ ffrtmpcrypt_protocol_deps_any="gcrypt nettle openssl"
ffrtmpcrypt_protocol_select="tcp_protocol"
ffrtmphttp_protocol_deps="!librtmp_protocol"
ffrtmphttp_protocol_select="http_protocol"
+ftp_protocol_select="tcp_protocol"
gopher_protocol_select="network"
httpproxy_protocol_select="tcp_protocol"
http_protocol_select="tcp_protocol"
diff --git a/doc/protocols.texi b/doc/protocols.texi
index 0c56b8b..a91103a 100644
--- a/doc/protocols.texi
+++ b/doc/protocols.texi
@@ -100,6 +100,40 @@ The ff* tools default to the file protocol, that is a resource
specified with the name "FILE.mpeg" is interpreted as the URL
"file:FILE.mpeg".
+ at section ftp
+
+FTP (File Transfer Protocol)
+
+Allow to read from or write to remote resources using FTP protocol.
+
+Following syntax is required.
+ at example
+ftp://[user[:password]@@]server[:port]/path/to/remote/resource.mpeg
+ at end example
+
+This protocol accepts the following options.
+
+ at table @option
+ at item timeout
+Set timeout of socket I/O operations used by the underlying low level
+operation. By default it is set to -1, which means that the timeout is
+not specified.
+
+ at item ftp-anonymous-password
+Password used when login as anonymous user. Typically an e-mail address
+should be used.
+
+ at item ftp-write-seekable
+Control seekability of connection during encoding. If set to 1 the
+resource is supposed to be seekable, if set to 0 it is assumed not
+to be seekable. Default value is 0.
+ at end table
+
+NOTE: Protocol can be used as output, but it is recommended to not do
+it, unless special care is taken (tests, customized server configuration
+etc.). Different FTP servers behave in different way during seek
+operation. ff* tools may produce incomplete content due to server limitations.
+
@section gopher
Gopher protocol.
diff --git a/libavformat/Makefile b/libavformat/Makefile
index 24dd3cd..abc2472 100644
--- a/libavformat/Makefile
+++ b/libavformat/Makefile
@@ -424,6 +424,7 @@ OBJS-$(CONFIG_DATA_PROTOCOL) += data_uri.o
OBJS-$(CONFIG_FFRTMPCRYPT_PROTOCOL) += rtmpcrypt.o rtmpdh.o
OBJS-$(CONFIG_FFRTMPHTTP_PROTOCOL) += rtmphttp.o
OBJS-$(CONFIG_FILE_PROTOCOL) += file.o
+OBJS-$(CONFIG_FTP_PROTOCOL) += ftp.o
OBJS-$(CONFIG_GOPHER_PROTOCOL) += gopher.o
OBJS-$(CONFIG_HLS_PROTOCOL) += hlsproto.o
OBJS-$(CONFIG_HTTP_PROTOCOL) += http.o httpauth.o urldecode.o
diff --git a/libavformat/allformats.c b/libavformat/allformats.c
index 2b2d46d..ab6a548 100644
--- a/libavformat/allformats.c
+++ b/libavformat/allformats.c
@@ -313,6 +313,7 @@ void av_register_all(void)
REGISTER_PROTOCOL(FFRTMPCRYPT, ffrtmpcrypt);
REGISTER_PROTOCOL(FFRTMPHTTP, ffrtmphttp);
REGISTER_PROTOCOL(FILE, file);
+ REGISTER_PROTOCOL(FTP, ftp);
REGISTER_PROTOCOL(GOPHER, gopher);
REGISTER_PROTOCOL(HLS, hls);
REGISTER_PROTOCOL(HTTP, http);
diff --git a/libavformat/ftp.c b/libavformat/ftp.c
new file mode 100644
index 0000000..62b396c
--- /dev/null
+++ b/libavformat/ftp.c
@@ -0,0 +1,659 @@
+/*
+ * Copyright (c) 2013 Lukasz Marek <lukasz.m.luki at 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,
+};
More information about the ffmpeg-cvslog
mailing list