1 /* $NetBSD: util.c,v 1.21 2009/11/15 10:12:37 lukem Exp $ */ 2 /* from NetBSD: util.c,v 1.152 2009/07/13 19:05:41 roy Exp */ 3 4 /*- 5 * Copyright (c) 1997-2009 The NetBSD Foundation, Inc. 6 * All rights reserved. 7 * 8 * This code is derived from software contributed to The NetBSD Foundation 9 * by Luke Mewburn. 10 * 11 * This code is derived from software contributed to The NetBSD Foundation 12 * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility, 13 * NASA Ames Research Center. 14 * 15 * Redistribution and use in source and binary forms, with or without 16 * modification, are permitted provided that the following conditions 17 * are met: 18 * 1. Redistributions of source code must retain the above copyright 19 * notice, this list of conditions and the following disclaimer. 20 * 2. Redistributions in binary form must reproduce the above copyright 21 * notice, this list of conditions and the following disclaimer in the 22 * documentation and/or other materials provided with the distribution. 23 * 24 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 25 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 26 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 27 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 28 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 29 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 30 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 31 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 32 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 33 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 34 * POSSIBILITY OF SUCH DAMAGE. 35 */ 36 37 /* 38 * Copyright (c) 1985, 1989, 1993, 1994 39 * The Regents of the University of California. All rights reserved. 40 * 41 * Redistribution and use in source and binary forms, with or without 42 * modification, are permitted provided that the following conditions 43 * are met: 44 * 1. Redistributions of source code must retain the above copyright 45 * notice, this list of conditions and the following disclaimer. 46 * 2. Redistributions in binary form must reproduce the above copyright 47 * notice, this list of conditions and the following disclaimer in the 48 * documentation and/or other materials provided with the distribution. 49 * 3. Neither the name of the University nor the names of its contributors 50 * may be used to endorse or promote products derived from this software 51 * without specific prior written permission. 52 * 53 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 54 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 55 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 56 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 57 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 58 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 59 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 60 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 61 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 62 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 63 * SUCH DAMAGE. 64 */ 65 66 #include "tnftp.h" 67 68 #if 0 /* tnftp */ 69 70 #include <sys/cdefs.h> 71 #ifndef lint 72 __RCSID(" NetBSD: util.c,v 1.152 2009/07/13 19:05:41 roy Exp "); 73 #endif /* not lint */ 74 75 /* 76 * FTP User Program -- Misc support routines 77 */ 78 #include <sys/param.h> 79 #include <sys/socket.h> 80 #include <sys/ioctl.h> 81 #include <sys/time.h> 82 #include <netinet/in.h> 83 #include <arpa/ftp.h> 84 85 #include <ctype.h> 86 #include <err.h> 87 #include <errno.h> 88 #include <fcntl.h> 89 #include <glob.h> 90 #include <signal.h> 91 #include <libgen.h> 92 #include <limits.h> 93 #include <netdb.h> 94 #include <stdio.h> 95 #include <stdlib.h> 96 #include <string.h> 97 #include <termios.h> 98 #include <time.h> 99 #include <tzfile.h> 100 #include <unistd.h> 101 102 #endif /* tnftp */ 103 104 #include "ftp_var.h" 105 106 /* 107 * Connect to peer server and auto-login, if possible. 108 */ 109 void 110 setpeer(int argc, char *argv[]) 111 { 112 char *host; 113 const char *port; 114 115 if (argc == 0) 116 goto usage; 117 if (connected) { 118 fprintf(ttyout, "Already connected to %s, use close first.\n", 119 hostname); 120 code = -1; 121 return; 122 } 123 if (argc < 2) 124 (void)another(&argc, &argv, "to"); 125 if (argc < 2 || argc > 3) { 126 usage: 127 UPRINTF("usage: %s host-name [port]\n", argv[0]); 128 code = -1; 129 return; 130 } 131 if (gatemode) 132 port = gateport; 133 else 134 port = ftpport; 135 if (argc > 2) 136 port = argv[2]; 137 138 if (gatemode) { 139 if (gateserver == NULL || *gateserver == '\0') 140 errx(1, "main: gateserver not defined"); 141 host = hookup(gateserver, port); 142 } else 143 host = hookup(argv[1], port); 144 145 if (host) { 146 if (gatemode && verbose) { 147 fprintf(ttyout, 148 "Connecting via pass-through server %s\n", 149 gateserver); 150 } 151 152 connected = 1; 153 /* 154 * Set up defaults for FTP. 155 */ 156 (void)strlcpy(typename, "ascii", sizeof(typename)); 157 type = TYPE_A; 158 curtype = TYPE_A; 159 (void)strlcpy(formname, "non-print", sizeof(formname)); 160 form = FORM_N; 161 (void)strlcpy(modename, "stream", sizeof(modename)); 162 mode = MODE_S; 163 (void)strlcpy(structname, "file", sizeof(structname)); 164 stru = STRU_F; 165 (void)strlcpy(bytename, "8", sizeof(bytename)); 166 bytesize = 8; 167 if (autologin) 168 (void)ftp_login(argv[1], NULL, NULL); 169 } 170 } 171 172 static void 173 parse_feat(const char *fline) 174 { 175 176 /* 177 * work-around broken ProFTPd servers that can't 178 * even obey RFC2389. 179 */ 180 while (*fline && isspace((int)*fline)) 181 fline++; 182 183 if (strcasecmp(fline, "MDTM") == 0) 184 features[FEAT_MDTM] = 1; 185 else if (strncasecmp(fline, "MLST", sizeof("MLST") - 1) == 0) { 186 features[FEAT_MLST] = 1; 187 } else if (strcasecmp(fline, "REST STREAM") == 0) 188 features[FEAT_REST_STREAM] = 1; 189 else if (strcasecmp(fline, "SIZE") == 0) 190 features[FEAT_SIZE] = 1; 191 else if (strcasecmp(fline, "TVFS") == 0) 192 features[FEAT_TVFS] = 1; 193 } 194 195 /* 196 * Determine the remote system type (SYST) and features (FEAT). 197 * Call after a successful login (i.e, connected = -1) 198 */ 199 void 200 getremoteinfo(void) 201 { 202 int overbose, i; 203 204 overbose = verbose; 205 if (ftp_debug == 0) 206 verbose = -1; 207 208 /* determine remote system type */ 209 if (command("SYST") == COMPLETE) { 210 if (overbose) { 211 char *cp, c; 212 213 c = 0; 214 cp = strchr(reply_string + 4, ' '); 215 if (cp == NULL) 216 cp = strchr(reply_string + 4, '\r'); 217 if (cp) { 218 if (cp[-1] == '.') 219 cp--; 220 c = *cp; 221 *cp = '\0'; 222 } 223 224 fprintf(ttyout, "Remote system type is %s.\n", 225 reply_string + 4); 226 if (cp) 227 *cp = c; 228 } 229 if (!strncmp(reply_string, "215 UNIX Type: L8", 17)) { 230 if (proxy) 231 unix_proxy = 1; 232 else 233 unix_server = 1; 234 /* 235 * Set type to 0 (not specified by user), 236 * meaning binary by default, but don't bother 237 * telling server. We can use binary 238 * for text files unless changed by the user. 239 */ 240 type = 0; 241 (void)strlcpy(typename, "binary", sizeof(typename)); 242 if (overbose) 243 fprintf(ttyout, 244 "Using %s mode to transfer files.\n", 245 typename); 246 } else { 247 if (proxy) 248 unix_proxy = 0; 249 else 250 unix_server = 0; 251 if (overbose && 252 !strncmp(reply_string, "215 TOPS20", 10)) 253 fputs( 254 "Remember to set tenex mode when transferring binary files from this machine.\n", 255 ttyout); 256 } 257 } 258 259 /* determine features (if any) */ 260 for (i = 0; i < FEAT_max; i++) 261 features[i] = -1; 262 reply_callback = parse_feat; 263 if (command("FEAT") == COMPLETE) { 264 for (i = 0; i < FEAT_max; i++) { 265 if (features[i] == -1) 266 features[i] = 0; 267 } 268 features[FEAT_FEAT] = 1; 269 } else 270 features[FEAT_FEAT] = 0; 271 #ifndef NO_DEBUG 272 if (ftp_debug) { 273 #define DEBUG_FEAT(x) fprintf(ttyout, "features[" #x "] = %d\n", features[(x)]) 274 DEBUG_FEAT(FEAT_FEAT); 275 DEBUG_FEAT(FEAT_MDTM); 276 DEBUG_FEAT(FEAT_MLST); 277 DEBUG_FEAT(FEAT_REST_STREAM); 278 DEBUG_FEAT(FEAT_SIZE); 279 DEBUG_FEAT(FEAT_TVFS); 280 #undef DEBUG_FEAT 281 } 282 #endif 283 reply_callback = NULL; 284 285 verbose = overbose; 286 } 287 288 /* 289 * Reset the various variables that indicate connection state back to 290 * disconnected settings. 291 * The caller is responsible for issuing any commands to the remote server 292 * to perform a clean shutdown before this is invoked. 293 */ 294 void 295 cleanuppeer(void) 296 { 297 298 if (cout) 299 (void)fclose(cout); 300 cout = NULL; 301 connected = 0; 302 unix_server = 0; 303 unix_proxy = 0; 304 /* 305 * determine if anonftp was specifically set with -a 306 * (1), or implicitly set by auto_fetch() (2). in the 307 * latter case, disable after the current xfer 308 */ 309 if (anonftp == 2) 310 anonftp = 0; 311 data = -1; 312 epsv4bad = 0; 313 epsv6bad = 0; 314 if (username) 315 free(username); 316 username = NULL; 317 if (!proxy) 318 macnum = 0; 319 } 320 321 /* 322 * Top-level signal handler for interrupted commands. 323 */ 324 void 325 intr(int signo) 326 { 327 328 sigint_raised = 1; 329 alarmtimer(0); 330 if (fromatty) 331 write(fileno(ttyout), "\n", 1); 332 siglongjmp(toplevel, 1); 333 } 334 335 /* 336 * Signal handler for lost connections; cleanup various elements of 337 * the connection state, and call cleanuppeer() to finish it off. 338 */ 339 void 340 lostpeer(int dummy) 341 { 342 int oerrno = errno; 343 344 alarmtimer(0); 345 if (connected) { 346 if (cout != NULL) { 347 (void)shutdown(fileno(cout), 1+1); 348 (void)fclose(cout); 349 cout = NULL; 350 } 351 if (data >= 0) { 352 (void)shutdown(data, 1+1); 353 (void)close(data); 354 data = -1; 355 } 356 connected = 0; 357 } 358 pswitch(1); 359 if (connected) { 360 if (cout != NULL) { 361 (void)shutdown(fileno(cout), 1+1); 362 (void)fclose(cout); 363 cout = NULL; 364 } 365 connected = 0; 366 } 367 proxflag = 0; 368 pswitch(0); 369 cleanuppeer(); 370 errno = oerrno; 371 } 372 373 374 /* 375 * Login to remote host, using given username & password if supplied. 376 * Return non-zero if successful. 377 */ 378 int 379 ftp_login(const char *host, const char *luser, const char *lpass) 380 { 381 char tmp[80]; 382 char *fuser, *pass, *facct, *p; 383 char emptypass[] = ""; 384 const char *errormsg; 385 int n, aflag, rval, nlen; 386 387 aflag = rval = 0; 388 fuser = pass = facct = NULL; 389 if (luser) 390 fuser = ftp_strdup(luser); 391 if (lpass) 392 pass = ftp_strdup(lpass); 393 394 DPRINTF("ftp_login: user `%s' pass `%s' host `%s'\n", 395 STRorNULL(fuser), STRorNULL(pass), STRorNULL(host)); 396 397 /* 398 * Set up arguments for an anonymous FTP session, if necessary. 399 */ 400 if (anonftp) { 401 FREEPTR(fuser); 402 fuser = ftp_strdup("anonymous"); /* as per RFC1635 */ 403 FREEPTR(pass); 404 pass = ftp_strdup(getoptionvalue("anonpass")); 405 } 406 407 if (ruserpass(host, &fuser, &pass, &facct) < 0) { 408 code = -1; 409 goto cleanup_ftp_login; 410 } 411 412 while (fuser == NULL) { 413 if (localname) 414 fprintf(ttyout, "Name (%s:%s): ", host, localname); 415 else 416 fprintf(ttyout, "Name (%s): ", host); 417 errormsg = NULL; 418 nlen = get_line(stdin, tmp, sizeof(tmp), &errormsg); 419 if (nlen < 0) { 420 fprintf(ttyout, "%s; %s aborted.\n", errormsg, "login"); 421 code = -1; 422 goto cleanup_ftp_login; 423 } else if (nlen == 0) { 424 fuser = ftp_strdup(localname); 425 } else { 426 fuser = ftp_strdup(tmp); 427 } 428 } 429 430 if (gatemode) { 431 char *nuser; 432 size_t len; 433 434 len = strlen(fuser) + 1 + strlen(host) + 1; 435 nuser = ftp_malloc(len); 436 (void)strlcpy(nuser, fuser, len); 437 (void)strlcat(nuser, "@", len); 438 (void)strlcat(nuser, host, len); 439 FREEPTR(fuser); 440 fuser = nuser; 441 } 442 443 n = command("USER %s", fuser); 444 if (n == CONTINUE) { 445 if (pass == NULL) { 446 p = getpass("Password: "); 447 if (p == NULL) 448 p = emptypass; 449 pass = ftp_strdup(p); 450 memset(p, 0, strlen(p)); 451 } 452 n = command("PASS %s", pass); 453 memset(pass, 0, strlen(pass)); 454 } 455 if (n == CONTINUE) { 456 aflag++; 457 if (facct == NULL) { 458 p = getpass("Account: "); 459 if (p == NULL) 460 p = emptypass; 461 facct = ftp_strdup(p); 462 memset(p, 0, strlen(p)); 463 } 464 if (facct[0] == '\0') { 465 warnx("Login failed"); 466 goto cleanup_ftp_login; 467 } 468 n = command("ACCT %s", facct); 469 memset(facct, 0, strlen(facct)); 470 } 471 if ((n != COMPLETE) || 472 (!aflag && facct != NULL && command("ACCT %s", facct) != COMPLETE)) { 473 warnx("Login failed"); 474 goto cleanup_ftp_login; 475 } 476 rval = 1; 477 username = ftp_strdup(fuser); 478 if (proxy) 479 goto cleanup_ftp_login; 480 481 connected = -1; 482 getremoteinfo(); 483 for (n = 0; n < macnum; ++n) { 484 if (!strcmp("init", macros[n].mac_name)) { 485 (void)strlcpy(line, "$init", sizeof(line)); 486 makeargv(); 487 domacro(margc, margv); 488 break; 489 } 490 } 491 updatelocalcwd(); 492 updateremotecwd(); 493 494 cleanup_ftp_login: 495 FREEPTR(fuser); 496 if (pass != NULL) 497 memset(pass, 0, strlen(pass)); 498 FREEPTR(pass); 499 if (facct != NULL) 500 memset(facct, 0, strlen(facct)); 501 FREEPTR(facct); 502 return (rval); 503 } 504 505 /* 506 * `another' gets another argument, and stores the new argc and argv. 507 * It reverts to the top level (via intr()) on EOF/error. 508 * 509 * Returns false if no new arguments have been added. 510 */ 511 int 512 another(int *pargc, char ***pargv, const char *aprompt) 513 { 514 const char *errormsg; 515 int ret, nlen; 516 size_t len; 517 518 len = strlen(line); 519 if (len >= sizeof(line) - 3) { 520 fputs("Sorry, arguments too long.\n", ttyout); 521 intr(0); 522 } 523 fprintf(ttyout, "(%s) ", aprompt); 524 line[len++] = ' '; 525 errormsg = NULL; 526 nlen = get_line(stdin, line + len, sizeof(line)-len, &errormsg); 527 if (nlen < 0) { 528 fprintf(ttyout, "%s; %s aborted.\n", errormsg, "operation"); 529 intr(0); 530 } 531 len += nlen; 532 makeargv(); 533 ret = margc > *pargc; 534 *pargc = margc; 535 *pargv = margv; 536 return (ret); 537 } 538 539 /* 540 * glob files given in argv[] from the remote server. 541 * if errbuf isn't NULL, store error messages there instead 542 * of writing to the screen. 543 */ 544 char * 545 remglob(char *argv[], int doswitch, const char **errbuf) 546 { 547 static char buf[MAXPATHLEN]; 548 static FILE *ftemp = NULL; 549 static char **args; 550 char temp[MAXPATHLEN]; 551 int oldverbose, oldhash, oldprogress, fd; 552 char *cp; 553 const char *rmode; 554 size_t len; 555 556 if (!mflag || !connected) { 557 if (!doglob) 558 args = NULL; 559 else { 560 if (ftemp) { 561 (void)fclose(ftemp); 562 ftemp = NULL; 563 } 564 } 565 return (NULL); 566 } 567 if (!doglob) { 568 if (args == NULL) 569 args = argv; 570 if ((cp = *++args) == NULL) 571 args = NULL; 572 return (cp); 573 } 574 if (ftemp == NULL) { 575 len = strlcpy(temp, tmpdir, sizeof(temp)); 576 if (temp[len - 1] != '/') 577 (void)strlcat(temp, "/", sizeof(temp)); 578 (void)strlcat(temp, TMPFILE, sizeof(temp)); 579 if ((fd = mkstemp(temp)) < 0) { 580 warn("Unable to create temporary file `%s'", temp); 581 return (NULL); 582 } 583 close(fd); 584 oldverbose = verbose; 585 verbose = (errbuf != NULL) ? -1 : 0; 586 oldhash = hash; 587 oldprogress = progress; 588 hash = 0; 589 progress = 0; 590 if (doswitch) 591 pswitch(!proxy); 592 for (rmode = "w"; *++argv != NULL; rmode = "a") 593 recvrequest("NLST", temp, *argv, rmode, 0, 0); 594 if ((code / 100) != COMPLETE) { 595 if (errbuf != NULL) 596 *errbuf = reply_string; 597 } 598 if (doswitch) 599 pswitch(!proxy); 600 verbose = oldverbose; 601 hash = oldhash; 602 progress = oldprogress; 603 ftemp = fopen(temp, "r"); 604 (void)unlink(temp); 605 if (ftemp == NULL) { 606 if (errbuf == NULL) 607 warnx("Can't find list of remote files"); 608 else 609 *errbuf = 610 "Can't find list of remote files"; 611 return (NULL); 612 } 613 } 614 if (fgets(buf, sizeof(buf), ftemp) == NULL) { 615 (void)fclose(ftemp); 616 ftemp = NULL; 617 return (NULL); 618 } 619 if ((cp = strchr(buf, '\n')) != NULL) 620 *cp = '\0'; 621 return (buf); 622 } 623 624 /* 625 * Glob a local file name specification with the expectation of a single 626 * return value. Can't control multiple values being expanded from the 627 * expression, we return only the first. 628 * Returns NULL on error, or a pointer to a buffer containing the filename 629 * that's the caller's responsiblity to free(3) when finished with. 630 */ 631 char * 632 globulize(const char *pattern) 633 { 634 glob_t gl; 635 int flags; 636 char *p; 637 638 if (!doglob) 639 return (ftp_strdup(pattern)); 640 641 flags = GLOB_BRACE|GLOB_NOCHECK|GLOB_TILDE; 642 memset(&gl, 0, sizeof(gl)); 643 if (glob(pattern, flags, NULL, &gl) || gl.gl_pathc == 0) { 644 warnx("Glob pattern `%s' not found", pattern); 645 globfree(&gl); 646 return (NULL); 647 } 648 p = ftp_strdup(gl.gl_pathv[0]); 649 globfree(&gl); 650 return (p); 651 } 652 653 /* 654 * determine size of remote file 655 */ 656 off_t 657 remotesize(const char *file, int noisy) 658 { 659 int overbose, r; 660 off_t size; 661 662 overbose = verbose; 663 size = -1; 664 if (ftp_debug == 0) 665 verbose = -1; 666 if (! features[FEAT_SIZE]) { 667 if (noisy) 668 fprintf(ttyout, 669 "SIZE is not supported by remote server.\n"); 670 goto cleanup_remotesize; 671 } 672 r = command("SIZE %s", file); 673 if (r == COMPLETE) { 674 char *cp, *ep; 675 676 cp = strchr(reply_string, ' '); 677 if (cp != NULL) { 678 cp++; 679 size = STRTOLL(cp, &ep, 10); 680 if (*ep != '\0' && !isspace((unsigned char)*ep)) 681 size = -1; 682 } 683 } else { 684 if (r == ERROR && code == 500 && features[FEAT_SIZE] == -1) 685 features[FEAT_SIZE] = 0; 686 if (noisy && ftp_debug == 0) { 687 fputs(reply_string, ttyout); 688 putc('\n', ttyout); 689 } 690 } 691 cleanup_remotesize: 692 verbose = overbose; 693 return (size); 694 } 695 696 /* 697 * determine last modification time (in GMT) of remote file 698 */ 699 time_t 700 remotemodtime(const char *file, int noisy) 701 { 702 int overbose, ocode, r; 703 time_t rtime; 704 705 overbose = verbose; 706 ocode = code; 707 rtime = -1; 708 if (ftp_debug == 0) 709 verbose = -1; 710 if (! features[FEAT_MDTM]) { 711 if (noisy) 712 fprintf(ttyout, 713 "MDTM is not supported by remote server.\n"); 714 goto cleanup_parse_time; 715 } 716 r = command("MDTM %s", file); 717 if (r == COMPLETE) { 718 struct tm timebuf; 719 char *timestr, *frac; 720 721 /* 722 * time-val = 14DIGIT [ "." 1*DIGIT ] 723 * YYYYMMDDHHMMSS[.sss] 724 * mdtm-response = "213" SP time-val CRLF / error-response 725 */ 726 timestr = reply_string + 4; 727 728 /* 729 * parse fraction. 730 * XXX: ignored for now 731 */ 732 frac = strchr(timestr, '\r'); 733 if (frac != NULL) 734 *frac = '\0'; 735 frac = strchr(timestr, '.'); 736 if (frac != NULL) 737 *frac++ = '\0'; 738 if (strlen(timestr) == 15 && strncmp(timestr, "191", 3) == 0) { 739 /* 740 * XXX: Workaround for lame ftpd's that return 741 * `19100' instead of `2000' 742 */ 743 fprintf(ttyout, 744 "Y2K warning! Incorrect time-val `%s' received from server.\n", 745 timestr); 746 timestr++; 747 timestr[0] = '2'; 748 timestr[1] = '0'; 749 fprintf(ttyout, "Converted to `%s'\n", timestr); 750 } 751 memset(&timebuf, 0, sizeof(timebuf)); 752 if (strlen(timestr) != 14 || 753 (strptime(timestr, "%Y%m%d%H%M%S", &timebuf) == NULL)) { 754 bad_parse_time: 755 fprintf(ttyout, "Can't parse time `%s'.\n", timestr); 756 goto cleanup_parse_time; 757 } 758 timebuf.tm_isdst = -1; 759 rtime = timegm(&timebuf); 760 if (rtime == -1) { 761 if (noisy || ftp_debug != 0) 762 goto bad_parse_time; 763 else 764 goto cleanup_parse_time; 765 } else { 766 DPRINTF("remotemodtime: parsed date `%s' as " LLF 767 ", %s", 768 timestr, (LLT)rtime, 769 rfc2822time(localtime(&rtime))); 770 } 771 } else { 772 if (r == ERROR && code == 500 && features[FEAT_MDTM] == -1) 773 features[FEAT_MDTM] = 0; 774 if (noisy && ftp_debug == 0) { 775 fputs(reply_string, ttyout); 776 putc('\n', ttyout); 777 } 778 } 779 cleanup_parse_time: 780 verbose = overbose; 781 if (rtime == -1) 782 code = ocode; 783 return (rtime); 784 } 785 786 /* 787 * Format tm in an RFC2822 compatible manner, with a trailing \n. 788 * Returns a pointer to a static string containing the result. 789 */ 790 const char * 791 rfc2822time(const struct tm *tm) 792 { 793 static char result[50]; 794 795 if (strftime(result, sizeof(result), 796 "%a, %d %b %Y %H:%M:%S %z\n", tm) == 0) 797 errx(1, "Can't convert RFC2822 time: buffer too small"); 798 return result; 799 } 800 801 /* 802 * Update global `localcwd', which contains the state of the local cwd 803 */ 804 void 805 updatelocalcwd(void) 806 { 807 808 if (getcwd(localcwd, sizeof(localcwd)) == NULL) 809 localcwd[0] = '\0'; 810 DPRINTF("updatelocalcwd: got `%s'\n", localcwd); 811 } 812 813 /* 814 * Update global `remotecwd', which contains the state of the remote cwd 815 */ 816 void 817 updateremotecwd(void) 818 { 819 int overbose, ocode; 820 size_t i; 821 char *cp; 822 823 overbose = verbose; 824 ocode = code; 825 if (ftp_debug == 0) 826 verbose = -1; 827 if (command("PWD") != COMPLETE) 828 goto badremotecwd; 829 cp = strchr(reply_string, ' '); 830 if (cp == NULL || cp[0] == '\0' || cp[1] != '"') 831 goto badremotecwd; 832 cp += 2; 833 for (i = 0; *cp && i < sizeof(remotecwd) - 1; i++, cp++) { 834 if (cp[0] == '"') { 835 if (cp[1] == '"') 836 cp++; 837 else 838 break; 839 } 840 remotecwd[i] = *cp; 841 } 842 remotecwd[i] = '\0'; 843 DPRINTF("updateremotecwd: got `%s'\n", remotecwd); 844 goto cleanupremotecwd; 845 badremotecwd: 846 remotecwd[0]='\0'; 847 cleanupremotecwd: 848 verbose = overbose; 849 code = ocode; 850 } 851 852 /* 853 * Ensure file is in or under dir. 854 * Returns 1 if so, 0 if not (or an error occurred). 855 */ 856 int 857 fileindir(const char *file, const char *dir) 858 { 859 char parentdirbuf[PATH_MAX+1], *parentdir; 860 char realdir[PATH_MAX+1]; 861 size_t dirlen; 862 863 /* determine parent directory of file */ 864 (void)strlcpy(parentdirbuf, file, sizeof(parentdirbuf)); 865 parentdir = dirname(parentdirbuf); 866 if (strcmp(parentdir, ".") == 0) 867 return 1; /* current directory is ok */ 868 869 /* find the directory */ 870 if (realpath(parentdir, realdir) == NULL) { 871 warn("Unable to determine real path of `%s'", parentdir); 872 return 0; 873 } 874 if (realdir[0] != '/') /* relative result is ok */ 875 return 1; 876 dirlen = strlen(dir); 877 if (strncmp(realdir, dir, dirlen) == 0 && 878 (realdir[dirlen] == '/' || realdir[dirlen] == '\0')) 879 return 1; 880 return 0; 881 } 882 883 /* 884 * List words in stringlist, vertically arranged 885 */ 886 void 887 list_vertical(StringList *sl) 888 { 889 size_t i, j; 890 size_t columns, lines; 891 char *p; 892 size_t w, width; 893 894 width = 0; 895 896 for (i = 0 ; i < sl->sl_cur ; i++) { 897 w = strlen(sl->sl_str[i]); 898 if (w > width) 899 width = w; 900 } 901 width = (width + 8) &~ 7; 902 903 columns = ttywidth / width; 904 if (columns == 0) 905 columns = 1; 906 lines = (sl->sl_cur + columns - 1) / columns; 907 for (i = 0; i < lines; i++) { 908 for (j = 0; j < columns; j++) { 909 p = sl->sl_str[j * lines + i]; 910 if (p) 911 fputs(p, ttyout); 912 if (j * lines + i + lines >= sl->sl_cur) { 913 putc('\n', ttyout); 914 break; 915 } 916 if (p) { 917 w = strlen(p); 918 while (w < width) { 919 w = (w + 8) &~ 7; 920 (void)putc('\t', ttyout); 921 } 922 } 923 } 924 } 925 } 926 927 /* 928 * Update the global ttywidth value, using TIOCGWINSZ. 929 */ 930 void 931 setttywidth(int a) 932 { 933 struct winsize winsize; 934 int oerrno = errno; 935 936 if (ioctl(fileno(ttyout), TIOCGWINSZ, &winsize) != -1 && 937 winsize.ws_col != 0) 938 ttywidth = winsize.ws_col; 939 else 940 ttywidth = 80; 941 errno = oerrno; 942 } 943 944 /* 945 * Change the rate limit up (SIGUSR1) or down (SIGUSR2) 946 */ 947 void 948 crankrate(int sig) 949 { 950 951 switch (sig) { 952 case SIGUSR1: 953 if (rate_get) 954 rate_get += rate_get_incr; 955 if (rate_put) 956 rate_put += rate_put_incr; 957 break; 958 case SIGUSR2: 959 if (rate_get && rate_get > rate_get_incr) 960 rate_get -= rate_get_incr; 961 if (rate_put && rate_put > rate_put_incr) 962 rate_put -= rate_put_incr; 963 break; 964 default: 965 err(1, "crankrate invoked with unknown signal: %d", sig); 966 } 967 } 968 969 970 /* 971 * Setup or cleanup EditLine structures 972 */ 973 #ifndef NO_EDITCOMPLETE 974 void 975 controlediting(void) 976 { 977 if (editing && el == NULL && hist == NULL) { 978 HistEvent ev; 979 int editmode; 980 981 el = el_init(getprogname(), stdin, ttyout, stderr); 982 /* init editline */ 983 hist = history_init(); /* init the builtin history */ 984 history(hist, &ev, H_SETSIZE, 100);/* remember 100 events */ 985 el_set(el, EL_HIST, history, hist); /* use history */ 986 987 el_set(el, EL_EDITOR, "emacs"); /* default editor is emacs */ 988 el_set(el, EL_PROMPT, prompt); /* set the prompt functions */ 989 el_set(el, EL_RPROMPT, rprompt); 990 991 /* add local file completion, bind to TAB */ 992 el_set(el, EL_ADDFN, "ftp-complete", 993 "Context sensitive argument completion", 994 complete); 995 el_set(el, EL_BIND, "^I", "ftp-complete", NULL); 996 el_source(el, NULL); /* read ~/.editrc */ 997 if ((el_get(el, EL_EDITMODE, &editmode) != -1) && editmode == 0) 998 editing = 0; /* the user doesn't want editing, 999 * so disable, and let statement 1000 * below cleanup */ 1001 else 1002 el_set(el, EL_SIGNAL, 1); 1003 } 1004 if (!editing) { 1005 if (hist) { 1006 history_end(hist); 1007 hist = NULL; 1008 } 1009 if (el) { 1010 el_end(el); 1011 el = NULL; 1012 } 1013 } 1014 } 1015 #endif /* !NO_EDITCOMPLETE */ 1016 1017 /* 1018 * Convert the string `arg' to an int, which may have an optional SI suffix 1019 * (`b', `k', `m', `g'). Returns the number for success, -1 otherwise. 1020 */ 1021 int 1022 strsuftoi(const char *arg) 1023 { 1024 char *cp; 1025 long val; 1026 1027 if (!isdigit((unsigned char)arg[0])) 1028 return (-1); 1029 1030 val = strtol(arg, &cp, 10); 1031 if (cp != NULL) { 1032 if (cp[0] != '\0' && cp[1] != '\0') 1033 return (-1); 1034 switch (tolower((unsigned char)cp[0])) { 1035 case '\0': 1036 case 'b': 1037 break; 1038 case 'k': 1039 val <<= 10; 1040 break; 1041 case 'm': 1042 val <<= 20; 1043 break; 1044 case 'g': 1045 val <<= 30; 1046 break; 1047 default: 1048 return (-1); 1049 } 1050 } 1051 if (val < 0 || val > INT_MAX) 1052 return (-1); 1053 1054 return (val); 1055 } 1056 1057 /* 1058 * Set up socket buffer sizes before a connection is made. 1059 */ 1060 void 1061 setupsockbufsize(int sock) 1062 { 1063 socklen_t slen; 1064 1065 if (0 == rcvbuf_size) { 1066 slen = sizeof(rcvbuf_size); 1067 if (getsockopt(sock, SOL_SOCKET, SO_RCVBUF, 1068 (void *)&rcvbuf_size, &slen) == -1) 1069 err(1, "Unable to determine rcvbuf size"); 1070 if (rcvbuf_size <= 0) 1071 rcvbuf_size = 8 * 1024; 1072 if (rcvbuf_size > 8 * 1024 * 1024) 1073 rcvbuf_size = 8 * 1024 * 1024; 1074 DPRINTF("setupsockbufsize: rcvbuf_size determined as %d\n", 1075 rcvbuf_size); 1076 } 1077 if (0 == sndbuf_size) { 1078 slen = sizeof(sndbuf_size); 1079 if (getsockopt(sock, SOL_SOCKET, SO_SNDBUF, 1080 (void *)&sndbuf_size, &slen) == -1) 1081 err(1, "Unable to determine sndbuf size"); 1082 if (sndbuf_size <= 0) 1083 sndbuf_size = 8 * 1024; 1084 if (sndbuf_size > 8 * 1024 * 1024) 1085 sndbuf_size = 8 * 1024 * 1024; 1086 DPRINTF("setupsockbufsize: sndbuf_size determined as %d\n", 1087 sndbuf_size); 1088 } 1089 1090 if (setsockopt(sock, SOL_SOCKET, SO_SNDBUF, 1091 (void *)&sndbuf_size, sizeof(sndbuf_size)) == -1) 1092 warn("Unable to set sndbuf size %d", sndbuf_size); 1093 1094 if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF, 1095 (void *)&rcvbuf_size, sizeof(rcvbuf_size)) == -1) 1096 warn("Unable to set rcvbuf size %d", rcvbuf_size); 1097 } 1098 1099 /* 1100 * Copy characters from src into dst, \ quoting characters that require it 1101 */ 1102 void 1103 ftpvis(char *dst, size_t dstlen, const char *src, size_t srclen) 1104 { 1105 size_t di, si; 1106 1107 for (di = si = 0; 1108 src[si] != '\0' && di < dstlen && si < srclen; 1109 di++, si++) { 1110 switch (src[si]) { 1111 case '\\': 1112 case ' ': 1113 case '\t': 1114 case '\r': 1115 case '\n': 1116 case '"': 1117 dst[di++] = '\\'; 1118 if (di >= dstlen) 1119 break; 1120 /* FALLTHROUGH */ 1121 default: 1122 dst[di] = src[si]; 1123 } 1124 } 1125 dst[di] = '\0'; 1126 } 1127 1128 /* 1129 * Copy src into buf (which is len bytes long), expanding % sequences. 1130 */ 1131 void 1132 formatbuf(char *buf, size_t len, const char *src) 1133 { 1134 const char *p, *p2, *q; 1135 size_t i; 1136 int op, updirs, pdirs; 1137 1138 #define ADDBUF(x) do { \ 1139 if (i >= len - 1) \ 1140 goto endbuf; \ 1141 buf[i++] = (x); \ 1142 } while (0) 1143 1144 p = src; 1145 for (i = 0; *p; p++) { 1146 if (*p != '%') { 1147 ADDBUF(*p); 1148 continue; 1149 } 1150 p++; 1151 1152 switch (op = *p) { 1153 1154 case '/': 1155 case '.': 1156 case 'c': 1157 p2 = connected ? remotecwd : ""; 1158 updirs = pdirs = 0; 1159 1160 /* option to determine fixed # of dirs from path */ 1161 if (op == '.' || op == 'c') { 1162 int skip; 1163 1164 q = p2; 1165 while (*p2) /* calc # of /'s */ 1166 if (*p2++ == '/') 1167 updirs++; 1168 if (p[1] == '0') { /* print <x> or ... */ 1169 pdirs = 1; 1170 p++; 1171 } 1172 if (p[1] >= '1' && p[1] <= '9') { 1173 /* calc # to skip */ 1174 skip = p[1] - '0'; 1175 p++; 1176 } else 1177 skip = 1; 1178 1179 updirs -= skip; 1180 while (skip-- > 0) { 1181 while ((p2 > q) && (*p2 != '/')) 1182 p2--; /* back up */ 1183 if (skip && p2 > q) 1184 p2--; 1185 } 1186 if (*p2 == '/' && p2 != q) 1187 p2++; 1188 } 1189 1190 if (updirs > 0 && pdirs) { 1191 if (i >= len - 5) 1192 break; 1193 if (op == '.') { 1194 ADDBUF('.'); 1195 ADDBUF('.'); 1196 ADDBUF('.'); 1197 } else { 1198 ADDBUF('/'); 1199 ADDBUF('<'); 1200 if (updirs > 9) { 1201 ADDBUF('9'); 1202 ADDBUF('+'); 1203 } else 1204 ADDBUF('0' + updirs); 1205 ADDBUF('>'); 1206 } 1207 } 1208 for (; *p2; p2++) 1209 ADDBUF(*p2); 1210 break; 1211 1212 case 'M': 1213 case 'm': 1214 for (p2 = connected && hostname ? hostname : "-"; 1215 *p2 ; p2++) { 1216 if (op == 'm' && *p2 == '.') 1217 break; 1218 ADDBUF(*p2); 1219 } 1220 break; 1221 1222 case 'n': 1223 for (p2 = connected ? username : "-"; *p2 ; p2++) 1224 ADDBUF(*p2); 1225 break; 1226 1227 case '%': 1228 ADDBUF('%'); 1229 break; 1230 1231 default: /* display unknown codes literally */ 1232 ADDBUF('%'); 1233 ADDBUF(op); 1234 break; 1235 1236 } 1237 } 1238 endbuf: 1239 buf[i] = '\0'; 1240 } 1241 1242 /* 1243 * Determine if given string is an IPv6 address or not. 1244 * Return 1 for yes, 0 for no 1245 */ 1246 int 1247 isipv6addr(const char *addr) 1248 { 1249 int rv = 0; 1250 #ifdef INET6 1251 struct addrinfo hints, *res; 1252 1253 memset(&hints, 0, sizeof(hints)); 1254 hints.ai_family = AF_INET6; 1255 hints.ai_socktype = SOCK_DGRAM; /*dummy*/ 1256 hints.ai_flags = AI_NUMERICHOST; 1257 if (getaddrinfo(addr, "0", &hints, &res) != 0) 1258 rv = 0; 1259 else { 1260 rv = 1; 1261 freeaddrinfo(res); 1262 } 1263 DPRINTF("isipv6addr: got %d for %s\n", rv, addr); 1264 #endif 1265 return (rv == 1) ? 1 : 0; 1266 } 1267 1268 /* 1269 * Read a line from the FILE stream into buf/buflen using fgets(), so up 1270 * to buflen-1 chars will be read and the result will be NUL terminated. 1271 * If the line has a trailing newline it will be removed. 1272 * If the line is too long, excess characters will be read until 1273 * newline/EOF/error. 1274 * If EOF/error occurs or a too-long line is encountered and errormsg 1275 * isn't NULL, it will be changed to a description of the problem. 1276 * (The EOF message has a leading \n for cosmetic purposes). 1277 * Returns: 1278 * >=0 length of line (excluding trailing newline) if all ok 1279 * -1 error occurred 1280 * -2 EOF encountered 1281 * -3 line was too long 1282 */ 1283 int 1284 get_line(FILE *stream, char *buf, size_t buflen, const char **errormsg) 1285 { 1286 int rv, ch; 1287 size_t len; 1288 1289 if (fgets(buf, buflen, stream) == NULL) { 1290 if (feof(stream)) { /* EOF */ 1291 rv = -2; 1292 if (errormsg) 1293 *errormsg = "\nEOF received"; 1294 } else { /* error */ 1295 rv = -1; 1296 if (errormsg) 1297 *errormsg = "Error encountered"; 1298 } 1299 clearerr(stream); 1300 return rv; 1301 } 1302 len = strlen(buf); 1303 if (buf[len-1] == '\n') { /* clear any trailing newline */ 1304 buf[--len] = '\0'; 1305 } else if (len == buflen-1) { /* line too long */ 1306 while ((ch = getchar()) != '\n' && ch != EOF) 1307 continue; 1308 if (errormsg) 1309 *errormsg = "Input line is too long"; 1310 clearerr(stream); 1311 return -3; 1312 } 1313 if (errormsg) 1314 *errormsg = NULL; 1315 return len; 1316 } 1317 1318 /* 1319 * Internal version of connect(2); sets socket buffer sizes, 1320 * binds to a specific local address (if set), and 1321 * supports a connection timeout using a non-blocking connect(2) with 1322 * a poll(2). 1323 * Socket fcntl flags are temporarily updated to include O_NONBLOCK; 1324 * these will not be reverted on connection failure. 1325 * Returns 0 on success, or -1 upon failure (with an appropriate 1326 * error message displayed.) 1327 */ 1328 int 1329 ftp_connect(int sock, const struct sockaddr *name, socklen_t namelen) 1330 { 1331 int flags, rv, timeout, error; 1332 socklen_t slen; 1333 struct timeval endtime, now, td; 1334 struct pollfd pfd[1]; 1335 char hname[NI_MAXHOST]; 1336 char sname[NI_MAXSERV]; 1337 1338 setupsockbufsize(sock); 1339 if (getnameinfo(name, namelen, 1340 hname, sizeof(hname), sname, sizeof(sname), 1341 NI_NUMERICHOST | NI_NUMERICSERV) != 0) { 1342 strlcpy(hname, "?", sizeof(hname)); 1343 strlcpy(sname, "?", sizeof(sname)); 1344 } 1345 1346 if (bindai != NULL) { /* bind to specific addr */ 1347 struct addrinfo *ai; 1348 1349 for (ai = bindai; ai != NULL; ai = ai->ai_next) { 1350 if (ai->ai_family == name->sa_family) 1351 break; 1352 } 1353 if (ai == NULL) 1354 ai = bindai; 1355 if (bind(sock, ai->ai_addr, ai->ai_addrlen) == -1) { 1356 char bname[NI_MAXHOST]; 1357 int saveerr; 1358 1359 saveerr = errno; 1360 if (getnameinfo(ai->ai_addr, ai->ai_addrlen, 1361 bname, sizeof(bname), NULL, 0, NI_NUMERICHOST) != 0) 1362 strlcpy(bname, "?", sizeof(bname)); 1363 errno = saveerr; 1364 warn("Can't bind to `%s'", bname); 1365 return -1; 1366 } 1367 } 1368 1369 /* save current socket flags */ 1370 if ((flags = fcntl(sock, F_GETFL, 0)) == -1) { 1371 warn("Can't %s socket flags for connect to `%s:%s'", 1372 "save", hname, sname); 1373 return -1; 1374 } 1375 /* set non-blocking connect */ 1376 if (fcntl(sock, F_SETFL, flags | O_NONBLOCK) == -1) { 1377 warn("Can't set socket non-blocking for connect to `%s:%s'", 1378 hname, sname); 1379 return -1; 1380 } 1381 1382 /* NOTE: we now must restore socket flags on successful exit */ 1383 1384 pfd[0].fd = sock; 1385 pfd[0].events = POLLIN|POLLOUT; 1386 1387 if (quit_time > 0) { /* want a non default timeout */ 1388 (void)gettimeofday(&endtime, NULL); 1389 endtime.tv_sec += quit_time; /* determine end time */ 1390 } 1391 1392 rv = connect(sock, name, namelen); /* inititate the connection */ 1393 if (rv == -1) { /* connection error */ 1394 if (errno != EINPROGRESS) { /* error isn't "please wait" */ 1395 connecterror: 1396 warn("Can't connect to `%s:%s'", hname, sname); 1397 return -1; 1398 } 1399 1400 /* connect EINPROGRESS; wait */ 1401 do { 1402 if (quit_time > 0) { /* determine timeout */ 1403 (void)gettimeofday(&now, NULL); 1404 timersub(&endtime, &now, &td); 1405 timeout = td.tv_sec * 1000 + td.tv_usec/1000; 1406 if (timeout < 0) 1407 timeout = 0; 1408 } else { 1409 timeout = INFTIM; 1410 } 1411 pfd[0].revents = 0; 1412 rv = ftp_poll(pfd, 1, timeout); 1413 /* loop until poll ! EINTR */ 1414 } while (rv == -1 && errno == EINTR); 1415 1416 if (rv == 0) { /* poll (connect) timed out */ 1417 errno = ETIMEDOUT; 1418 goto connecterror; 1419 } 1420 1421 if (rv == -1) { /* poll error */ 1422 goto connecterror; 1423 } else if (pfd[0].revents & (POLLIN|POLLOUT)) { 1424 slen = sizeof(error); /* OK, or pending error */ 1425 if (getsockopt(sock, SOL_SOCKET, SO_ERROR, 1426 &error, &slen) == -1) { 1427 /* Solaris pending error */ 1428 goto connecterror; 1429 } else if (error != 0) { 1430 errno = error; /* BSD pending error */ 1431 goto connecterror; 1432 } 1433 } else { 1434 errno = EBADF; /* this shouldn't happen ... */ 1435 goto connecterror; 1436 } 1437 } 1438 1439 if (fcntl(sock, F_SETFL, flags) == -1) { 1440 /* restore socket flags */ 1441 warn("Can't %s socket flags for connect to `%s:%s'", 1442 "restore", hname, sname); 1443 return -1; 1444 } 1445 return 0; 1446 } 1447 1448 /* 1449 * Internal version of listen(2); sets socket buffer sizes first. 1450 */ 1451 int 1452 ftp_listen(int sock, int backlog) 1453 { 1454 1455 setupsockbufsize(sock); 1456 return (listen(sock, backlog)); 1457 } 1458 1459 /* 1460 * Internal version of poll(2), to allow reimplementation by select(2) 1461 * on platforms without the former. 1462 */ 1463 int 1464 ftp_poll(struct pollfd *fds, int nfds, int timeout) 1465 { 1466 #if defined(HAVE_POLL) 1467 return poll(fds, nfds, timeout); 1468 1469 #elif defined(HAVE_SELECT) 1470 /* implement poll(2) using select(2) */ 1471 fd_set rset, wset, xset; 1472 const int rsetflags = POLLIN | POLLRDNORM; 1473 const int wsetflags = POLLOUT | POLLWRNORM; 1474 const int xsetflags = POLLRDBAND; 1475 struct timeval tv, *ptv; 1476 int i, max, rv; 1477 1478 FD_ZERO(&rset); /* build list of read & write events */ 1479 FD_ZERO(&wset); 1480 FD_ZERO(&xset); 1481 max = 0; 1482 for (i = 0; i < nfds; i++) { 1483 if (fds[i].fd > FD_SETSIZE) { 1484 warnx("can't select fd %d", fds[i].fd); 1485 errno = EINVAL; 1486 return -1; 1487 } else if (fds[i].fd > max) 1488 max = fds[i].fd; 1489 if (fds[i].events & rsetflags) 1490 FD_SET(fds[i].fd, &rset); 1491 if (fds[i].events & wsetflags) 1492 FD_SET(fds[i].fd, &wset); 1493 if (fds[i].events & xsetflags) 1494 FD_SET(fds[i].fd, &xset); 1495 } 1496 1497 ptv = &tv; /* determine timeout */ 1498 if (timeout == -1) { /* wait forever */ 1499 ptv = NULL; 1500 } else if (timeout == 0) { /* poll once */ 1501 ptv->tv_sec = 0; 1502 ptv->tv_usec = 0; 1503 } 1504 else if (timeout != 0) { /* wait timeout milliseconds */ 1505 ptv->tv_sec = timeout / 1000; 1506 ptv->tv_usec = (timeout % 1000) * 1000; 1507 } 1508 rv = select(max + 1, &rset, &wset, &xset, ptv); 1509 if (rv <= 0) /* -1 == error, 0 == timeout */ 1510 return rv; 1511 1512 for (i = 0; i < nfds; i++) { /* determine results */ 1513 if (FD_ISSET(fds[i].fd, &rset)) 1514 fds[i].revents |= (fds[i].events & rsetflags); 1515 if (FD_ISSET(fds[i].fd, &wset)) 1516 fds[i].revents |= (fds[i].events & wsetflags); 1517 if (FD_ISSET(fds[i].fd, &xset)) 1518 fds[i].revents |= (fds[i].events & xsetflags); 1519 } 1520 return rv; 1521 1522 #else 1523 # error no way to implement xpoll 1524 #endif 1525 } 1526 1527 /* 1528 * malloc() with inbuilt error checking 1529 */ 1530 void * 1531 ftp_malloc(size_t size) 1532 { 1533 void *p; 1534 1535 p = malloc(size); 1536 if (p == NULL) 1537 err(1, "Unable to allocate %ld bytes of memory", (long)size); 1538 return (p); 1539 } 1540 1541 /* 1542 * sl_init() with inbuilt error checking 1543 */ 1544 StringList * 1545 ftp_sl_init(void) 1546 { 1547 StringList *p; 1548 1549 p = sl_init(); 1550 if (p == NULL) 1551 err(1, "Unable to allocate memory for stringlist"); 1552 return (p); 1553 } 1554 1555 /* 1556 * sl_add() with inbuilt error checking 1557 */ 1558 void 1559 ftp_sl_add(StringList *sl, char *i) 1560 { 1561 1562 if (sl_add(sl, i) == -1) 1563 err(1, "Unable to add `%s' to stringlist", i); 1564 } 1565 1566 /* 1567 * strdup() with inbuilt error checking 1568 */ 1569 char * 1570 ftp_strdup(const char *str) 1571 { 1572 char *s; 1573 1574 if (str == NULL) 1575 errx(1, "ftp_strdup: called with NULL argument"); 1576 s = strdup(str); 1577 if (s == NULL) 1578 err(1, "Unable to allocate memory for string copy"); 1579 return (s); 1580 } 1581