FFmpeg: libavformat/ftp.c Source File

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 };

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 };

91 static int ftp_close(URLContext *h);

93 static int ftp_getc(FTPContext *s)

94 {

95 int len;

96 if (s->control_buf_ptr >= s->control_buf_end) {

97 len = ffurl_read(s->conn_control, s->control_buffer, CONTROL_BUFFER_SIZE);

98 if (len < 0) {

99 return len;

100 } else if (!len) {

101 return -1;

102 } else {

103 s->control_buf_ptr = s->control_buffer;

104 s->control_buf_end = s->control_buffer + len;

105 }

106 }

107 return *s->control_buf_ptr++;

108 }

109

110 static int ftp_get_line(FTPContext *s, char *line, int line_size)

111 {

112 int ch;

113 char *q = line;

114

115 for (;;) {

116 ch = ftp_getc(s);

117 if (ch < 0) {

118 return ch;

119 }

120 if (ch == '\n') {

121 /* process line */

122 if (q > line && q[-1] == '\r')

123 q--;

124 *q = '0円';

125 return 0;

126 } else {

127 if ((q - line) < line_size - 1)

128 *q++ = ch;

129 }

130 }

131 }

132

133 /*

134 * This routine returns ftp server response code.

135 * Server may send more than one response for a certain command.

136 * First expected code is returned.

137 */

138 static int ftp_status(FTPContext *s, char **line, const int response_codes[])

139 {

140 int err, i, dash = 0, result = 0, code_found = 0, linesize;

141 char buf[CONTROL_BUFFER_SIZE];

142 AVBPrint line_buffer;

143

144 if (line)

145 av_bprint_init(&line_buffer, 0, AV_BPRINT_SIZE_AUTOMATIC);

146

147 while (!code_found || dash) {

148 if ((err = ftp_get_line(s, buf, sizeof(buf))) < 0) {

149 if (line)

150 av_bprint_finalize(&line_buffer, NULL);

151 return err;

152 }

153

154 av_log(s, AV_LOG_DEBUG, "%s\n", buf);

155

156 linesize = strlen(buf);

157 err = 0;

158 if (linesize >= 3) {

159 for (i = 0; i < 3; ++i) {

160 if (buf[i] < '0' || buf[i] > '9') {

161 err = 0;

162 break;

163 }

164 err *= 10;

165 err += buf[i] - '0';

166 }

167 }

168

169 if (!code_found) {

170 if (err >= 500) {

171 code_found = 1;

172 result = err;

173 } else

174 for (i = 0; response_codes[i]; ++i) {

175 if (err == response_codes[i]) {

176 code_found = 1;

177 result = err;

178 break;

179 }

180 }

181 }

182 if (code_found) {

183 if (line)

184 av_bprintf(&line_buffer, "%s\r\n", buf);

185 if (linesize >= 4) {

186 if (!dash && buf[3] == '-')

187 dash = err;

188 else if (err == dash && buf[3] == ' ')

189 dash = 0;

190 }

191 }

192 }

193

194 if (line)

195 av_bprint_finalize(&line_buffer, line);

196 return result;

197 }

198

199 static int ftp_send_command(FTPContext *s, const char *command,

200 const int response_codes[], char **response)

201 {

202 int err;

203

204 ff_dlog(s, "%s", command);

205

206 if (response)

207 *response = NULL;

208

209 if (!s->conn_control)

210 return AVERROR(EIO);

211

212 if ((err = ffurl_write(s->conn_control, command, strlen(command))) < 0)

213 return err;

214 if (!err)

215 return -1;

216

217 /* return status */

218 if (response_codes) {

219 return ftp_status(s, response, response_codes);

220 }

221 return 0;

222 }

223

224 static void ftp_close_data_connection(FTPContext *s)

225 {

226 ffurl_closep(&s->conn_data);

227 s->position = 0;

228 s->state = DISCONNECTED;

229 }

230

231 static void ftp_close_both_connections(FTPContext *s)

232 {

233 ffurl_closep(&s->conn_control);

234 ftp_close_data_connection(s);

235 }

236

237 static int ftp_auth(FTPContext *s)

238 {

239 char buf[CONTROL_BUFFER_SIZE];

240 int err;

241 static const int user_codes[] = {331, 230, 0};

242 static const int pass_codes[] = {230, 0};

243

244 snprintf(buf, sizeof(buf), "USER %s\r\n", s->user);

245 err = ftp_send_command(s, buf, user_codes, NULL);

246 if (err == 331) {

247 if (s->password) {

248 snprintf(buf, sizeof(buf), "PASS %s\r\n", s->password);

249 err = ftp_send_command(s, buf, pass_codes, NULL);

250 } else

251 return AVERROR(EACCES);

252 }

253 if (err != 230)

254 return AVERROR(EACCES);

255

256 return 0;

257 }

258

259 static int ftp_passive_mode_epsv(FTPContext *s)

260 {

261 char *res = NULL, *start = NULL, *end = NULL;

262 int i;

263 static const char d = '|';

264 static const char *command = "EPSV\r\n";

265 static const int epsv_codes[] = {229, 0};

266

267 if (ftp_send_command(s, command, epsv_codes, &res) != 229 || !res)

268 goto fail;

269

270 for (i = 0; res[i]; ++i) {

271 if (res[i] == '(') {

272 start = res + i + 1;

273 } else if (res[i] == ')') {

274 end = res + i;

275 break;

276 }

277 }

278 if (!start || !end)

279 goto fail;

280

281 *end = '0円';

282 if (strlen(start) < 5)

283 goto fail;

284 if (start[0] != d || start[1] != d || start[2] != d || end[-1] != d)

285 goto fail;

286 start += 3;

287 end[-1] = '0円';

288

289 s->server_data_port = atoi(start);

290 ff_dlog(s, "Server data port: %d\n", s->server_data_port);

291

292 av_free(res);

293 return 0;

294

295 fail:

296 av_free(res);

297 s->server_data_port = -1;

298 return AVERROR(ENOSYS);

299 }

300

301 static int ftp_passive_mode(FTPContext *s)

