git.mutantstargoat.com Git - oftp/blob - src/ftp.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <stdarg.h>
   5 #include <errno.h>
   6 #include <ctype.h>
   7 #include <time.h>
   8 #include <sys/socket.h>
   9 #include <sys/select.h>
  10 #include <sys/swap.h>
  11 #include <arpa/inet.h>
  12 #include <netinet/in.h>
  13 #include <netdb.h>
  14 #include "darray.h"
  15 #include "ftp.h"
  16 #include "util.h"
  17
  18 #ifdef __unix__
  19 #include <unistd.h>
  20 #include <fcntl.h>
  21 #define closesocket             close
  22 #define fcntlsocket             fcntl
  23 #else
  24 #define select  select_s
  25
  26 #ifndef O_NONBLOCK
  27 #define O_NONBLOCK      0x2000
  28 #endif
  29 #ifndef F_SETFL
  30 #define F_GETFL 101
  31 #define F_SETFL 102
  32 #endif
  33 #endif
  34
  35 #define TIMEOUT 15
  36
  37 static void free_dir(struct ftp_dirent *dir);
  38
  39 static int newconn(struct ftp *ftp);
  40 static int sendcmd(struct ftp *ftp, const char *fmt, ...);
  41 static int handle_control(struct ftp *ftp);
  42 static int handle_data(struct ftp *ftp, int s);
  43 static void proc_control(struct ftp *ftp, const char *buf);
  44
  45 static int cproc_active(struct ftp *ftp, int code, const char *buf, void *cls);
  46 static int cproc_pasv(struct ftp *ftp, int code, const char *buf, void *cls);
  47 static int cproc_pwd(struct ftp *ftp, int code, const char *buf, void *cls);
  48 static int cproc_cwd(struct ftp *ftp, int code, const char *buf, void *cls);
  49
  50 static int cproc_list(struct ftp *ftp, int code, const char *buf, void *cls);
  51 static void dproc_list(struct ftp *ftp, const char *buf, int sz, void *cls);
  52
  53 static int cproc_xfer(struct ftp *ftp, int code, const char *buf, void *cls);
  54 static void dproc_xfer(struct ftp *ftp, const char *buf, int sz, void *cls);
  55
  56
  57 struct ftp *ftp_alloc(void)
  58 {
  59         struct ftp *ftp;
  60
  61         if(!(ftp = calloc(1, sizeof *ftp))) {
  62                 return 0;
  63         }
  64         ftp->ctl = ftp->data = ftp->lis = -1;
  65         ftp->passive = 1;
  66
  67         ftp->dirent = darr_alloc(0, sizeof *ftp->dirent);
  68         return ftp;
  69 }
  70
  71 void ftp_free(struct ftp *ftp)
  72 {
  73         if(!ftp) return;
  74
  75         if(ftp->ctl >= 0) {
  76                 ftp_close(ftp);
  77         }
  78
  79         free_dir(ftp->dirent);
  80 }
  81
  82 static void free_dir(struct ftp_dirent *dir)
  83 {
  84         int i;
  85         for(i=0; i<darr_size(dir); i++) {
  86                 free(dir[i].name);
  87         }
  88         darr_free(dir);
  89 }
  90
  91 int ftp_connect(struct ftp *ftp, const char *hostname, int port)
  92 {
  93         struct hostent *host;
  94         struct sockaddr_in addr;
  95
  96         if((ftp->ctl = socket(PF_INET, SOCK_STREAM, 0)) == -1) {
  97                 errmsg("failed to create control socket\n");
  98                 return -1;
  99         }
 100
 101         if(!(host = gethostbyname(hostname))) {
 102                 errmsg("failed to resolve host: %s\n", hostname);
 103                 closesocket(ftp->ctl);
 104                 ftp->ctl = -1;
 105                 return -1;
 106         }
 107
 108         memset(&addr, 0, sizeof addr);
 109         addr.sin_family = AF_INET;
 110         addr.sin_addr = *((struct in_addr*)host->h_addr);
 111         addr.sin_port = htons(port);
 112
 113         if(connect(ftp->ctl, (struct sockaddr*)&addr, sizeof addr) == -1) {
 114                 errmsg("failed to connect to: %s (port: %d)\n", hostname, port);
 115                 closesocket(ftp->ctl);
 116                 ftp->ctl = -1;
 117                 return -1;
 118         }
 119
 120         fcntlsocket(ftp->ctl, F_SETFL, fcntlsocket(ftp->ctl, F_GETFL) | O_NONBLOCK);
 121         ftp->num_crecv = 0;
 122         return 0;
 123 }
 124
 125 void ftp_close(struct ftp *ftp)
 126 {
 127         if(ftp->ctl >= 0) {
 128                 closesocket(ftp->ctl);
 129                 ftp->ctl = -1;
 130                 ftp->num_crecv = 0;
 131         }
 132         if(ftp->lis >= 0) {
 133                 closesocket(ftp->lis);
 134                 ftp->lis = -1;
 135         }
 136         if(ftp->data >= 0) {
 137                 closesocket(ftp->data);
 138                 ftp->data = -1;
 139         }
 140 }
 141
 142 int ftp_sockets(struct ftp *ftp, int *sockv, int maxsize)
 143 {
 144         int *sptr = sockv;
 145         if(ftp->ctl >= 0 && maxsize-- > 0) {
 146                 *sptr++ = ftp->ctl;
 147         }
 148         if(ftp->lis >= 0 && maxsize-- > 0) {
 149                 *sptr++ = ftp->lis;
 150         }
 151         if(ftp->data >= 0 && maxsize-- > 0) {
 152                 *sptr++ = ftp->data;
 153         }
 154         return sptr - sockv;
 155 }
 156
 157 static void exec_op(struct ftp *ftp, struct ftp_op *fop)
 158 {
 159         switch(fop->op) {
 160         case FTP_TYPE:
 161                 ftp_type(ftp, fop->arg);
 162                 break;
 163
 164         case FTP_PWD:
 165                 ftp_pwd(ftp);
 166                 break;
 167
 168         case FTP_CHDIR:
 169                 ftp_chdir(ftp, fop->arg);
 170                 break;
 171
 172         case FTP_CDUP:
 173                 ftp_chdir(ftp, "..");
 174                 break;
 175
 176         case FTP_MKDIR:
 177                 ftp_mkdir(ftp, fop->arg);
 178                 break;
 179
 180         case FTP_RMDIR:
 181                 ftp_rmdir(ftp, fop->arg);
 182                 break;
 183
 184         case FTP_DEL:
 185                 ftp_delete(ftp, fop->arg);
 186                 break;
 187
 188         case FTP_LIST:
 189                 ftp_list(ftp);
 190                 break;
 191
 192         case FTP_RETR:
 193                 ftp_retrieve(ftp, fop->arg);
 194                 break;
 195
 196         case FTP_STORE:
 197                 ftp_store(ftp, fop->arg);
 198                 break;
 199
 200         case FTP_XFER:
 201                 ftp_transfer(ftp, fop->data);
 202                 break;
 203
 204         default:
 205                 break;
 206         }
 207 }
 208
 209 static void exec_queued(struct ftp *ftp)
 210 {
 211         struct ftp_op *fop;
 212
 213         if(!(fop = ftp->qhead)) {
 214                 return;
 215         }
 216
 217         if(ftp->qtail == fop) {
 218                 ftp->qhead = ftp->qtail = 0;
 219         } else {
 220                 ftp->qhead = ftp->qhead->next;
 221         }
 222
 223         exec_op(ftp, fop);
 224
 225         free(fop->arg);
 226         free(fop);
 227 }
 228
 229
 230 int ftp_queue(struct ftp *ftp, int op, const char *arg)
 231 {
 232         struct ftp_op *fop;
 233
 234         if(!ftp->busy && !ftp->qhead) {
 235                 struct ftp_op tmp = {0};
 236                 tmp.op = op;
 237                 tmp.arg = (char*)arg;
 238                 exec_op(ftp, &tmp);
 239                 return 0;
 240         }
 241
 242         if(!(fop = malloc(sizeof *fop))) {
 243                 return -1;
 244         }
 245         if(arg) {
 246                 if(!(fop->arg = strdup(arg))) {
 247                         free(fop);
 248                         return -1;
 249                 }
 250         } else {
 251                 fop->arg = 0;
 252         }
 253         fop->op = op;
 254         fop->next = 0;
 255
 256         if(ftp->qhead) {
 257                 ftp->qtail->next = fop;
 258                 ftp->qtail = fop;
 259         } else {
 260                 ftp->qhead = ftp->qtail = fop;
 261         }
 262         return 0;
 263 }
 264
 265 int ftp_queue_transfer(struct ftp *ftp, struct ftp_transfer *xfer)
 266 {
 267         struct ftp_op *fop;
 268
 269         if(!ftp->busy && !ftp->qhead) {
 270                 struct ftp_op tmp = {0};
 271                 tmp.op = FTP_XFER;
 272                 tmp.data = xfer;
 273                 exec_op(ftp, &tmp);
 274                 return 0;
 275         }
 276
 277         if(!(fop = malloc(sizeof *fop))) {
 278                 return -1;
 279         }
 280         fop->op = FTP_XFER;
 281         fop->arg = 0;
 282         fop->data = xfer;
 283         fop->next = 0;
 284
 285         if(ftp->qhead) {
 286                 ftp->qtail->next = fop;
 287                 ftp->qtail = fop;
 288         } else {
 289                 ftp->qhead = ftp->qtail = fop;
 290         }
 291         return 0;
 292 }
 293
 294 int ftp_waitresp(struct ftp *ftp, long timeout)
 295 {
 296         fd_set rdset;
 297         struct timeval tv;
 298         time_t start;
 299
 300         ftp->last_resp = -1;
 301         start = time(0);
 302
 303         for(;;) {
 304                 FD_ZERO(&rdset);
 305                 FD_SET(ftp->ctl, &rdset);
 306
 307                 if(timeout >= 0) {
 308                         tv.tv_sec = timeout;
 309                         tv.tv_usec = 0;
 310                 }
 311
 312                 if(select(ftp->ctl + 1, &rdset, 0, 0, timeout >= 0 ? &tv : 0) == -1 && errno == EINTR) {
 313                         continue;
 314                 }
 315
 316                 if(FD_ISSET(ftp->ctl, &rdset)) {
 317                         ftp->last_resp = -1;
 318                         ftp_handle(ftp, ftp->ctl);
 319                         if(ftp->last_resp) {
 320                                 break;
 321                         }
 322                 }
 323
 324                 if(timeout > 0) {
 325                         timeout -= time(0) - start;
 326                         if(timeout <= 0) {
 327                                 return -1;
 328                         }
 329                 }
 330
 331         }
 332         return ftp->last_resp;
 333 }
 334
 335 static int ftp_active(struct ftp *ftp)
 336 {
 337         struct sockaddr_in sa = {0};
 338         int len;
 339         unsigned long addr;
 340         unsigned short port;
 341
 342         if(ftp->lis >= 0) {
 343                 closesocket(ftp->lis);
 344         }
 345         if(ftp->data >= 0) {
 346                 closesocket(ftp->data);
 347                 ftp->data = -1;
 348         }
 349
 350         if((ftp->lis = socket(PF_INET, SOCK_STREAM, 0)) == -1) {
 351                 errmsg("ftp_active: failed to create listening socket\n");
 352                 return -1;
 353         }
 354
 355         len = sizeof sa;
 356         getsockname(ftp->ctl, (struct sockaddr*)&sa, &len);
 357
 358         sa.sin_family = AF_INET;
 359         sa.sin_port = 0;
 360
 361         if(bind(ftp->lis, (struct sockaddr*)&sa, sizeof sa) == -1) {
 362                 errmsg("ftp_active: failed to bind listening socket\n");
 363                 closesocket(ftp->lis);
 364                 ftp->lis = -1;
 365                 return -1;
 366         }
 367         listen(ftp->lis, 1);
 368
 369         len = sizeof sa;
 370         if(getsockname(ftp->lis, (struct sockaddr*)&sa, &len) == -1) {
 371                 errmsg("ftp_active: failed to retrieve listening socket address\n");
 372                 closesocket(ftp->lis);
 373                 ftp->lis = -1;
 374                 return -1;
 375         }
 376
 377         addr = ntohl(sa.sin_addr.s_addr);
 378         port = ntohs(sa.sin_port);
 379         infomsg("listening on %s port %d\n", inet_ntoa(sa.sin_addr), port);
 380
 381         sendcmd(ftp, "PORT %d,%d,%d,%d,%d,%d", addr >> 24, (addr >> 16) & 0xff,
 382                         (addr >> 8) & 0xff, addr & 0xff, port >> 8, port & 0xff);
 383
 384         ftp->cproc = cproc_active;
 385         return 0;
 386 }
 387
 388 static int ftp_passive(struct ftp *ftp)
 389 {
 390         if(ftp->lis >= 0) {
 391                 closesocket(ftp->lis);
 392                 ftp->lis = -1;
 393         }
 394         if(ftp->data >= 0) {
 395                 closesocket(ftp->data);
 396                 ftp->data = -1;
 397         }
 398
 399         sendcmd(ftp, "PASV");
 400         ftp->cproc = cproc_pasv;
 401         return 0;
 402 }
 403
 404 int ftp_handle(struct ftp *ftp, int s)
 405 {
 406         if(s == ftp->ctl) {
 407                 return handle_control(ftp);
 408         }
 409         if(s == ftp->data) {
 410                 return handle_data(ftp, s);
 411         }
 412         if(s == ftp->lis) {
 413                 int ns = accept(s, 0, 0);
 414                 if(ftp->data >= 0) {
 415                         closesocket(ns);
 416                 } else {
 417                         ftp->data = ns;
 418                 }
 419                 return 0;
 420         }
 421         return -1;
 422 }
 423
 424 static int sendcmd(struct ftp *ftp, const char *fmt, ...)
 425 {
 426         char buf[256];
 427         va_list ap;
 428
 429         if(ftp->ctl < 0) {
 430                 return -1;
 431         }
 432
 433         ftp->busy = 1;
 434
 435         va_start(ap, fmt);
 436         vsprintf(buf, fmt, ap);
 437         va_end(ap);
 438         infomsg("send: %s\n", buf);
 439         strcat(buf, "\r\n");
 440         return send(ftp->ctl, buf, strlen(buf), 0);
 441 }
 442
 443 static int handle_control(struct ftp *ftp)
 444 {
 445         int i, sz, rd;
 446         char *buf, *start, *end;
 447
 448         for(;;) {
 449                 if((sz = sizeof ftp->crecv - ftp->num_crecv) <= 0) {
 450                         /* discard buffer */
 451                         warnmsg("discard buffer\n");
 452                         sz = sizeof ftp->crecv;
 453                         ftp->num_crecv = 0;
 454                 }
 455                 start = ftp->crecv + ftp->num_crecv;
 456                 if((rd = recv(ftp->ctl, start, sz, 0)) == -1) {
 457                         if(errno == EINTR) continue;
 458                         /* assume EWOULDBLOCK, try again next time */
 459                         return 0;
 460                 }
 461                 if(rd == 0) {
 462                         ftp_close(ftp);
 463                         return -1;
 464                 }
 465
 466                 end = start + rd;
 467                 buf = ftp->crecv;
 468                 for(i=0; i<rd; i++) {
 469                         if(start[i] == '\r') {
 470                                 start[i] = 0;
 471                         } else if(start[i] == '\n') {
 472                                 start[i] = 0;
 473                                 proc_control(ftp, buf);
 474                                 buf = start + i + 1;
 475                         }
 476                 }
 477                 if(buf != ftp->crecv && buf < end) {
 478                         ftp->num_crecv = end - buf;
 479                         memmove(ftp->crecv, buf, ftp->num_crecv);
 480                 } else {
 481                         ftp->num_crecv = 0;
 482                 }
 483         }
 484         return 0;
 485 }
 486
 487 static int handle_data(struct ftp *ftp, int s)
 488 {
 489         int rd;
 490
 491         if(ftp->data == -1) {
 492                 return -1;
 493         }
 494
 495         for(;;) {
 496                 if((rd = recv(ftp->data, ftp->drecv, sizeof ftp->drecv, 0)) == -1) {
 497                         if(errno == EINTR) continue;
 498                         /* assume EWOULDBLOCK, try again next time */
 499                         break;
 500                 }
 501
 502                 /* call the callback first, so that we'll get a 0-count call to indicate
 503                  * EOF when the server closes the data connection
 504                  */
 505                 if(ftp->dproc) {
 506                         ftp->dproc(ftp, ftp->drecv, rd, ftp->dproc_cls);
 507                 }
 508
 509                 if(rd == 0) {
 510                         closesocket(ftp->data);
 511                         ftp->data = -1;
 512                         return -1;
 513                 }
 514         }
 515         return 0;
 516 }
 517
 518 static int respcode(const char *resp)
 519 {
 520         if(!isdigit(resp[0]) || !isdigit(resp[1]) || !isdigit(resp[2])) {
 521                 return 0;
 522         }
 523
 524         if(isspace(resp[3])) {
 525                 return atoi(resp);
 526         }
 527         if(resp[3] == '-') {
 528                 return -atoi(resp);
 529         }
 530         return 0;
 531 }
 532
 533 static void proc_control(struct ftp *ftp, const char *buf)
 534 {
 535         int code;
 536         char *end;
 537
 538         while(*buf && isspace(*buf)) buf++;
 539         if((end = strchr(buf, '\r'))) {
 540                 *end = 0;
 541         }
 542
 543         infomsg("recv: %s\n", buf);
 544
 545         if((code = respcode(buf)) == 0) {
 546                 warnmsg("ignoring invalid response: %s\n", buf);
 547                 return;
 548         }
 549         if(code < 0) {
 550                 return; /* ignore continuations for now */
 551         }
 552
 553         ftp->last_resp = code;
 554
 555         if(ftp->cproc) {
 556                 if(ftp->cproc(ftp, code, buf, ftp->cproc_cls) <= 0) {
 557                         ftp->cproc = 0;
 558                         ftp->busy = 0;
 559
 560                         /* execute next operation if there's one queued */
 561                         exec_queued(ftp);
 562                 }
 563                 return;
 564         }
 565         ftp->busy = 0;
 566
 567         switch(code) {
 568         case 220:
 569                 sendcmd(ftp, "user %s", ftp->user ? ftp->user : "anonymous");
 570                 break;
 571         case 331:
 572                 sendcmd(ftp, "pass %s", ftp->pass ? ftp->pass : "foobar");
 573                 break;
 574         case 230:
 575                 infomsg("login successful\n");
 576                 if(newconn(ftp) == -1) {
 577                         ftp_close(ftp);
 578                 }
 579                 break;
 580         case 530:
 581                 ftp->status = 0;
 582                 errmsg("login failed\n");
 583                 break;
 584
 585         default:
 586                 ftp->busy = 0;
 587
 588                 /* execute next operation if there's one queued */
 589                 exec_queued(ftp);
 590         }
 591 }
 592
 593 static int newconn(struct ftp *ftp)
 594 {
 595         ftp_queue(ftp, FTP_TYPE, "I");
 596         ftp_queue(ftp, FTP_PWD, 0);
 597         ftp_queue(ftp, FTP_LIST, 0);
 598         return 0;
 599 }
 600
 601 int ftp_update(struct ftp *ftp)
 602 {
 603         return -1;
 604 }
 605
 606 int ftp_type(struct ftp *ftp, const char *type)
 607 {
 608         int tc = toupper(type[0]);
 609         if(tc != 'I' && tc != 'A') {
 610                 return -1;
 611         }
 612         sendcmd(ftp, "type %c", tc);
 613         return 0;
 614 }
 615
 616 int ftp_pwd(struct ftp *ftp)
 617 {
 618         sendcmd(ftp, "pwd");
 619         ftp->cproc = cproc_pwd;
 620         return 0;
 621 }
 622
 623 int ftp_chdir(struct ftp *ftp, const char *dirname)
 624 {
 625         if(strcmp(dirname, "..") == 0) {
 626                 sendcmd(ftp, "cdup");
 627         } else {
 628                 sendcmd(ftp, "cwd %s", dirname);
 629         }
 630         ftp->cproc = cproc_cwd;
 631         return 0;
 632 }
 633
 634 int ftp_mkdir(struct ftp *ftp, const char *dirname)
 635 {
 636         return -1;
 637 }
 638
 639 int ftp_rmdir(struct ftp *ftp, const char *dirname)
 640 {
 641         return -1;
 642 }
 643
 644 int ftp_delete(struct ftp *ftp, const char *fname)
 645 {
 646         return -1;
 647 }
 648
 649 static int prepare_data(struct ftp *ftp)
 650 {
 651         if(ftp->data >= 0) {
 652                 return 0;
 653         }
 654
 655         if(ftp->passive) {
 656                 ftp_passive(ftp);
 657                 ftp_waitresp(ftp, TIMEOUT);
 658         } else {
 659                 if(ftp_active(ftp) == -1) {
 660                         return -1;
 661                 }
 662         }
 663         if(ftp->data == -1) {
 664                 return -1;
 665         }
 666         return 0;
 667 }
 668
 669 struct recvbuf {
 670         char *buf;
 671         long size, bufsz;
 672 };
 673
 674 int ftp_list(struct ftp *ftp)
 675 {
 676         struct recvbuf *rbuf;
 677
 678         if(prepare_data(ftp) == -1) {
 679                 return -1;
 680         }
 681
 682         if(!(rbuf = malloc(sizeof *rbuf))) {
 683                 errmsg("failed to allocate receive buffer\n");
 684                 return -1;
 685         }
 686         rbuf->size = 0;
 687         rbuf->bufsz = 1024;
 688         if(!(rbuf->buf = malloc(rbuf->bufsz))) {
 689                 free(rbuf);
 690                 errmsg("failed to allocate receive buffer\n");
 691                 return -1;
 692         }
 693
 694         sendcmd(ftp, "list");
 695         ftp->cproc = cproc_list;
 696         ftp->dproc = dproc_list;
 697         ftp->cproc_cls = ftp->dproc_cls = rbuf;
 698         return 0;
 699 }
 700
 701 int ftp_retrieve(struct ftp *ftp, const char *fname)
 702 {
 703         return -1;
 704 }
 705
 706 int ftp_store(struct ftp *ftp, const char *fname)
 707 {
 708         return -1;
 709 }
 710
 711 #define XFER_BUF_SIZE   1024
 712
 713 int ftp_transfer(struct ftp *ftp, struct ftp_transfer *xfer)
 714 {
 715         if(prepare_data(ftp) == -1) {
 716                 return -1;
 717         }
 718
 719         if(xfer->op == FTP_RETR) {
 720                 sendcmd(ftp, "retr %s", xfer->rname);
 721                 ftp->cproc = cproc_xfer;
 722                 ftp->dproc = dproc_xfer;
 723                 ftp->cproc_cls = ftp->dproc_cls = xfer;
 724         } else {
 725                 /* TODO */
 726         }
 727         return 0;
 728 }
 729
 730 static int get_quoted_text(const char *str, char *buf)
 731 {
 732         int len;
 733         const char *src, *end;
 734
 735         if(!(src = strchr(str, '"'))) {
 736                 return -1;
 737         }
 738         src++;
 739         end = src;
 740         while(*end && *end != '"') end++;
 741         if(!*end) return -1;
 742
 743         len = end - src;
 744         memcpy(buf, src, len);
 745         buf[len] = 0;
 746         return 0;
 747 }
 748
 749 static int cproc_active(struct ftp *ftp, int code, const char *buf, void *cls)
 750 {
 751         if(code != 200) {
 752                 errmsg("ftp_active failed\n");
 753                 ftp_close(ftp);
 754         } else {
 755                 ftp->status = FTP_CONN_ACT;
 756         }
 757         return 0;
 758 }
 759
 760 static int cproc_pasv(struct ftp *ftp, int code, const char *buf, void *cls)
 761 {
 762         const char *str;
 763         unsigned int addr[6];
 764         struct sockaddr_in sa;
 765         unsigned int ipaddr;
 766         int port;
 767
 768         if(code != 227) {
 769                 errmsg("ftp_passive failed\n");
 770                 goto nopasv;
 771         }
 772
 773         str = buf;
 774         while(*str) {
 775                 if(sscanf(str, "%u,%u,%u,%u,%u,%u", addr, addr + 1, addr + 2, addr + 3,
 776                                         addr + 4, addr + 5) == 6) {
 777                         break;
 778                 }
 779                 str++;
 780         }
 781         if(!*str || (addr[0] | addr[1] | addr[2] | addr[3] | addr[4] | addr[5]) >= 256) {
 782                 errmsg("ftp_passive: failed to parse response: %s\n", buf);
 783                 goto nopasv;
 784         }
 785         port = (addr[4] << 8) | addr[5];
 786         ipaddr = ((unsigned int)addr[0] << 24) | ((unsigned int)addr[1] << 16) |
 787                 ((unsigned int)addr[2] << 8) | addr[3];
 788
 789         if((ftp->data = socket(PF_INET, SOCK_STREAM, 0)) == -1) {
 790                 fprintf(stderr, "ftp_passive: failed to allocate socket\n");
 791                 goto nopasv;
 792         }
 793
 794         infomsg("passive mode: %d.%d.%d.%d port %d\n", addr[0], addr[1], addr[2], addr[3],
 795                         port);
 796
 797         sa.sin_family = AF_INET;
 798         sa.sin_addr.s_addr = htonl(ipaddr);
 799         sa.sin_port = htons(port);
 800
 801         if(connect(ftp->data, (struct sockaddr*)&sa, sizeof sa) == -1) {
 802                 errmsg("ftp_passive: failed to connect to %s:%p\n", inet_ntoa(sa.sin_addr), port);
 803                 closesocket(ftp->data);
 804                 ftp->data = -1;
 805                 goto nopasv;
 806         }
 807
 808         ftp->status = FTP_CONN_PASV;
 809         return 0;
 810
 811 nopasv:
 812         ftp->passive = 0;
 813         ftp_active(ftp);
 814         return 0;
 815 }
 816
 817 static int cproc_pwd(struct ftp *ftp, int code, const char *buf, void *cls)
 818 {
 819         char *dirname;
 820
 821         if(code != 257) {
 822                 warnmsg("pwd failed\n");
 823                 return -1;
 824         }
 825
 826         dirname = alloca(strlen(buf) + 1);
 827         if(get_quoted_text(buf, dirname) == -1) {
 828                 warnmsg("pwd: invalid response: %s\n", buf);
 829                 return -1;
 830         }
 831
 832         free(ftp->curdir);
 833         ftp->curdir = strdup_nf(dirname);
 834         ftp->modified = FTP_MOD_DIR;
 835         return 0;
 836 }
 837
 838 static int cproc_cwd(struct ftp *ftp, int code, const char *buf, void *cls)
 839 {
 840         if(code != 250) {
 841                 warnmsg("cwd failed\n");
 842                 return -1;
 843         }
 844
 845         ftp_queue(ftp, FTP_PWD, 0);
 846         ftp_queue(ftp, FTP_LIST, 0);
 847         return 0;
 848 }
 849
 850 static int cproc_list(struct ftp *ftp, int code, const char *buf, void *cls)
 851 {
 852         if(code < 200) {
 853                 /* expect more */
 854                 return 1;
 855         }
 856
 857         if(code >= 400) {
 858                 errmsg("failed to retrieve directory listing\n");
 859         }
 860         return 0;
 861 }
 862
 863 #define SKIP_FIELD(p) \
 864         do { \
 865                 while(*(p) && *(p) != '\n' && !isspace(*(p))) (p)++; \
 866                 while(*(p) && *(p) != '\n' && isspace(*(p))) (p)++; \
 867         } while(0)
 868
 869 static int parse_dirent(struct ftp_dirent *ent, const char *line)
 870 {
 871         int len;
 872         const char *ptr = line;
 873         const char *end;
 874
 875         if(!(end = strchr(line, '\r')) && !(end = strchr(line, '\n'))) {
 876                 return -1;
 877         }
 878
 879         if(line[0] == 'd') {
 880                 ent->type = FTP_DIR;
 881         } else {
 882                 ent->type = FTP_FILE;
 883         }
 884
 885         SKIP_FIELD(ptr);                /* skip mode */
 886         SKIP_FIELD(ptr);                /* skip links */
 887         SKIP_FIELD(ptr);                /* skip owner */
 888         SKIP_FIELD(ptr);                /* skip group */
 889
 890         if(ent->type == FTP_FILE) {
 891                 ent->size = atoi(ptr);
 892         }
 893         SKIP_FIELD(ptr);                /* skip size */
 894         SKIP_FIELD(ptr);                /* skip month */
 895         SKIP_FIELD(ptr);                /* skip day */
 896         SKIP_FIELD(ptr);                /* skip year */
 897
 898         if(ptr >= end) return -1;
 899
 900         len = end - ptr;
 901         ent->name = malloc(len + 1);
 902         memcpy(ent->name, ptr, len);
 903         ent->name[len] = 0;
 904
 905         return 0;
 906 }
 907
 908 int ftp_direntcmp(const void *a, const void *b)
 909 {
 910         const struct ftp_dirent *da = a, *db = b;
 911
 912         if(da->type == db->type) {
 913                 return strcmp(da->name, db->name);
 914         }
 915         return da->type == FTP_DIR ? -1 : 1;
 916 }
 917
 918 static void dproc_list(struct ftp *ftp, const char *buf, int sz, void *cls)
 919 {
 920         int num;
 921         struct recvbuf *rbuf = cls;
 922
 923         if(sz == 0) {
 924                 /* EOF condition, we got the whole list, update directory entries */
 925                 char *ptr = rbuf->buf;
 926                 char *end = rbuf->buf + rbuf->size;
 927                 struct ftp_dirent ent;
 928
 929                 darr_clear(ftp->dirent);
 930
 931                 while(ptr < end) {
 932                         if(parse_dirent(&ent, ptr) != -1) {
 933                                 darr_push(ftp->dirent, &ent);
 934                         }
 935                         while(ptr < end && *ptr != '\n' && *ptr != '\r') ptr++;
 936                         while(ptr < end && (*ptr == '\r' || *ptr == '\n')) ptr++;
 937                 }
 938                 ftp->modified |= FTP_MOD_DIR;
 939
 940                 free(rbuf->buf);
 941                 free(rbuf);
 942                 ftp->dproc = 0;
 943
 944                 num = darr_size(ftp->dirent);
 945                 qsort(ftp->dirent, num, sizeof *ftp->dirent, ftp_direntcmp);
 946                 return;
 947         }
 948
 949         if(rbuf->size + sz > rbuf->bufsz) {
 950                 char *tmp;
 951                 int newsz = rbuf->bufsz << 1;
 952
 953                 if(!(tmp = realloc(rbuf->buf, newsz))) {
 954                         errmsg("failed to resize receive buffer\n");
 955                         return;
 956                 }
 957                 rbuf->buf = tmp;
 958                 rbuf->bufsz = newsz;
 959         }
 960
 961         memcpy(rbuf->buf + rbuf->size, buf, sz);
 962         rbuf->size += sz;
 963 }
 964
 965 static int cproc_xfer(struct ftp *ftp, int code, const char *buf, void *cls)
 966 {
 967         char *ptr;
 968         struct ftp_transfer *xfer = cls;
 969
 970         if(code < 200) {
 971                 /* expect more */
 972                 if(code == 150 && (ptr = strchr(buf, '('))) {
 973                         /* update total size */
 974                         sscanf(ptr, "(%ld bytes)", &xfer->total);
 975                 }
 976                 return 1;
 977         }
 978
 979         if(code >= 400) {
 980                 errmsg("failed to retrieve file\n");
 981         }
 982         return 0;
 983 }
 984
 985 static void dproc_xfer(struct ftp *ftp, const char *buf, int sz, void *cls)
 986 {
 987         struct ftp_transfer *xfer = cls;
 988
 989         if(xfer->op == FTP_RETR) {
 990                 if(sz == 0) {
 991                         /* EOF condition, got the whole file */
 992                         if(xfer->fp) {
 993                                 fclose(xfer->fp);
 994                                 xfer->fp = 0;
 995                         }
 996
 997                         if(xfer->done) {
 998                                 xfer->done(ftp, xfer);
 999                         }
1000                         return;
1001                 }
1002
1003                 if(xfer->fp) {
1004                         ((char*)buf)[sz] = 0;
1005                         fwrite(buf, 1, sz, xfer->fp);
1006
1007                 } else if(xfer->mem) {
1008                         int prevsz = darr_size(xfer->mem);
1009                         darr_resize(xfer->mem, prevsz + sz);
1010                         memcpy(xfer->mem + prevsz, buf, sz);
1011                 }
1012
1013                 xfer->count += sz;
1014                 if(xfer->count > xfer->total) {
1015                         xfer->count = xfer->total;
1016                 }
1017
1018         } else { /* FTP_STOR */
1019                 /* TODO */
1020         }
1021 }
1022
1023 const char *ftp_curdir(struct ftp *ftp)
1024 {
1025         return ftp->curdir;
1026 }
1027
1028 int ftp_num_dirent(struct ftp *ftp)
1029 {
1030         return darr_size(ftp->dirent);
1031 }
1032
1033 struct ftp_dirent *ftp_dirent(struct ftp *ftp, int idx)
1034 {
1035         return ftp->dirent + idx;
1036 }