forked from KolibriOS/kolibrios
1118 lines
31 KiB
C
1118 lines
31 KiB
C
/*
|
|
* 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 "libavutil/avstring.h"
|
|
#include "libavutil/internal.h"
|
|
#include "libavutil/parseutils.h"
|
|
#include "avformat.h"
|
|
#include "internal.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 */
|
|
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. */
|
|
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)
|
|
#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 anonymous 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_close(URLContext *h);
|
|
|
|
static int ftp_getc(FTPContext *s)
|
|
{
|
|
int len;
|
|
if (s->control_buf_ptr >= s->control_buf_end) {
|
|
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;
|
|
|
|
for (;;) {
|
|
ch = ftp_getc(s);
|
|
if (ch < 0) {
|
|
return ch;
|
|
}
|
|
if (ch == '\n') {
|
|
/* process line */
|
|
if (q > line && q[-1] == '\r')
|
|
q--;
|
|
*q = '\0';
|
|
return 0;
|
|
} else {
|
|
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.
|
|
* First expected code is returned.
|
|
*/
|
|
static int ftp_status(FTPContext *s, char **line, const int response_codes[])
|
|
{
|
|
int err, i, dash = 0, result = 0, code_found = 0, linesize;
|
|
char buf[CONTROL_BUFFER_SIZE];
|
|
AVBPrint line_buffer;
|
|
|
|
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;
|
|
}
|
|
|
|
av_log(s, AV_LOG_DEBUG, "%s\n", 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';
|
|
}
|
|
}
|
|
|
|
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_send_command(FTPContext *s, const char *command,
|
|
const int response_codes[], char **response)
|
|
{
|
|
int err;
|
|
|
|
ff_dlog(s, "%s", command);
|
|
|
|
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 = NULL, *end = NULL;
|
|
int i;
|
|
static const char *command = "PASV\r\n";
|
|
static const int pasv_codes[] = {227, 0};
|
|
|
|
if (ftp_send_command(s, command, pasv_codes, &res) != 227 || !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';
|
|
/* 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);
|
|
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(EIO);
|
|
}
|
|
|
|
static int ftp_current_dir(FTPContext *s)
|
|
{
|
|
char *res = NULL, *start = NULL, *end = NULL;
|
|
int i;
|
|
static const char *command = "PWD\r\n";
|
|
static const int pwd_codes[] = {257, 0};
|
|
|
|
if (ftp_send_command(s, command, pwd_codes, &res) != 257 || !res)
|
|
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;
|
|
|
|
*end = '\0';
|
|
s->path = av_strdup(start);
|
|
|
|
av_free(res);
|
|
|
|
if (!s->path)
|
|
return AVERROR(ENOMEM);
|
|
return 0;
|
|
|
|
fail:
|
|
av_free(res);
|
|
return AVERROR(EIO);
|
|
}
|
|
|
|
static int ftp_file_size(FTPContext *s)
|
|
{
|
|
char command[CONTROL_BUFFER_SIZE];
|
|
char *res = NULL;
|
|
static const int size_codes[] = {213, 0};
|
|
|
|
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;
|
|
av_free(res);
|
|
return AVERROR(EIO);
|
|
}
|
|
|
|
av_free(res);
|
|
return 0;
|
|
}
|
|
|
|
static int ftp_retrieve(FTPContext *s)
|
|
{
|
|
char command[CONTROL_BUFFER_SIZE];
|
|
static const int retr_codes[] = {150, 0};
|
|
|
|
snprintf(command, sizeof(command), "RETR %s\r\n", s->path);
|
|
if (ftp_send_command(s, command, retr_codes, NULL) != 150)
|
|
return AVERROR(EIO);
|
|
|
|
s->state = DOWNLOADING;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int ftp_store(FTPContext *s)
|
|
{
|
|
char command[CONTROL_BUFFER_SIZE];
|
|
static const int stor_codes[] = {150, 0};
|
|
|
|
snprintf(command, sizeof(command), "STOR %s\r\n", s->path);
|
|
if (ftp_send_command(s, command, stor_codes, NULL) != 150)
|
|
return AVERROR(EIO);
|
|
|
|
s->state = UPLOADING;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int ftp_type(FTPContext *s)
|
|
{
|
|
static const char *command = "TYPE I\r\n";
|
|
static const int type_codes[] = {200, 0};
|
|
|
|
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_connect_control_connection(URLContext *h)
|
|
{
|
|
char buf[CONTROL_BUFFER_SIZE], *response = NULL;
|
|
int err;
|
|
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(&s->conn_control, buf, AVIO_FLAG_READ_WRITE,
|
|
&h->interrupt_callback, &opts);
|
|
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) {
|
|
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, h->flags,
|
|
&h->interrupt_callback, &opts);
|
|
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;
|
|
return 0;
|
|
}
|
|
|
|
static int ftp_abort(URLContext *h)
|
|
{
|
|
static const char *command = "ABOR\r\n";
|
|
int err;
|
|
static const int abor_codes[] = {225, 226, 0};
|
|
FTPContext *s = h->priv_data;
|
|
|
|
/* 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->position = 0;
|
|
s->features = NULL;
|
|
|
|
av_url_split(proto, sizeof(proto),
|
|
credencials, sizeof(credencials),
|
|
hostname, sizeof(hostname),
|
|
&s->server_control_port,
|
|
path, sizeof(path),
|
|
url);
|
|
|
|
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->server_control_port < 0 || s->server_control_port > 65535)
|
|
s->server_control_port = 21;
|
|
|
|
if ((err = ftp_connect_control_connection(h)) < 0)
|
|
return err;
|
|
|
|
if ((err = ftp_current_dir(s)) < 0)
|
|
return err;
|
|
|
|
newpath = av_append_path_component(s->path, path);
|
|
if (!newpath)
|
|
return AVERROR(ENOMEM);
|
|
av_free(s->path);
|
|
s->path = newpath;
|
|
|
|
return 0;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
return 0;
|
|
|
|
fail:
|
|
av_log(h, AV_LOG_ERROR, "FTP open failed\n");
|
|
ftp_close(h);
|
|
return err;
|
|
}
|
|
|
|
static int64_t ftp_seek(URLContext *h, int64_t pos, int whence)
|
|
{
|
|
FTPContext *s = h->priv_data;
|
|
int err;
|
|
int64_t new_pos, fake_pos;
|
|
|
|
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) {
|
|
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) {
|
|
/* 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;
|
|
}
|
|
|
|
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)
|
|
{
|
|
int err;
|
|
FTPContext *s = h->priv_data;
|
|
int written;
|
|
|
|
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) {
|
|
if ((err = ftp_store(s)) < 0)
|
|
return err;
|
|
}
|
|
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 int ftp_close(URLContext *h)
|
|
{
|
|
FTPContext *s = h->priv_data;
|
|
|
|
ff_dlog(h, "ftp protocol close\n");
|
|
|
|
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);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int ftp_get_file_handle(URLContext *h)
|
|
{
|
|
FTPContext *s = h->priv_data;
|
|
|
|
ff_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;
|
|
|
|
ff_dlog(h, "ftp protocol shutdown\n");
|
|
|
|
if (s->conn_data)
|
|
return ffurl_shutdown(s->conn_data, flags);
|
|
|
|
return AVERROR(EIO);
|
|
}
|
|
|
|
static int ftp_open_dir(URLContext *h)
|
|
{
|
|
FTPContext *s = h->priv_data;
|
|
int ret;
|
|
|
|
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_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;
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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_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;
|
|
}
|
|
|
|
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);
|
|
|
|
cleanup:
|
|
ftp_close(h);
|
|
return ret;
|
|
}
|
|
|
|
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 = {
|
|
.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,
|
|
.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,
|
|
};
|