302 {

303 char *res = NULL, *start = NULL, *end = NULL;

304 int i;

305 static const char *command = "PASV\r\n";

306 static const int pasv_codes[] = {227, 0};

307

308 if (ftp_send_command(s, command, pasv_codes, &res) != 227 || !res)

309 goto fail;

310

311 for (i = 0; res[i]; ++i) {

312 if (res[i] == '(') {

313 start = res + i + 1;

314 } else if (res[i] == ')') {

315 end = res + i;

316 break;

317 }

318 }

319 if (!start || !end)

320 goto fail;

321

322 *end = '0円';

323 /* skip ip */

324 if (!av_strtok(start, ",", &end)) goto fail;

325 if (!av_strtok(end, ",", &end)) goto fail;

326 if (!av_strtok(end, ",", &end)) goto fail;

327 if (!av_strtok(end, ",", &end)) goto fail;

328

329 /* parse port number */

330 start = av_strtok(end, ",", &end);

331 if (!start) goto fail;

332 s->server_data_port = atoi(start) * 256;

333 start = av_strtok(end, ",", &end);

334 if (!start) goto fail;

335 s->server_data_port += atoi(start);

336 ff_dlog(s, "Server data port: %d\n", s->server_data_port);

337

338 av_free(res);

339 return 0;

340

341 fail:

342 av_free(res);

343 s->server_data_port = -1;

344 return AVERROR(EIO);

345 }

346

347 static int ftp_current_dir(FTPContext *s)

348 {

349 char *res = NULL, *start = NULL, *end = NULL;

350 int i;

351 static const char *command = "PWD\r\n";

352 static const int pwd_codes[] = {257, 0};

353

354 if (ftp_send_command(s, command, pwd_codes, &res) != 257 || !res)

355 goto fail;

356

357 for (i = 0; res[i]; ++i) {

358 if (res[i] == '"') {

359 if (!start) {

360 start = res + i + 1;

361 continue;

362 }

363 end = res + i;

364 break;

365 }

366 }

367

368 if (!end)

369 goto fail;

370

371 *end = '0円';

372 s->path = av_strdup(start);

373

374 av_free(res);

375

376 if (!s->path)

377 return AVERROR(ENOMEM);

378 return 0;

379

380 fail:

381 av_free(res);

382 return AVERROR(EIO);

383 }

384

385 static int ftp_file_size(FTPContext *s)

386 {

387 char command[CONTROL_BUFFER_SIZE];

388 char *res = NULL;

389 static const int size_codes[] = {213, 0};

390

391 snprintf(command, sizeof(command), "SIZE %s\r\n", s->path);

392 if (ftp_send_command(s, command, size_codes, &res) == 213 && res) {

393 s->filesize = strtoll(&res[4], NULL, 10);

394 } else {

395 s->filesize = -1;

396 av_free(res);

397 return AVERROR(EIO);

398 }

399

400 av_free(res);

401 return 0;

402 }

403

404 static int ftp_retrieve(FTPContext *s)

405 {

406 char command[CONTROL_BUFFER_SIZE];

407 static const int retr_codes[] = {150, 125, 0};

408 int resp_code;

409

410 snprintf(command, sizeof(command), "RETR %s\r\n", s->path);

411 resp_code = ftp_send_command(s, command, retr_codes, NULL);

412 if (resp_code != 125 && resp_code != 150)

413 return AVERROR(EIO);

414

415 s->state = DOWNLOADING;

416

417 return 0;

418 }

419

420 static int ftp_store(FTPContext *s)

421 {

422 char command[CONTROL_BUFFER_SIZE];

423 static const int stor_codes[] = {150, 125, 0};

424 int resp_code;

425

426 snprintf(command, sizeof(command), "STOR %s\r\n", s->path);

427 resp_code = ftp_send_command(s, command, stor_codes, NULL);

428 if (resp_code != 125 && resp_code != 150)

429 return AVERROR(EIO);

430

431 s->state = UPLOADING;

432

433 return 0;

434 }

435

436 static int ftp_type(FTPContext *s)

437 {

438 static const char *command = "TYPE I\r\n";

439 static const int type_codes[] = {200, 0};

440

441 if (ftp_send_command(s, command, type_codes, NULL) != 200)

442 return AVERROR(EIO);

443

444 return 0;

445 }

446

447 static int ftp_restart(FTPContext *s, int64_t pos)

448 {

449 char command[CONTROL_BUFFER_SIZE];

450 static const int rest_codes[] = {350, 0};

451

452 snprintf(command, sizeof(command), "REST %"PRId64"\r\n", pos);

453 if (ftp_send_command(s, command, rest_codes, NULL) != 350)

454 return AVERROR(EIO);

455

456 return 0;

457 }

458

459 static int ftp_set_dir(FTPContext *s)

460 {

461 static const int cwd_codes[] = {250, 550, 0}; /* 550 is incorrect code */

462 char command[MAX_URL_SIZE];

463

464 snprintf(command, sizeof(command), "CWD %s\r\n", s->path);

465 if (ftp_send_command(s, command, cwd_codes, NULL) != 250)

466 return AVERROR(EIO);

467 return 0;

468 }

469

470 static int ftp_list_mlsd(FTPContext *s)

471 {

472 static const char *command = "MLSD\r\n";

473 static const int mlsd_codes[] = {150, 500, 0}; /* 500 is incorrect code */

474

475 if (ftp_send_command(s, command, mlsd_codes, NULL) != 150)

476 return AVERROR(ENOSYS);

477 s->listing_method = MLSD;

478 return 0;

479 }

480

481 static int ftp_list_nlst(FTPContext *s)

482 {

483 static const char *command = "NLST\r\n";

484 static const int nlst_codes[] = {226, 425, 426, 451, 450, 550, 0};

485

486 if (ftp_send_command(s, command, nlst_codes, NULL) != 226)

487 return AVERROR(ENOSYS);

488 s->listing_method = NLST;

489 return 0;

490 }

491

492 static int ftp_has_feature(FTPContext *s, const char *feature_name);

493

494 static int ftp_list(FTPContext *s)

495 {

496 int ret;

497 s->state = LISTING_DIR;

498

499 if ((ret = ftp_list_mlsd(s)) < 0)

500 ret = ftp_list_nlst(s);

501

502 return ret;

503 }

504

505 static int ftp_has_feature(FTPContext *s, const char *feature_name)

506 {

507 if (!s->features)

508 return 0;

509

510 return av_stristr(s->features, feature_name) != NULL;

511 }

