FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ftp.c
Go to the documentation of this file.
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 {
40 } FTPState;
41 
42 typedef enum {
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;
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) {
98  if (len < 0) {
99  return len;
100  } else if (!len) {
101  return -1;
102  } else {
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 
225 {
226  ffurl_closep(&s->conn_data);
227  s->position = 0;
228  s->state = DISCONNECTED;
229 }
230 
232 {
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 
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 
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 
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 
386 {
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 
405 {
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 {
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 {
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 
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 
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 
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 
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 
534 {
535  char buf[CONTROL_BUFFER_SIZE], *response = NULL;
536  int err;
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,
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 */
548  &h->interrupt_callback, &opts,
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 
583 {
584  int err;
585  char buf[CONTROL_BUFFER_SIZE];
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,
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) {
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 {
641  if (ftp_status(s, NULL, abor_codes) < 225) {
642  /* wu-ftpd also closes control connection after data connection closing */
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;
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),
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 
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 
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 
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;
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:
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:"))
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);
1007  s->dir_buffer_offset = 0;
1008  if (s->dir_buffer_size)
1009  memmove(s->dir_buffer, start, s->dir_buffer_size);
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) {
1034  if (ret < 0)
1035  return ret;
1036  }
1037  } while (ret > 0);
1038  return 0;
1039 }
1040 
1042 {
1043  FTPContext *s = h->priv_data;
1044  av_freep(&s->dir_buffer);
1046  ffurl_closep(&s->conn_data);
1047  return 0;
1048 }
1049 
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 
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,
1126  .default_whitelist = "tcp",
1127 };
time_t av_timegm(struct tm *tm)
Convert the decomposed UTC time in tm to a time_t value.
Definition: parseutils.c:568
const URLProtocol ff_ftp_protocol
Definition: ftp.c:1109
void av_url_split(char *proto, int proto_size, char *authorization, int authorization_size, char *hostname, int hostname_size, int *port_ptr, char *path, int path_size, const char *url)
Split a URL string into components.
Definition: utils.c:4607
#define NULL
Definition: coverity.c:32
const char * s
Definition: avisynth_c.h:768
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:94
int ffurl_open_whitelist(URLContext **puc, const char *filename, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options, const char *whitelist, const char *blacklist, URLContext *parent)
Create an URLContext for accessing to the resource indicated by url, and open it. ...
Definition: avio.c:309
#define URL_PROTOCOL_FLAG_NETWORK
Definition: url.h:34
static int ftp_get_line(FTPContext *s, char *line, int line_size)
Definition: ftp.c:110
char * password
Server user's password.
Definition: ftp.c:58
AVOption.
Definition: opt.h:246
int64_t filemode
Unix file mode, -1 if unknown.
Definition: avio.h:100
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
static int ftp_list(FTPContext *s)
Definition: ftp.c:494
static int ftp_move(URLContext *h_src, URLContext *h_dst)
Definition: ftp.c:1078
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
static int ftp_file_size(FTPContext *s)
Definition: ftp.c:385
int ffurl_write(URLContext *h, const unsigned char *buf, int size)
Write size bytes from buf to the resource accessed by h.
Definition: avio.c:421
char * av_stristr(const char *s1, const char *s2)
Locate the first case-independent occurrence in the string haystack of the string needle...
Definition: avstring.c:56
int is_streamed
true if streamed (no seek possible), default = false
Definition: url.h:45
AVIOInterruptCB interrupt_callback
Definition: url.h:47
Describes single entry of the directory.
Definition: avio.h:86
#define AVIO_FLAG_READ
read-only
Definition: avio.h:622
static int ftp_connect(URLContext *h, const char *url)
Definition: ftp.c:654
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:623
static int ftp_open(URLContext *h, const char *url, int flags)
Definition: ftp.c:706
uint8_t * control_buf_end
Definition: ftp.c:53
size_t dir_buffer_size
Definition: ftp.c:69
int flags
Definition: url.h:43
static int ftp_status(FTPContext *s, char **line, const int response_codes[])
Definition: ftp.c:138
int write_seekable
Control seekability, 0 = disable, 1 = enable.
Definition: ftp.c:64
static int ftp_retrieve(FTPContext *s)
Definition: ftp.c:404
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
int ffurl_shutdown(URLContext *h, int flags)
Signal the URLContext that we are done reading or writing the stream.
Definition: avio.c:655
Definition: ftp.c:34
Definition: ftp.c:37
#define MAX_URL_SIZE
Definition: internal.h:30
int64_t modification_timestamp
Time of last modification in microseconds since unix epoch, -1 if unknown.
Definition: avio.h:92
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
URLContext * conn_control
Control connection.
Definition: ftp.c:50
static int ftp_read_dir(URLContext *h, AVIODirEntry **next)
Definition: ftp.c:994
static int ftp_connect_data_connection(URLContext *h)
Definition: ftp.c:582
uint8_t
#define av_malloc(s)
static int ftp_set_dir(FTPContext *s)
Definition: ftp.c:459
static int ftp_shutdown(URLContext *h, int flags)
Definition: ftp.c:890
AVOptions.
FTPState
Definition: ftp.c:33
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
#define E
Definition: ftp.c:76
int64_t filesize
Size of file on server, -1 on error.
Definition: ftp.c:60
char * av_small_strptime(const char *p, const char *fmt, struct tm *dt)
Simplified version of strptime.
Definition: parseutils.c:489
static int ftp_delete(URLContext *h)
Definition: ftp.c:1050
static int flags
Definition: log.c:57
static int ftp_connect_control_connection(URLContext *h)
Definition: ftp.c:533
#define ff_dlog(a,...)
#define DIR_BUFFER_SIZE
Definition: ftp.c:31
uint8_t control_buffer[CONTROL_BUFFER_SIZE]
Control connection buffer.
Definition: ftp.c:52
ptrdiff_t size
Definition: opengl_enc.c:101
static int ftp_current_dir(FTPContext *s)
Definition: ftp.c:347
FTPListingMethod
Definition: ftp.c:42
uint8_t * control_buf_ptr
Definition: ftp.c:53
#define av_log(a,...)
static int ftp_passive_mode(FTPContext *s)
Definition: ftp.c:301
int server_data_port
Data connection port opened by server, -1 on error.
Definition: ftp.c:54
FTPListingMethod listing_method
Called listing method.
Definition: ftp.c:66
static void * av_x_if_null(const void *p, const void *x)
Return x default pointer in case p is NULL.
Definition: avutil.h:308
char * name
Filename.
Definition: avio.h:87
static int ftp_getc(FTPContext *s)
Definition: ftp.c:93
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
Definition: ftp.c:45
const char * anonymous_password
Password to be used for anonymous user.
Definition: ftp.c:63
const char * protocol_whitelist
Definition: url.h:49
av_default_item_name
#define AVERROR(e)
Definition: error.h:43
static int ftp_abort(URLContext *h)
Definition: ftp.c:616
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
Definition: graph2dot.c:48
size_t dir_buffer_offset
Definition: ftp.c:70
Definition: ftp.c:35
static int ftp_send_command(FTPContext *s, const char *command, const int response_codes[], char **response)
Definition: ftp.c:199
static void ftp_close_both_connections(FTPContext *s)
Definition: ftp.c:231
static int ftp_passive_mode_epsv(FTPContext *s)
Definition: ftp.c:259
#define FFMAX(a, b)
Definition: common.h:94
#define fail()
Definition: checkasm.h:90
void avio_free_directory_entry(AVIODirEntry **entry)
Free entry allocated by avio_read_dir().
Definition: avio.c:603
int rw_timeout
Network timeout.
Definition: ftp.c:62
common internal API header
static int ftp_parse_entry_nlst(char *line, AVIODirEntry *next)
Definition: ftp.c:937
AVDictionary * opts
Definition: movenc.c:50
static int ftp_read(URLContext *h, unsigned char *buf, int size)
Definition: ftp.c:776
static int ftp_close(URLContext *h)
Definition: ftp.c:862
URLContext * conn_data
Data connection, NULL when not connected.
Definition: ftp.c:51
#define FFMIN(a, b)
Definition: common.h:96
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:213
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:109
char * user
Server user.
Definition: ftp.c:57
static int ftp_auth(FTPContext *s)
Definition: ftp.c:237
int64_t position
Current position, calculated.
Definition: ftp.c:61
static int ftp_restart(FTPContext *s, int64_t pos)
Definition: ftp.c:447
char * features
List of server's features represented as raw response.
Definition: ftp.c:67
static int ftp_has_feature(FTPContext *s, const char *feature_name)
Definition: ftp.c:505
char * path
Path to resource on server.
Definition: ftp.c:59
int ffurl_get_file_handle(URLContext *h)
Return the file descriptor associated with this URL.
Definition: avio.c:626
int64_t size
File size in bytes, -1 if unknown.
Definition: avio.h:91
int ffurl_closep(URLContext **hh)
Close the resource accessed by the URLContext h, and free the memory used by it.
Definition: avio.c:444
int ff_url_join(char *str, int size, const char *proto, const char *authorization, const char *hostname, int port, const char *fmt,...)
Definition: url.c:36
static int64_t ftp_seek(URLContext *h, int64_t pos, int whence)
Definition: ftp.c:733
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
#define AV_BPRINT_SIZE_AUTOMATIC
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:237
const char * protocol_blacklist
Definition: url.h:50
static int ftp_close_dir(URLContext *h)
Definition: ftp.c:1041
int type
Type of the entry.
Definition: avio.h:88
static int ftp_get_file_handle(URLContext *h)
Definition: ftp.c:878
static int command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Definition: vf_drawtext.c:863
static const AVOption options[]
Definition: ftp.c:77
void * buf
Definition: avisynth_c.h:690
Definition: url.h:38
#define AVIO_FLAG_READ_WRITE
read-write pseudo flag
Definition: avio.h:624
FTPState state
State of data connection.
Definition: ftp.c:65
Describe the class of an AVClass context structure.
Definition: log.h:67
int64_t group_id
Group ID of owner, -1 if unknown.
Definition: avio.h:99
static void ftp_close_data_connection(FTPContext *s)
Definition: ftp.c:224
static int ftp_features(FTPContext *s)
Definition: ftp.c:513
void * priv_data
Definition: url.h:41
static int ftp_parse_entry_mlsd(char *mlsd, AVIODirEntry *next)
Definition: ftp.c:943
#define snprintf
Definition: snprintf.h:34
#define CONTROL_BUFFER_SIZE
Definition: ftp.c:30
misc parsing utilities
const char * name
Definition: url.h:54
char * av_strtok(char *s, const char *delim, char **saveptr)
Split the string into several tokens which can be accessed by successive calls to av_strtok()...
Definition: avstring.c:184
Definition: ftp.c:44
Main libavformat public API header.
static int ftp_write(URLContext *h, const unsigned char *buf, int size)
Definition: ftp.c:833
char * av_append_path_component(const char *path, const char *component)
Append path component to the existing path.
Definition: avstring.c:295
int utf8
Definition: ftp.c:71
#define OFFSET(x)
Definition: ftp.c:74
int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags)
Convenience wrapper for av_dict_set that converts the value to a string and stores it...
Definition: dict.c:147
char * dir_buffer
Definition: ftp.c:68
AVIODirEntry * ff_alloc_dir_entry(void)
Allocate directory entry with default values.
Definition: url.c:149
char * filename
specified URL
Definition: url.h:42
#define AVSEEK_SIZE
ORing this as the "whence" parameter to a seek function causes it to return the filesize without seek...
Definition: avio.h:501
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(constuint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(constint16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(constint32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(constint64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(constfloat *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(constdouble *) pi *(INT64_C(1)<< 63)))#defineFMT_PAIR_FUNC(out, in) staticconv_func_type *constfmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};staticvoidcpy1(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, len);}staticvoidcpy2(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 2 *len);}staticvoidcpy4(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 4 *len);}staticvoidcpy8(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, constint *ch_map, intflags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) returnNULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) returnNULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case1:ctx->simd_f=cpy1;break;case2:ctx->simd_f=cpy2;break;case4:ctx->simd_f=cpy4;break;case8:ctx->simd_f=cpy8;break;}}if(HAVE_YASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);returnctx;}voidswri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}intswri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, intlen){intch;intoff=0;constintos=(out->planar?1:out->ch_count)*out->bps;unsignedmisaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){intplanes=in->planar?in->ch_count:1;unsignedm=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;}if(ctx->out_simd_align_mask){intplanes=out->planar?out->ch_count:1;unsignedm=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;}if(ctx->simd_f &&!ctx->ch_map &&!misaligned){off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){if(out->planar==in->planar){intplanes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
char * hostname
Server address.
Definition: ftp.c:56
static int ftp_store(FTPContext *s)
Definition: ftp.c:420
static int ftp_type(FTPContext *s)
Definition: ftp.c:436
#define D
Definition: ftp.c:75
#define av_free(p)
static int ftp_open_dir(URLContext *h)
Definition: ftp.c:902
int len
int server_control_port
Control connection port, default is 21.
Definition: ftp.c:55
int64_t user_id
User ID of owner, -1 if unknown.
Definition: avio.h:98
static int ftp_list_mlsd(FTPContext *s)
Definition: ftp.c:470
static const AVClass ftp_context_class
Definition: ftp.c:84
#define av_freep(p)
void INT64 start
Definition: avisynth_c.h:690
unbuffered private I/O API
static int64_t ftp_parse_date(const char *date)
Definition: ftp.c:929
Definition: ftp.c:48
static int ftp_parse_entry(URLContext *h, char *line, AVIODirEntry *next)
Definition: ftp.c:979
int ffurl_read(URLContext *h, unsigned char *buf, int size)
Read up to size bytes from the resource accessed by h, and store the read bytes in buf...
Definition: avio.c:407
static av_cold void cleanup(FlashSV2Context *s)
Definition: flashsv2enc.c:127
static int ftp_list_nlst(FTPContext *s)
Definition: ftp.c:481