512

513 static int ftp_features(FTPContext *s)

514 {

515 static const char *feat_command = "FEAT\r\n";

516 static const char *enable_utf8_command = "OPTS UTF8 ON\r\n";

517 static const int feat_codes[] = {211, 0};

518 static const int opts_codes[] = {200, 451, 0};

519

520 av_freep(&s->features);

521 if (ftp_send_command(s, feat_command, feat_codes, &s->features) != 211) {

522 av_freep(&s->features);

523 }

524

525 if (ftp_has_feature(s, "UTF8")) {

526 if (ftp_send_command(s, enable_utf8_command, opts_codes, NULL) == 200)

527 s->utf8 = 1;

528 }

529

530 return 0;

531 }

532

533 static int ftp_connect_control_connection(URLContext *h)

534 {

535 char buf[CONTROL_BUFFER_SIZE], *response = NULL;

536 int err;

537 AVDictionary *opts = NULL;

538 FTPContext *s = h->priv_data;

539 static const int connect_codes[] = {220, 0};

540

541 if (!s->conn_control) {

542 ff_url_join(buf, sizeof(buf), "tcp", NULL,

543 s->hostname, s->server_control_port, NULL);

544 if (s->rw_timeout != -1) {

545 av_dict_set_int(&opts, "timeout", s->rw_timeout, 0);

546 } /* if option is not given, don't pass it and let tcp use its own default */

547 err = ffurl_open_whitelist(&s->conn_control, buf, AVIO_FLAG_READ_WRITE,

548 &h->interrupt_callback, &opts,

549 h->protocol_whitelist, h->protocol_blacklist, h);

550 av_dict_free(&opts);

551 if (err < 0) {

552 av_log(h, AV_LOG_ERROR, "Cannot open control connection\n");

553 return err;

554 }

555

556 /* check if server is ready */

557 if (ftp_status(s, ((h->flags & AVIO_FLAG_WRITE) ? &response : NULL), connect_codes) != 220) {

558 av_log(h, AV_LOG_ERROR, "FTP server not ready for new users\n");

559 return AVERROR(EACCES);

560 }

561

562 if ((h->flags & AVIO_FLAG_WRITE) && av_stristr(response, "pure-ftpd")) {

563 av_log(h, AV_LOG_WARNING, "Pure-FTPd server is used as an output protocol. It is known issue this implementation may produce incorrect content and it cannot be fixed at this moment.");

564 }

565 av_free(response);

566

567 if ((err = ftp_auth(s)) < 0) {

568 av_log(h, AV_LOG_ERROR, "FTP authentication failed\n");

569 return err;

570 }

571

572 if ((err = ftp_type(s)) < 0) {

573 av_log(h, AV_LOG_ERROR, "Set content type failed\n");

574 return err;

575 }

576

577 ftp_features(s);

578 }

579 return 0;

580 }

581

582 static int ftp_connect_data_connection(URLContext *h)

583 {

584 int err;

585 char buf[CONTROL_BUFFER_SIZE];

586 AVDictionary *opts = NULL;

587 FTPContext *s = h->priv_data;

588

589 if (!s->conn_data) {

590 /* Enter passive mode */

591 if (ftp_passive_mode_epsv(s) < 0) {

592 /* Use PASV as fallback */

593 if ((err = ftp_passive_mode(s)) < 0)

594 return err;

595 }

596 /* Open data connection */

597 ff_url_join(buf, sizeof(buf), "tcp", NULL, s->hostname, s->server_data_port, NULL);

598 if (s->rw_timeout != -1) {

599 av_dict_set_int(&opts, "timeout", s->rw_timeout, 0);

600 } /* if option is not given, don't pass it and let tcp use its own default */

601 err = ffurl_open_whitelist(&s->conn_data, buf, h->flags,

602 &h->interrupt_callback, &opts,

603 h->protocol_whitelist, h->protocol_blacklist, h);

604 av_dict_free(&opts);

605 if (err < 0)

606 return err;

607

608 if (s->position)

609 if ((err = ftp_restart(s, s->position)) < 0)

610 return err;

611 }

612 s->state = READY;

613 return 0;

614 }

615

616 static int ftp_abort(URLContext *h)

617 {

618 static const char *command = "ABOR\r\n";

619 int err;

620 static const int abor_codes[] = {225, 226, 0};

621 FTPContext *s = h->priv_data;

622

623 /* According to RCF 959:

624 "ABOR command tells the server to abort the previous FTP

625 service command and any associated transfer of data."

626

627 There are FTP server implementations that don't response

628 to any commands during data transfer in passive mode (including ABOR).

629

630 This implementation closes data connection by force.

631 */

632

633 if (ftp_send_command(s, command, NULL, NULL) < 0) {

634 ftp_close_both_connections(s);

635 if ((err = ftp_connect_control_connection(h)) < 0) {

636 av_log(h, AV_LOG_ERROR, "Reconnect failed.\n");

637 return err;

638 }

639 } else {

640 ftp_close_data_connection(s);

641 if (ftp_status(s, NULL, abor_codes) < 225) {

642 /* wu-ftpd also closes control connection after data connection closing */

643 ffurl_closep(&s->conn_control);

644 if ((err = ftp_connect_control_connection(h)) < 0) {

645 av_log(h, AV_LOG_ERROR, "Reconnect failed.\n");

646 return err;

647 }

648 }

649 }

650

651 return 0;

652 }

653

654 static int ftp_connect(URLContext *h, const char *url)

655 {

656 char proto[10], path[MAX_URL_SIZE], credencials[MAX_URL_SIZE], hostname[MAX_URL_SIZE];

657 const char *tok_user = NULL, *tok_pass = NULL;

658 char *end = NULL, *newpath = NULL;

659 int err;

660 FTPContext *s = h->priv_data;

661

662 s->state = DISCONNECTED;

663 s->listing_method = UNKNOWN_METHOD;

664 s->filesize = -1;

665 s->position = 0;

666 s->features = NULL;

667

668 av_url_split(proto, sizeof(proto),

669 credencials, sizeof(credencials),

670 hostname, sizeof(hostname),

671 &s->server_control_port,

672 path, sizeof(path),

673 url);

674

675 tok_user = av_strtok(credencials, ":", &end);

676 tok_pass = av_strtok(end, ":", &end);

677 if (!tok_user) {

678 tok_user = "anonymous";

679 tok_pass = av_x_if_null(s->anonymous_password, "nopassword");

680 }

681 s->user = av_strdup(tok_user);

682 s->password = av_strdup(tok_pass);

683 s->hostname = av_strdup(hostname);

684 if (!s->hostname || !s->user || (tok_pass && !s->password)) {

685 return AVERROR(ENOMEM);

686 }

687

688 if (s->server_control_port < 0 || s->server_control_port > 65535)

689 s->server_control_port = 21;

690

691 if ((err = ftp_connect_control_connection(h)) < 0)

692 return err;

693

694 if ((err = ftp_current_dir(s)) < 0)

695 return err;

696

697 newpath = av_append_path_component(s->path, path);

698 if (!newpath)

699 return AVERROR(ENOMEM);

700 av_free(s->path);

701 s->path = newpath;

702

703 return 0;

704 }

705

706 static int ftp_open(URLContext *h, const char *url, int flags)

707 {

708 FTPContext *s = h->priv_data;

709 int err;

710

711 ff_dlog(h, "ftp protocol open\n");

712

713 if ((err = ftp_connect(h, url)) < 0)

714 goto fail;

715

716 if (ftp_restart(s, 0) < 0) {

717 h->is_streamed = 1;

718 } else {

719 if (ftp_file_size(s) < 0 && flags & AVIO_FLAG_READ)

720 h->is_streamed = 1;

721 if (s->write_seekable != 1 && flags & AVIO_FLAG_WRITE)

722 h->is_streamed = 1;

723 }

724

725 return 0;

726

727 fail:

728 av_log(h, AV_LOG_ERROR, "FTP open failed\n");

729 ftp_close(h);

730 return err;

731 }

732

733 static int64_t ftp_seek(URLContext *h, int64_t pos, int whence)

734 {

735 FTPContext *s = h->priv_data;

736 int err;

737 int64_t new_pos, fake_pos;

738

739 ff_dlog(h, "ftp protocol seek %"PRId64" %d\n", pos, whence);

740

741 switch(whence) {

742 case AVSEEK_SIZE:

743 return s->filesize;

744 case SEEK_SET:

745 new_pos = pos;

746 break;

747 case SEEK_CUR:

748 new_pos = s->position + pos;

749 break;

750 case SEEK_END:

751 if (s->filesize < 0)

752 return AVERROR(EIO);

753 new_pos = s->filesize + pos;

754 break;

755 default:

756 return AVERROR(EINVAL);

757 }

758

759 if (h->is_streamed)

760 return AVERROR(EIO);

761

762 if (new_pos < 0) {

763 av_log(h, AV_LOG_ERROR, "Seeking to nagative position.\n");

764 return AVERROR(EINVAL);

765 }

766

767 fake_pos = s->filesize != -1 ? FFMIN(new_pos, s->filesize) : new_pos;

768 if (fake_pos != s->position) {

769 if ((err = ftp_abort(h)) < 0)

770 return err;

771 s->position = fake_pos;

772 }

773 return new_pos;

774 }

775

776 static int ftp_read(URLContext *h, unsigned char *buf, int size)

777 {

778 FTPContext *s = h->priv_data;

779 int read, err, retry_done = 0;

780

781 ff_dlog(h, "ftp protocol read %d bytes\n", size);

782 retry:

783 if (s->state == DISCONNECTED) {

784 /* optimization */

785 if (s->position >= s->filesize)

786 return 0;

787 if ((err = ftp_connect_data_connection(h)) < 0)

788 return err;

789 }

790 if (s->state == READY) {

791 if (s->position >= s->filesize)

792 return 0;

793 if ((err = ftp_retrieve(s)) < 0)

794 return err;

795 }

796 if (s->conn_data && s->state == DOWNLOADING) {

797 read = ffurl_read(s->conn_data, buf, size);

798 if (read >= 0) {

799 s->position += read;

800 if (s->position >= s->filesize) {

801 /* server will terminate, but keep current position to avoid madness */

802 /* save position to restart from it */

803 int64_t pos = s->position;

804 if (ftp_abort(h) < 0) {

805 s->position = pos;

806 return AVERROR(EIO);

807 }

808 s->position = pos;

809 }

810 }

811 if (read <= 0 && s->position < s->filesize && !h->is_streamed) {

812 /* Server closed connection. Probably due to inactivity */

813 int64_t pos = s->position;

814 av_log(h, AV_LOG_INFO, "Reconnect to FTP server.\n");

815 if ((err = ftp_abort(h)) < 0)

816 return err;

817 if ((err = ftp_seek(h, pos, SEEK_SET)) < 0) {

818 av_log(h, AV_LOG_ERROR, "Position cannot be restored.\n");

819 return err;

820 }

821 if (!retry_done) {

822 retry_done = 1;

823 goto retry;

824 }

825 }

826 return read;

827 }

828

829 av_log(h, AV_LOG_DEBUG, "FTP read failed\n");

830 return AVERROR(EIO);

831 }

832

833 static int ftp_write(URLContext *h, const unsigned char *buf, int size)

834 {

835 int err;

836 FTPContext *s = h->priv_data;

837 int written;

838

839 ff_dlog(h, "ftp protocol write %d bytes\n", size);

840

841 if (s->state == DISCONNECTED) {

842 if ((err = ftp_connect_data_connection(h)) < 0)

843 return err;

844 }

845 if (s->state == READY) {

846 if ((err = ftp_store(s)) < 0)

847 return err;

848 }

849 if (s->conn_data && s->state == UPLOADING) {

850 written = ffurl_write(s->conn_data, buf, size);

851 if (written > 0) {

852 s->position += written;

853 s->filesize = FFMAX(s->filesize, s->position);

854 }

855 return written;

856 }

857

858 av_log(h, AV_LOG_ERROR, "FTP write failed\n");

859 return AVERROR(EIO);

860 }

861

862 static int ftp_close(URLContext *h)

863 {

864 FTPContext *s = h->priv_data;

865

866 ff_dlog(h, "ftp protocol close\n");

867

868 ftp_close_both_connections(s);

869 av_freep(&s->user);

870 av_freep(&s->password);

871 av_freep(&s->hostname);

872 av_freep(&s->path);

873 av_freep(&s->features);

874

875 return 0;

876 }

877

878 static int ftp_get_file_handle(URLContext *h)

879 {

880 FTPContext *s = h->priv_data;

881

882 ff_dlog(h, "ftp protocol get_file_handle\n");

883

884 if (s->conn_data)

885 return ffurl_get_file_handle(s->conn_data);

886

887 return AVERROR(EIO);

888 }

889

890 static int ftp_shutdown(URLContext *h, int flags)

891 {

892 FTPContext *s = h->priv_data;

893

894 ff_dlog(h, "ftp protocol shutdown\n");

895

896 if (s->conn_data)

897 return ffurl_shutdown(s->conn_data, flags);

898

899 return AVERROR(EIO);

900 }

901

902 static int ftp_open_dir(URLContext *h)

903 {

904 FTPContext *s = h->priv_data;

905 int ret;

906

907 if ((ret = ftp_connect(h, h->filename)) < 0)

908 goto fail;

909 if ((ret = ftp_set_dir(s)) < 0)

910 goto fail;

911 if ((ret = ftp_connect_data_connection(h)) < 0)

912 goto fail;

913 if ((ret = ftp_list(s)) < 0)

914 goto fail;

915 s->dir_buffer = av_malloc(DIR_BUFFER_SIZE);

916 if (!s->dir_buffer) {

917 ret = AVERROR(ENOMEM);

918 goto fail;

919 }

920 s->dir_buffer[0] = 0;

921 if (s->conn_data && s->state == LISTING_DIR)

922 return 0;

923 fail:

924 ffurl_closep(&s->conn_control);

925 ffurl_closep(&s->conn_data);

926 return ret;

927 }

928

929 static int64_t ftp_parse_date(const char *date)

930 {

931 struct tm tv;

932 memset(&tv, 0, sizeof(struct tm));

933 av_small_strptime(date, "%Y%m%d%H%M%S", &tv);

934 return INT64_C(1000000) * av_timegm(&tv);

935 }

936

937 static int ftp_parse_entry_nlst(char *line, AVIODirEntry *next)

938 {

939 next->name = av_strdup(line);

940 return 0;

941 }

942

943 static int ftp_parse_entry_mlsd(char *mlsd, AVIODirEntry *next)

944 {

945 char *fact, *value;

946 ff_dlog(NULL, "%s\n", mlsd);

947 while(fact = av_strtok(mlsd, ";", &mlsd)) {

948 if (fact[0] == ' ') {

949 next->name = av_strdup(&fact[1]);

950 continue;

951 }

952 fact = av_strtok(fact, "=", &value);

953 if (!av_strcasecmp(fact, "type")) {

954 if (!av_strcasecmp(value, "cdir") || !av_strcasecmp(value, "pdir"))

955 return 1;

956 if (!av_strcasecmp(value, "dir"))

957 next->type = AVIO_ENTRY_DIRECTORY;

958 else if (!av_strcasecmp(value, "file"))

959 next->type = AVIO_ENTRY_FILE;

960 else if (!av_strcasecmp(value, "OS.unix=slink:"))

961 next->type = AVIO_ENTRY_SYMBOLIC_LINK;

962 } else if (!av_strcasecmp(fact, "modify")) {

963 next->modification_timestamp = ftp_parse_date(value);

964 } else if (!av_strcasecmp(fact, "UNIX.mode")) {

965 next->filemode = strtoumax(value, NULL, 8);

966 } else if (!av_strcasecmp(fact, "UNIX.uid") || !av_strcasecmp(fact, "UNIX.owner"))

967 next->user_id = strtoumax(value, NULL, 10);

968 else if (!av_strcasecmp(fact, "UNIX.gid") || !av_strcasecmp(fact, "UNIX.group"))

969 next->group_id = strtoumax(value, NULL, 10);

970 else if (!av_strcasecmp(fact, "size") || !av_strcasecmp(fact, "sizd"))

971 next->size = strtoll(value, NULL, 10);

972 }

973 return 0;

974 }

975

976 /**

977 * @return 0 on success, negative on error, positive on entry to discard.

978 */

979 static int ftp_parse_entry(URLContext *h, char *line, AVIODirEntry *next)

980 {

981 FTPContext *s = h->priv_data;

982

983 switch (s->listing_method) {

984 case MLSD:

985 return ftp_parse_entry_mlsd(line, next);

986 case NLST:

987 return ftp_parse_entry_nlst(line, next);

988 case UNKNOWN_METHOD:

989 default:

990 return -1;

991 }

992 }

993

994 static int ftp_read_dir(URLContext *h, AVIODirEntry **next)

995 {

996 FTPContext *s = h->priv_data;

997 char *start, *found;

998 int ret, retried;

999

1000 do {

1001 retried = 0;

1002 start = s->dir_buffer + s->dir_buffer_offset;

1003 while (!(found = strstr(start, "\n"))) {

1004 if (retried)

1005 return AVERROR(EIO);

1006 s->dir_buffer_size -= s->dir_buffer_offset;

1007 s->dir_buffer_offset = 0;

1008 if (s->dir_buffer_size)

1009 memmove(s->dir_buffer, start, s->dir_buffer_size);

1010 ret = ffurl_read(s->conn_data, s->dir_buffer + s->dir_buffer_size, DIR_BUFFER_SIZE - (s->dir_buffer_size + 1));

1011 if (ret < 0)

1012 return ret;

1013 if (!ret) {

1014 *next = NULL;

1015 return 0;

1016 }

1017 s->dir_buffer_size += ret;

1018 s->dir_buffer[s->dir_buffer_size] = 0;

1019 start = s->dir_buffer;

1020 retried = 1;

1021 }

1022 s->dir_buffer_offset += (found + 1 - start);

1023 found[0] = 0;

1024 if (found > start && found[-1] == '\r')

1025 found[-1] = 0;

1026

1027 *next = ff_alloc_dir_entry();

1028 if (!*next)

1029 return AVERROR(ENOMEM);

1030 (*next)->utf8 = s->utf8;

1031 ret = ftp_parse_entry(h, start, *next);

1032 if (ret) {

1033 avio_free_directory_entry(next);

1034 if (ret < 0)

1035 return ret;

1036 }

1037 } while (ret > 0);

1038 return 0;

1039 }

1040

1041 static int ftp_close_dir(URLContext *h)

1042 {

1043 FTPContext *s = h->priv_data;

1044 av_freep(&s->dir_buffer);

1045 ffurl_closep(&s->conn_control);

1046 ffurl_closep(&s->conn_data);

1047 return 0;

1048 }

1049

1050 static int ftp_delete(URLContext *h)

1051 {

1052 FTPContext *s = h->priv_data;

1053 char command[MAX_URL_SIZE];

1054 static const int del_codes[] = {250, 421, 450, 500, 501, 502, 530, 550, 0};

1055 static const int rmd_codes[] = {250, 421, 500, 501, 502, 530, 550, 0};

1056 int ret;

1057

1058 if ((ret = ftp_connect(h, h->filename)) < 0)

1059 goto cleanup;

1060

1061 snprintf(command, sizeof(command), "DELE %s\r\n", s->path);

1062 if (ftp_send_command(s, command, del_codes, NULL) == 250) {

1063 ret = 0;

1064 goto cleanup;

1065 }

1066

1067 snprintf(command, sizeof(command), "RMD %s\r\n", s->path);

1068 if (ftp_send_command(s, command, rmd_codes, NULL) == 250)

1069 ret = 0;

1070 else

1071 ret = AVERROR(EIO);

1072

1073 cleanup:

1074 ftp_close(h);

1075 return ret;

1076 }

1077

1078 static int ftp_move(URLContext *h_src, URLContext *h_dst)

1079 {

1080 FTPContext *s = h_src->priv_data;

1081 char command[MAX_URL_SIZE], path[MAX_URL_SIZE];

1082 static const int rnfr_codes[] = {350, 421, 450, 500, 501, 502, 503, 530, 0};

1083 static const int rnto_codes[] = {250, 421, 500, 501, 502, 503, 530, 532, 553, 0};

1084 int ret;

1085

1086 if ((ret = ftp_connect(h_src, h_src->filename)) < 0)

1087 goto cleanup;

1088

1089 snprintf(command, sizeof(command), "RNFR %s\r\n", s->path);

1090 if (ftp_send_command(s, command, rnfr_codes, NULL) != 350) {

1091 ret = AVERROR(EIO);

1092 goto cleanup;

1093 }

1094

1095 av_url_split(0, 0, 0, 0, 0, 0, 0,

1096 path, sizeof(path),

1097 h_dst->filename);

1098 snprintf(command, sizeof(command), "RNTO %s\r\n", path);

1099 if (ftp_send_command(s, command, rnto_codes, NULL) == 250)

1100 ret = 0;

1101 else

1102 ret = AVERROR(EIO);

1103

1104 cleanup:

1105 ftp_close(h_src);

1106 return ret;

1107 }

1108

1109 const URLProtocol ff_ftp_protocol = {

1110 .name = "ftp",

1111 .url_open = ftp_open,

1112 .url_read = ftp_read,

1113 .url_write = ftp_write,

1114 .url_seek = ftp_seek,

1115 .url_close = ftp_close,

1116 .url_get_file_handle = ftp_get_file_handle,

1117 .url_shutdown = ftp_shutdown,

1118 .priv_data_size = sizeof(FTPContext),

1119 .priv_data_class = &ftp_context_class,

1120 .url_open_dir = ftp_open_dir,

1121 .url_read_dir = ftp_read_dir,

1122 .url_close_dir = ftp_close_dir,

1123 .url_delete = ftp_delete,

1124 .url_move = ftp_move,

1125 .flags = URL_PROTOCOL_FLAG_NETWORK,

1126 .default_whitelist = "tcp",

1127 };

av_timegm

time_t av_timegm(struct tm *tm)

Convert the decomposed UTC time in tm to a time_t value.

Definition: parseutils.c:568

ff_ftp_protocol

const URLProtocol ff_ftp_protocol

Definition: ftp.c:1109

av_url_split

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:4700

NULL

#define NULL

Definition: coverity.c:32

const char * s

Definition: avisynth_c.h:768

av_bprintf

void av_bprintf(AVBPrint *buf, const char *fmt,...)

Definition: bprint.c:94

ffurl_open_whitelist

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:307

URL_PROTOCOL_FLAG_NETWORK

#define URL_PROTOCOL_FLAG_NETWORK

Definition: url.h:34

ftp_get_line

static int ftp_get_line(FTPContext *s, char *line, int line_size)

Definition: ftp.c:110

Definition: vp9dsp_template.c:2038

FTPContext::password

char * password

Server user's password.

Definition: ftp.c:58

AVOption

AVOption.

Definition: opt.h:246

AVIODirEntry::filemode

int64_t filemode

Unix file mode, -1 if unknown.

Definition: avio.h:100

AVIO_ENTRY_SYMBOLIC_LINK

Definition: avio.h:72

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:182

ftp_list

static int ftp_list(FTPContext *s)

Definition: ftp.c:494

ftp_move

static int ftp_move(URLContext *h_src, URLContext *h_dst)

Definition: ftp.c:1078

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

ftp_file_size

static int ftp_file_size(FTPContext *s)

Definition: ftp.c:385

ffurl_write

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

av_stristr

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

AV_OPT_TYPE_INT

Definition: opt.h:223

URLContext::is_streamed

int is_streamed

true if streamed (no seek possible), default = false

Definition: url.h:45

URLContext::interrupt_callback

AVIOInterruptCB interrupt_callback

Definition: url.h:47

AVIODirEntry

Describes single entry of the directory.

Definition: avio.h:86

AVIO_FLAG_READ

#define AVIO_FLAG_READ

read-only

Definition: avio.h:654

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:191

ftp_connect

static int ftp_connect(URLContext *h, const char *url)

Definition: ftp.c:654

AVIO_FLAG_WRITE

#define AVIO_FLAG_WRITE

write-only

Definition: avio.h:655

ftp_open

static int ftp_open(URLContext *h, const char *url, int flags)

Definition: ftp.c:706

FTPContext::control_buf_end

uint8_t * control_buf_end

Definition: ftp.c:53

FTPContext::dir_buffer_size

size_t dir_buffer_size

Definition: ftp.c:69

URLContext::flags

int flags

Definition: url.h:43

ftp_status

static int ftp_status(FTPContext *s, char **line, const int response_codes[])

Definition: ftp.c:138

FTPContext::write_seekable

int write_seekable

Control seekability, 0 = disable, 1 = enable.

Definition: ftp.c:64

avstring.h

ftp_retrieve

static int ftp_retrieve(FTPContext *s)

Definition: ftp.c:404

av_bprint_finalize

int av_bprint_finalize(AVBPrint *buf, char **ret_str)

Finalize a print buffer.

Definition: bprint.c:235

ffurl_shutdown

int ffurl_shutdown(URLContext *h, int flags)

Signal the URLContext that we are done reading or writing the stream.

Definition: avio.c:657

UNKNOWN

Definition: ftp.c:34

UPLOADING

Definition: ftp.c:37

MAX_URL_SIZE

#define MAX_URL_SIZE

Definition: internal.h:30

AVIODirEntry::modification_timestamp

int64_t modification_timestamp

Time of last modification in microseconds since unix epoch, -1 if unknown.

Definition: avio.h:92

AVClass::class_name

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

FTPContext::conn_control

URLContext * conn_control

Control connection.

Definition: ftp.c:50

ftp_read_dir

static int ftp_read_dir(URLContext *h, AVIODirEntry **next)

Definition: ftp.c:994

ftp_connect_data_connection

static int ftp_connect_data_connection(URLContext *h)

Definition: ftp.c:582

AVIO_ENTRY_FILE

Definition: avio.h:74

uint8_t

Definition: audio_convert.c:194

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:31

ftp_set_dir

static int ftp_set_dir(FTPContext *s)

Definition: ftp.c:459

ftp_shutdown

static int ftp_shutdown(URLContext *h, int flags)

Definition: ftp.c:890

opt.h

AVOptions.

FTPState

Definition: ftp.c:33

end

static av_cold int end(AVCodecContext *avctx)

Definition: avrndec.c:90

#define E

Definition: ftp.c:76

FTPContext::filesize

int64_t filesize

Size of file on server, -1 on error.

Definition: ftp.c:60

av_small_strptime

char * av_small_strptime(const char *p, const char *fmt, struct tm *dt)

Simplified version of strptime.

Definition: parseutils.c:489

ftp_delete

static int ftp_delete(URLContext *h)

Definition: ftp.c:1050

AV_OPT_TYPE_STRING

Definition: opt.h:227

DISCONNECTED

Definition: ftp.c:39

flags

static int flags

Definition: log.c:55

ftp_connect_control_connection

static int ftp_connect_control_connection(URLContext *h)

Definition: ftp.c:533

ff_dlog

#define ff_dlog(a,...)

Definition: tableprint_vlc.h:29

DIR_BUFFER_SIZE

#define DIR_BUFFER_SIZE

Definition: ftp.c:31

FTPContext::control_buffer

uint8_t control_buffer[CONTROL_BUFFER_SIZE]

Control connection buffer.

Definition: ftp.c:52

size

ptrdiff_t size

Definition: opengl_enc.c:101

ftp_current_dir

static int ftp_current_dir(FTPContext *s)

Definition: ftp.c:347

FTPListingMethod

Definition: ftp.c:42

FTPContext::control_buf_ptr

uint8_t * control_buf_ptr

Definition: ftp.c:53

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

ftp_passive_mode

static int ftp_passive_mode(FTPContext *s)

Definition: ftp.c:301

FTPContext::server_data_port

int server_data_port

Data connection port opened by server, -1 on error.

Definition: ftp.c:54

FTPContext::listing_method

FTPListingMethod listing_method

Called listing method.

Definition: ftp.c:66

UNKNOWN_METHOD

Definition: ftp.c:43

av_x_if_null

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

AVIODirEntry::name

char * name

Filename.

Definition: avio.h:87

AVDictionary

Definition: dict.c:30

ftp_getc

static int ftp_getc(FTPContext *s)

Definition: ftp.c:93

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

MLSD

Definition: ftp.c:45

FTPContext::anonymous_password

const char * anonymous_password

Password to be used for anonymous user.

Definition: ftp.c:63

URLContext::protocol_whitelist

const char * protocol_whitelist

Definition: url.h:49

AVERROR

#define AVERROR(e)

Definition: error.h:43

ftp_abort

static int ftp_abort(URLContext *h)

Definition: ftp.c:616

av_bprint_init

void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)

Definition: bprint.c:69

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:197

av_dict_free

void av_dict_free(AVDictionary **pm)

Free all the memory allocated for an AVDictionary struct and all keys and values. ...

Definition: dict.c:203

line

Definition: graph2dot.c:48

FTPContext::dir_buffer_offset

size_t dir_buffer_offset

Definition: ftp.c:70

internal.h

READY

Definition: ftp.c:35

ftp_send_command

static int ftp_send_command(FTPContext *s, const char *command, const int response_codes[], char **response)

Definition: ftp.c:199

ftp_close_both_connections

static void ftp_close_both_connections(FTPContext *s)

Definition: ftp.c:231

ftp_passive_mode_epsv

static int ftp_passive_mode_epsv(FTPContext *s)

Definition: ftp.c:259

FFMAX

#define FFMAX(a, b)

Definition: common.h:94

fail

#define fail()

Definition: checkasm.h:116

avio_free_directory_entry

void avio_free_directory_entry(AVIODirEntry **entry)

Free entry allocated by avio_read_dir().

Definition: avio.c:603

FTPContext::rw_timeout

int rw_timeout

Network timeout.

Definition: ftp.c:62

internal.h

common internal API header

ftp_parse_entry_nlst

static int ftp_parse_entry_nlst(char *line, AVIODirEntry *next)

Definition: ftp.c:937

opts

AVDictionary * opts

Definition: movenc.c:50

ftp_read

static int ftp_read(URLContext *h, unsigned char *buf, int size)

Definition: ftp.c:776

ftp_close

static int ftp_close(URLContext *h)

Definition: ftp.c:862

FTPContext::conn_data

URLContext * conn_data

Data connection, NULL when not connected.

Definition: ftp.c:51

AVIO_ENTRY_DIRECTORY

Definition: avio.h:70

FFMIN

#define FFMIN(a, b)

Definition: common.h:96

av_strcasecmp

int av_strcasecmp(const char *a, const char *b)

Locale-independent case-insensitive compare.

Definition: avstring.c:213

value

GLsizei GLboolean const GLfloat * value

Definition: opengl_enc.c:109

FTPContext::user

char * user

Server user.

Definition: ftp.c:57

ftp_auth

static int ftp_auth(FTPContext *s)

Definition: ftp.c:237

FTPContext::position

int64_t position

Current position, calculated.

Definition: ftp.c:61

ftp_restart

static int ftp_restart(FTPContext *s, int64_t pos)

Definition: ftp.c:447

AV_OPT_TYPE_BOOL

Definition: opt.h:240

FTPContext::features

char * features

List of server's features represented as raw response.

Definition: ftp.c:67

ftp_has_feature

static int ftp_has_feature(FTPContext *s, const char *feature_name)

Definition: ftp.c:505

LISTING_DIR

Definition: ftp.c:38

bprint.h

FTPContext::path

char * path

Path to resource on server.

Definition: ftp.c:59

ffurl_get_file_handle

int ffurl_get_file_handle(URLContext *h)

Return the file descriptor associated with this URL.

Definition: avio.c:626

AVIODirEntry::size

int64_t size

File size in bytes, -1 if unknown.

Definition: avio.h:91

ffurl_closep

int ffurl_closep(URLContext **hh)

Close the resource accessed by the URLContext h, and free the memory used by it.

Definition: avio.c:444

ff_url_join

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

ftp_seek

static int64_t ftp_seek(URLContext *h, int64_t pos, int whence)

Definition: ftp.c:733

AV_LOG_INFO

#define AV_LOG_INFO

Standard information.

Definition: log.h:187

AV_BPRINT_SIZE_AUTOMATIC

#define AV_BPRINT_SIZE_AUTOMATIC

av_strdup

char * av_strdup(const char *s)

Duplicate a string.

Definition: mem.c:251

URLContext::protocol_blacklist

const char * protocol_blacklist

Definition: url.h:50

ftp_close_dir

static int ftp_close_dir(URLContext *h)

Definition: ftp.c:1041

AVIODirEntry::type

int type

Type of the entry.

Definition: avio.h:88

ftp_get_file_handle

static int ftp_get_file_handle(URLContext *h)

Definition: ftp.c:878

URLProtocol

Definition: url.h:54

command

static int command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)

Definition: vf_drawtext.c:863

options

static const AVOption options[]

Definition: ftp.c:77

buf

void * buf

Definition: avisynth_c.h:690

URLContext

Definition: url.h:38

AVIO_FLAG_READ_WRITE

#define AVIO_FLAG_READ_WRITE

read-write pseudo flag

Definition: avio.h:656

FTPContext::state

FTPState state

State of data connection.

Definition: ftp.c:65

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:67

AVIODirEntry::group_id

int64_t group_id

Group ID of owner, -1 if unknown.

Definition: avio.h:99

ftp_close_data_connection

static void ftp_close_data_connection(FTPContext *s)

Definition: ftp.c:224

ftp_features

static int ftp_features(FTPContext *s)

Definition: ftp.c:513

URLContext::priv_data

void * priv_data

Definition: url.h:41

ftp_parse_entry_mlsd

static int ftp_parse_entry_mlsd(char *mlsd, AVIODirEntry *next)

Definition: ftp.c:943

snprintf

#define snprintf

Definition: snprintf.h:34

CONTROL_BUFFER_SIZE

#define CONTROL_BUFFER_SIZE

Definition: ftp.c:30

parseutils.h

misc parsing utilities

URLProtocol::name

const char * name

Definition: url.h:55

DOWNLOADING

Definition: ftp.c:36

av_strtok

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

NLST

Definition: ftp.c:44

avformat.h

Main libavformat public API header.

ftp_write

static int ftp_write(URLContext *h, const unsigned char *buf, int size)

Definition: ftp.c:833

av_append_path_component

char * av_append_path_component(const char *path, const char *component)

Append path component to the existing path.

Definition: avstring.c:295

FTPContext::utf8

int utf8

Definition: ftp.c:71

OFFSET

#define OFFSET(x)

Definition: ftp.c:74

av_dict_set_int

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

FTPContext::dir_buffer

char * dir_buffer

Definition: ftp.c:68

ff_alloc_dir_entry

AVIODirEntry * ff_alloc_dir_entry(void)

Allocate directory entry with default values.

Definition: url.c:149

URLContext::filename

char * filename

specified URL

Definition: url.h:42

AVSEEK_SIZE

#define AVSEEK_SIZE

ORing this as the "whence" parameter to a seek function causes it to return the filesize without seek...

Definition: avio.h:531

FTPContext::hostname

char * hostname

Server address.

Definition: ftp.c:56

ftp_store

static int ftp_store(FTPContext *s)

Definition: ftp.c:420

ftp_type

static int ftp_type(FTPContext *s)

Definition: ftp.c:436

#define D

Definition: ftp.c:75

av_free

#define av_free(p)

Definition: tableprint_vlc.h:34

ftp_open_dir

static int ftp_open_dir(URLContext *h)

Definition: ftp.c:902

len

int len

Definition: vorbis_enc_data.h:452

FTPContext::server_control_port

int server_control_port

Control connection port, default is 21.

Definition: ftp.c:55

AVIODirEntry::user_id

int64_t user_id

User ID of owner, -1 if unknown.

Definition: avio.h:98

ftp_list_mlsd

static int ftp_list_mlsd(FTPContext *s)

Definition: ftp.c:470

ftp_context_class

static const AVClass ftp_context_class

Definition: ftp.c:84

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

start

void INT64 start

Definition: avisynth_c.h:690

url.h

unbuffered private I/O API

ftp_parse_date

static int64_t ftp_parse_date(const char *date)

Definition: ftp.c:929

FTPContext

Definition: ftp.c:48

ftp_parse_entry

static int ftp_parse_entry(URLContext *h, char *line, AVIODirEntry *next)

Definition: ftp.c:979

ffurl_read

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

cleanup

static av_cold void cleanup(FlashSV2Context *s)

Definition: flashsv2enc.c:127

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_X86ASM &&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

ftp_list_nlst

static int ftp_list_nlst(FTPContext *s)

Definition: ftp.c:481

Generated on Sun May 13 2018 02:04:04 for FFmpeg by doxygen 1.8.6