1: /*
   2:  * Copyright (c) 1985 Regents of the University of California.
   3:  * All rights reserved.  The Berkeley software License Agreement
   4:  * specifies the terms and conditions for redistribution.
   5:  */
   6: 
   7: #ifndef lint
   8: static char sccsid[] = "@(#)ftp.c	5.14 (Berkeley) 5/22/86";
   9: #endif not lint
  10: 
  11: #include "ftp_var.h"
  12: 
  13: #include <sys/stat.h>
  14: #include <sys/ioctl.h>
  15: #include <sys/socket.h>
  16: #include <sys/time.h>
  17: #include <sys/param.h>
  18: 
  19: #include <netinet/in.h>
  20: #include <arpa/ftp.h>
  21: #include <arpa/telnet.h>
  22: 
  23: #include <stdio.h>
  24: #include <signal.h>
  25: #include <errno.h>
  26: #include <netdb.h>
  27: #include <fcntl.h>
  28: #include <pwd.h>
  29: 
  30: struct  sockaddr_in hisctladdr;
  31: struct  sockaddr_in data_addr;
  32: int data = -1;
  33: int abrtflag = 0;
  34: int ptflag = 0;
  35: int connected;
  36: struct  sockaddr_in myctladdr;
  37: uid_t   getuid();
  38: 
  39: FILE    *cin, *cout;
  40: FILE    *dataconn();
  41: 
  42: char *
  43: hookup(host, port)
  44:     char *host;
  45:     int port;
  46: {
  47:     register struct hostent *hp = 0;
  48:     int s,len;
  49:     static char hostnamebuf[80];
  50: 
  51:     bzero((char *)&hisctladdr, sizeof (hisctladdr));
  52:     hisctladdr.sin_addr.s_addr = inet_addr(host);
  53:     if (hisctladdr.sin_addr.s_addr != -1) {
  54:         hisctladdr.sin_family = AF_INET;
  55:         (void) strcpy(hostnamebuf, host);
  56:     }
  57:     else {
  58:         hp = gethostbyname(host);
  59:         if (hp == NULL) {
  60:             printf("%s: unknown host\n", host);
  61:             code = -1;
  62:             return((char *) 0);
  63:         }
  64:         hisctladdr.sin_family = hp->h_addrtype;
  65:         bcopy(hp->h_addr_list[0],
  66:             (caddr_t)&hisctladdr.sin_addr, hp->h_length);
  67:         (void) strcpy(hostnamebuf, hp->h_name);
  68:     }
  69:     hostname = hostnamebuf;
  70:     s = socket(hisctladdr.sin_family, SOCK_STREAM, 0);
  71:     if (s < 0) {
  72:         perror("ftp: socket");
  73:         code = -1;
  74:         return (0);
  75:     }
  76:     hisctladdr.sin_port = port;
  77:     while (connect(s, &hisctladdr, sizeof (hisctladdr)) < 0) {
  78:         if (hp && hp->h_addr_list[1]) {
  79:             int oerrno = errno;
  80: 
  81:             fprintf(stderr, "ftp: connect to address %s: ",
  82:                 inet_ntoa(hisctladdr.sin_addr));
  83:             errno = oerrno;
  84:             perror((char *) 0);
  85:             hp->h_addr_list++;
  86:             bcopy(hp->h_addr_list[0],
  87:                  (caddr_t)&hisctladdr.sin_addr, hp->h_length);
  88:             fprintf(stdout, "Trying %s...\n",
  89:                 inet_ntoa(hisctladdr.sin_addr));
  90:             (void) close(s);
  91:             s = socket(hisctladdr.sin_family, SOCK_STREAM, 0);
  92:             if (s < 0) {
  93:                 perror("ftp: socket");
  94:                 code = -1;
  95:                 return (0);
  96:             }
  97:             continue;
  98:         }
  99:         perror("ftp: connect");
 100:         code = -1;
 101:         goto bad;
 102:     }
 103:     len = sizeof (myctladdr);
 104:     if (getsockname(s, (char *)&myctladdr, &len) < 0) {
 105:         perror("ftp: getsockname");
 106:         code = -1;
 107:         goto bad;
 108:     }
 109:     cin = fdopen(s, "r");
 110:     cout = fdopen(s, "w");
 111:     if (cin == NULL || cout == NULL) {
 112:         fprintf(stderr, "ftp: fdopen failed.\n");
 113:         if (cin)
 114:             (void) fclose(cin);
 115:         if (cout)
 116:             (void) fclose(cout);
 117:         code = -1;
 118:         goto bad;
 119:     }
 120:     if (verbose)
 121:         printf("Connected to %s.\n", hostname);
 122:     if (getreply(0) > 2) {  /* read startup message from server */
 123:         if (cin)
 124:             (void) fclose(cin);
 125:         if (cout)
 126:             (void) fclose(cout);
 127:         code = -1;
 128:         goto bad;
 129:     }
 130: #ifdef SO_OOBINLINE
 131:     {
 132:     int on = 1;
 133: 
 134:     if (setsockopt(s, SOL_SOCKET, SO_OOBINLINE, &on, sizeof(on))
 135:         < 0 && debug) {
 136:             perror("ftp: setsockopt");
 137:         }
 138:     }
 139: #endif SO_OOBINLINE
 140: 
 141:     return (hostname);
 142: bad:
 143:     (void) close(s);
 144:     return ((char *)0);
 145: }
 146: 
 147: login(host)
 148:     char *host;
 149: {
 150:     char tmp[80];
 151:     char *user, *pass, *acct, *getlogin(), *mygetpass();
 152:     int n, aflag = 0;
 153: 
 154:     user = pass = acct = 0;
 155:     if (ruserpass(host, &user, &pass, &acct) < 0) {
 156:         disconnect();
 157:         code = -1;
 158:         return(0);
 159:     }
 160:     if (user == NULL) {
 161:         char *myname = getlogin();
 162: 
 163:         if (myname == NULL) {
 164:             struct passwd *pp = getpwuid(getuid());
 165: 
 166:             if (pp != NULL)
 167:                 myname = pp->pw_name;
 168:         }
 169:         printf("Name (%s:%s): ", host, myname);
 170:         (void) fgets(tmp, sizeof(tmp) - 1, stdin);
 171:         tmp[strlen(tmp) - 1] = '\0';
 172:         if (*tmp == '\0')
 173:             user = myname;
 174:         else
 175:             user = tmp;
 176:     }
 177:     n = command("USER %s", user);
 178:     if (n == CONTINUE) {
 179:         if (pass == NULL)
 180:             pass = mygetpass("Password:");
 181:         n = command("PASS %s", pass);
 182:     }
 183:     if (n == CONTINUE) {
 184:         aflag++;
 185:         acct = mygetpass("Account:");
 186:         n = command("ACCT %s", acct);
 187:     }
 188:     if (n != COMPLETE) {
 189:         fprintf(stderr, "Login failed.\n");
 190:         return (0);
 191:     }
 192:     if (!aflag && acct != NULL)
 193:         (void) command("ACCT %s", acct);
 194:     if (proxy)
 195:         return(1);
 196:     for (n = 0; n < macnum; ++n) {
 197:         if (!strcmp("init", macros[n].mac_name)) {
 198:             (void) strcpy(line, "$init");
 199:             makeargv();
 200:             domacro(margc, margv);
 201:             break;
 202:         }
 203:     }
 204:     return (1);
 205: }
 206: 
 207: cmdabort()
 208: {
 209:     extern jmp_buf ptabort;
 210: 
 211:     printf("\n");
 212:     (void) fflush(stdout);
 213:     abrtflag++;
 214:     if (ptflag)
 215:         longjmp(ptabort,1);
 216: }
 217: 
 218: /*VARARGS1*/
 219: command(fmt, args)
 220:     char *fmt;
 221: {
 222:     int r, (*oldintr)(), cmdabort();
 223: 
 224:     abrtflag = 0;
 225:     if (debug) {
 226:         printf("---> ");
 227:         _doprnt(fmt, &args, stdout);
 228:         printf("\n");
 229:         (void) fflush(stdout);
 230:     }
 231:     if (cout == NULL) {
 232:         perror ("No control connection for command");
 233:         code = -1;
 234:         return (0);
 235:     }
 236:     oldintr = signal(SIGINT,cmdabort);
 237:     _doprnt(fmt, &args, cout);
 238:     fprintf(cout, "\r\n");
 239:     (void) fflush(cout);
 240:     cpend = 1;
 241:     r = getreply(!strcmp(fmt, "QUIT"));
 242:     if (abrtflag && oldintr != SIG_IGN)
 243:         (*oldintr)();
 244:     (void) signal(SIGINT, oldintr);
 245:     return(r);
 246: }
 247: 
 248: #include <ctype.h>
 249: 
 250: getreply(expecteof)
 251:     int expecteof;
 252: {
 253:     register int c, n;
 254:     register int dig;
 255:     int originalcode = 0, continuation = 0, (*oldintr)(), cmdabort();
 256:     int pflag = 0;
 257:     char *pt = pasv;
 258: 
 259:     oldintr = signal(SIGINT,cmdabort);
 260:     for (;;) {
 261:         dig = n = code = 0;
 262:         while ((c = getc(cin)) != '\n') {
 263:             if (c == IAC) {     /* handle telnet commands */
 264:                 switch (c = getc(cin)) {
 265:                 case WILL:
 266:                 case WONT:
 267:                     c = getc(cin);
 268:                     fprintf(cout, "%c%c%c",IAC,WONT,c);
 269:                     (void) fflush(cout);
 270:                     break;
 271:                 case DO:
 272:                 case DONT:
 273:                     c = getc(cin);
 274:                     fprintf(cout, "%c%c%c",IAC,DONT,c);
 275:                     (void) fflush(cout);
 276:                     break;
 277:                 default:
 278:                     break;
 279:                 }
 280:                 continue;
 281:             }
 282:             dig++;
 283:             if (c == EOF) {
 284:                 if (expecteof) {
 285:                     (void) signal(SIGINT,oldintr);
 286:                     code = 221;
 287:                     return (0);
 288:                 }
 289:                 lostpeer();
 290:                 if (verbose) {
 291:                     printf("421 Service not available, remote server has closed connection\n");
 292:                     (void) fflush(stdout);
 293:                     code = 421;
 294:                     return(4);
 295:                 }
 296:             }
 297:             if (c != '\r' && (verbose > 0 ||
 298:                 (verbose > -1 && n == '5' && dig > 4))) {
 299:                 if (proxflag &&
 300:                    (dig == 1 || dig == 5 && verbose == 0))
 301:                     printf("%s:",hostname);
 302:                 (void) putchar(c);
 303:             }
 304:             if (dig < 4 && isdigit(c))
 305:                 code = code * 10 + (c - '0');
 306:             if (!pflag && code == 227)
 307:                 pflag = 1;
 308:             if (dig > 4 && pflag == 1 && isdigit(c))
 309:                 pflag = 2;
 310:             if (pflag == 2) {
 311:                 if (c != '\r' && c != ')')
 312:                     *pt++ = c;
 313:                 else {
 314:                     *pt = '\0';
 315:                     pflag = 3;
 316:                 }
 317:             }
 318:             if (dig == 4 && c == '-') {
 319:                 if (continuation)
 320:                     code = 0;
 321:                 continuation++;
 322:             }
 323:             if (n == 0)
 324:                 n = c;
 325:         }
 326:         if (verbose > 0 || verbose > -1 && n == '5') {
 327:             (void) putchar(c);
 328:             (void) fflush (stdout);
 329:         }
 330:         if (continuation && code != originalcode) {
 331:             if (originalcode == 0)
 332:                 originalcode = code;
 333:             continue;
 334:         }
 335:         if (n != '1')
 336:             cpend = 0;
 337:         (void) signal(SIGINT,oldintr);
 338:         if (code == 421 || originalcode == 421)
 339:             lostpeer();
 340:         if (abrtflag && oldintr != cmdabort && oldintr != SIG_IGN)
 341:             (*oldintr)();
 342:         return (n - '0');
 343:     }
 344: }
 345: 
 346: empty(mask, sec)
 347:     struct fd_set *mask;
 348:     int sec;
 349: {
 350:     struct timeval t;
 351: 
 352:     t.tv_sec = (long) sec;
 353:     t.tv_usec = 0;
 354:     return(select(32, mask, (struct fd_set *) 0, (struct fd_set *) 0, &t));
 355: }
 356: 
 357: jmp_buf sendabort;
 358: 
 359: abortsend()
 360: {
 361: 
 362:     mflag = 0;
 363:     abrtflag = 0;
 364:     printf("\nsend aborted\n");
 365:     (void) fflush(stdout);
 366:     longjmp(sendabort, 1);
 367: }
 368: 
 369: sendrequest(cmd, local, remote)
 370:     char *cmd, *local, *remote;
 371: {
 372:     FILE *fin, *dout = 0, *mypopen();
 373:     int (*closefunc)(), mypclose(), fclose(), (*oldintr)(), (*oldintp)();
 374:     int abortsend();
 375:     char buf[BUFSIZ];
 376:     long bytes = 0, hashbytes = sizeof (buf);
 377:     register int c, d;
 378:     struct stat st;
 379:     struct timeval start, stop;
 380: 
 381:     if (proxy) {
 382:         proxtrans(cmd, local, remote);
 383:         return;
 384:     }
 385:     closefunc = NULL;
 386:     oldintr = NULL;
 387:     oldintp = NULL;
 388:     if (setjmp(sendabort)) {
 389:         while (cpend) {
 390:             (void) getreply(0);
 391:         }
 392:         if (data >= 0) {
 393:             (void) close(data);
 394:             data = -1;
 395:         }
 396:         if (oldintr)
 397:             (void) signal(SIGINT,oldintr);
 398:         if (oldintp)
 399:             (void) signal(SIGPIPE,oldintp);
 400:         code = -1;
 401:         return;
 402:     }
 403:     oldintr = signal(SIGINT, abortsend);
 404:     if (strcmp(local, "-") == 0)
 405:         fin = stdin;
 406:     else if (*local == '|') {
 407:         oldintp = signal(SIGPIPE,SIG_IGN);
 408:         fin = mypopen(local + 1, "r");
 409:         if (fin == NULL) {
 410:             perror(local + 1);
 411:             (void) signal(SIGINT, oldintr);
 412:             (void) signal(SIGPIPE, oldintp);
 413:             code = -1;
 414:             return;
 415:         }
 416:         closefunc = mypclose;
 417:     } else {
 418:         fin = fopen(local, "r");
 419:         if (fin == NULL) {
 420:             perror(local);
 421:             (void) signal(SIGINT, oldintr);
 422:             code = -1;
 423:             return;
 424:         }
 425:         closefunc = fclose;
 426:         if (fstat(fileno(fin), &st) < 0 ||
 427:             (st.st_mode&S_IFMT) != S_IFREG) {
 428:             fprintf(stdout, "%s: not a plain file.\n", local);
 429:             (void) signal(SIGINT, oldintr);
 430:             code = -1;
 431:             return;
 432:         }
 433:     }
 434:     if (initconn()) {
 435:         (void) signal(SIGINT, oldintr);
 436:         if (oldintp)
 437:             (void) signal(SIGPIPE, oldintp);
 438:         code = -1;
 439:         return;
 440:     }
 441:     if (setjmp(sendabort))
 442:         goto abort;
 443:     if (remote) {
 444:         if (command("%s %s", cmd, remote) != PRELIM) {
 445:             (void) signal(SIGINT, oldintr);
 446:             if (oldintp)
 447:                 (void) signal(SIGPIPE, oldintp);
 448:             return;
 449:         }
 450:     } else
 451:         if (command("%s", cmd) != PRELIM) {
 452:             (void) signal(SIGINT, oldintr);
 453:             if (oldintp)
 454:                 (void) signal(SIGPIPE, oldintp);
 455:             return;
 456:         }
 457:     dout = dataconn("w");
 458:     if (dout == NULL)
 459:         goto abort;
 460:     (void) gettimeofday(&start, (struct timezone *)0);
 461:     switch (type) {
 462: 
 463:     case TYPE_I:
 464:     case TYPE_L:
 465:         errno = d = 0;
 466:         while ((c = read(fileno (fin), buf, sizeof (buf))) > 0) {
 467:             if ((d = write(fileno (dout), buf, c)) < 0)
 468:                 break;
 469:             bytes += c;
 470:             if (hash) {
 471:                 (void) putchar('#');
 472:                 (void) fflush(stdout);
 473:             }
 474:         }
 475:         if (hash && bytes > 0) {
 476:             (void) putchar('\n');
 477:             (void) fflush(stdout);
 478:         }
 479:         if (c < 0)
 480:             perror(local);
 481:         if (d < 0)
 482:             perror("netout");
 483:         break;
 484: 
 485:     case TYPE_A:
 486:         while ((c = getc(fin)) != EOF) {
 487:             if (c == '\n') {
 488:                 while (hash && (bytes >= hashbytes)) {
 489:                     (void) putchar('#');
 490:                     (void) fflush(stdout);
 491:                     hashbytes += sizeof (buf);
 492:                 }
 493:                 if (ferror(dout))
 494:                     break;
 495:                 (void) putc('\r', dout);
 496:                 bytes++;
 497:             }
 498:             (void) putc(c, dout);
 499:             bytes++;
 500:     /*		if (c == '\r') {			  	*/
 501:     /*		(void)	putc('\0', dout);  /* this violates rfc */
 502:     /*			bytes++;				*/
 503:     /*		}                          			*/
 504:         }
 505:         if (hash) {
 506:             if (bytes < hashbytes)
 507:                 (void) putchar('#');
 508:             (void) putchar('\n');
 509:             (void) fflush(stdout);
 510:         }
 511:         if (ferror(fin))
 512:             perror(local);
 513:         if (ferror(dout))
 514:             perror("netout");
 515:         break;
 516:     }
 517:     (void) gettimeofday(&stop, (struct timezone *)0);
 518:     if (closefunc != NULL)
 519:         (*closefunc)(fin);
 520:     (void) fclose(dout);
 521:     (void) getreply(0);
 522:     (void) signal(SIGINT, oldintr);
 523:     if (bytes > 0 && verbose)
 524:         ptransfer("sent", bytes, &start, &stop, local, remote);
 525:     return;
 526: abort:
 527:     (void) gettimeofday(&stop, (struct timezone *)0);
 528:     (void) signal(SIGINT, oldintr);
 529:     if (oldintp)
 530:         (void) signal(SIGPIPE, oldintp);
 531:     if (!cpend) {
 532:         code = -1;
 533:         return;
 534:     }
 535:     if (data >= 0) {
 536:         (void) close(data);
 537:         data = -1;
 538:     }
 539:     if (dout)
 540:         (void) fclose(dout);
 541:     (void) getreply(0);
 542:     code = -1;
 543:     if (closefunc != NULL && fin != NULL)
 544:         (*closefunc)(fin);
 545:     if (bytes > 0 && verbose)
 546:         ptransfer("sent", bytes, &start, &stop, local, remote);
 547: }
 548: 
 549: jmp_buf recvabort;
 550: 
 551: abortrecv()
 552: {
 553: 
 554:     mflag = 0;
 555:     abrtflag = 0;
 556:     printf("\n");
 557:     (void) fflush(stdout);
 558:     longjmp(recvabort, 1);
 559: }
 560: 
 561: recvrequest(cmd, local, remote, mode)
 562:     char *cmd, *local, *remote, *mode;
 563: {
 564:     FILE *fout, *din = 0, *mypopen();
 565:     int (*closefunc)(), mypclose(), fclose(), (*oldintr)(), (*oldintp)();
 566:     int abortrecv(), oldverbose, oldtype = 0, tcrflag, nfnd;
 567:     char buf[BUFSIZ], *gunique(), msg;
 568:     long bytes = 0, hashbytes = sizeof (buf);
 569:     struct fd_set mask;
 570:     register int c, d;
 571:     struct timeval start, stop;
 572: 
 573:     if (proxy && strcmp(cmd,"RETR") == 0) {
 574:         proxtrans(cmd, local, remote);
 575:         return;
 576:     }
 577:     closefunc = NULL;
 578:     oldintr = NULL;
 579:     oldintp = NULL;
 580:     tcrflag = !crflag && !strcmp(cmd, "RETR");
 581:     if (setjmp(recvabort)) {
 582:         while (cpend) {
 583:             (void) getreply(0);
 584:         }
 585:         if (data >= 0) {
 586:             (void) close(data);
 587:             data = -1;
 588:         }
 589:         if (oldintr)
 590:             (void) signal(SIGINT, oldintr);
 591:         code = -1;
 592:         return;
 593:     }
 594:     oldintr = signal(SIGINT, abortrecv);
 595:     if (strcmp(local, "-") && *local != '|') {
 596:         if (access(local, 2) < 0) {
 597:             char *dir = rindex(local, '/');
 598: 
 599:             if (errno != ENOENT && errno != EACCES) {
 600:                 perror(local);
 601:                 (void) signal(SIGINT, oldintr);
 602:                 code = -1;
 603:                 return;
 604:             }
 605:             if (dir != NULL)
 606:                 *dir = 0;
 607:             d = access(dir ? local : ".", 2);
 608:             if (dir != NULL)
 609:                 *dir = '/';
 610:             if (d < 0) {
 611:                 perror(local);
 612:                 (void) signal(SIGINT, oldintr);
 613:                 code = -1;
 614:                 return;
 615:             }
 616:             if (!runique && errno == EACCES &&
 617:                 chmod(local,0600) < 0) {
 618:                 perror(local);
 619:                 (void) signal(SIGINT, oldintr);
 620:                 code = -1;
 621:                 return;
 622:             }
 623:             if (runique && errno == EACCES &&
 624:                (local = gunique(local)) == NULL) {
 625:                 (void) signal(SIGINT, oldintr);
 626:                 code = -1;
 627:                 return;
 628:             }
 629:         }
 630:         else if (runique && (local = gunique(local)) == NULL) {
 631:             (void) signal(SIGINT, oldintr);
 632:             code = -1;
 633:             return;
 634:         }
 635:     }
 636:     if (initconn()) {
 637:         (void) signal(SIGINT, oldintr);
 638:         code = -1;
 639:         return;
 640:     }
 641:     if (setjmp(recvabort))
 642:         goto abort;
 643:     if (strcmp(cmd, "RETR") && type != TYPE_A) {
 644:         oldtype = type;
 645:         oldverbose = verbose;
 646:         if (!debug)
 647:             verbose = 0;
 648:         setascii();
 649:         verbose = oldverbose;
 650:     }
 651:     if (remote) {
 652:         if (command("%s %s", cmd, remote) != PRELIM) {
 653:             (void) signal(SIGINT, oldintr);
 654:             if (oldtype) {
 655:                 if (!debug)
 656:                     verbose = 0;
 657:                 switch (oldtype) {
 658:                     case TYPE_I:
 659:                         setbinary();
 660:                         break;
 661:                     case TYPE_E:
 662:                         setebcdic();
 663:                         break;
 664:                     case TYPE_L:
 665:                         settenex();
 666:                         break;
 667:                 }
 668:                 verbose = oldverbose;
 669:             }
 670:             return;
 671:         }
 672:     } else {
 673:         if (command("%s", cmd) != PRELIM) {
 674:             (void) signal(SIGINT, oldintr);
 675:             if (oldtype) {
 676:                 if (!debug)
 677:                     verbose = 0;
 678:                 switch (oldtype) {
 679:                     case TYPE_I:
 680:                         setbinary();
 681:                         break;
 682:                     case TYPE_E:
 683:                         setebcdic();
 684:                         break;
 685:                     case TYPE_L:
 686:                         settenex();
 687:                         break;
 688:                 }
 689:                 verbose = oldverbose;
 690:             }
 691:             return;
 692:         }
 693:     }
 694:     din = dataconn("r");
 695:     if (din == NULL)
 696:         goto abort;
 697:     if (strcmp(local, "-") == 0)
 698:         fout = stdout;
 699:     else if (*local == '|') {
 700:         oldintp = signal(SIGPIPE, SIG_IGN);
 701:         fout = mypopen(local + 1, "w");
 702:         if (fout == NULL) {
 703:             perror(local+1);
 704:             goto abort;
 705:         }
 706:         closefunc = mypclose;
 707:     }
 708:     else {
 709:         fout = fopen(local, mode);
 710:         if (fout == NULL) {
 711:             perror(local);
 712:             goto abort;
 713:         }
 714:         closefunc = fclose;
 715:     }
 716:     (void) gettimeofday(&start, (struct timezone *)0);
 717:     switch (type) {
 718: 
 719:     case TYPE_I:
 720:     case TYPE_L:
 721:         errno = d = 0;
 722:         while ((c = read(fileno(din), buf, sizeof (buf))) > 0) {
 723:             if ((d = write(fileno(fout), buf, c)) < 0)
 724:                 break;
 725:             bytes += c;
 726:             if (hash) {
 727:                 (void) putchar('#');
 728:                 (void) fflush(stdout);
 729:             }
 730:         }
 731:         if (hash && bytes > 0) {
 732:             (void) putchar('\n');
 733:             (void) fflush(stdout);
 734:         }
 735:         if (c < 0)
 736:             perror("netin");
 737:         if (d < 0)
 738:             perror(local);
 739:         break;
 740: 
 741:     case TYPE_A:
 742:         while ((c = getc(din)) != EOF) {
 743:             while (c == '\r') {
 744:                 while (hash && (bytes >= hashbytes)) {
 745:                     (void) putchar('#');
 746:                     (void) fflush(stdout);
 747:                     hashbytes += sizeof (buf);
 748:                 }
 749:                 bytes++;
 750:                 if ((c = getc(din)) != '\n' || tcrflag) {
 751:                     if (ferror (fout))
 752:                         break;
 753:                     (void) putc ('\r', fout);
 754:                 }
 755:                 /*if (c == '\0') {
 756: 					bytes++;
 757: 					continue;
 758: 				}*/
 759:             }
 760:             (void) putc (c, fout);
 761:             bytes++;
 762:         }
 763:         if (hash) {
 764:             if (bytes < hashbytes)
 765:                 (void) putchar('#');
 766:             (void) putchar('\n');
 767:             (void) fflush(stdout);
 768:         }
 769:         if (ferror (din))
 770:             perror ("netin");
 771:         if (ferror (fout))
 772:             perror (local);
 773:         break;
 774:     }
 775:     if (closefunc != NULL)
 776:         (*closefunc)(fout);
 777:     (void) signal(SIGINT, oldintr);
 778:     if (oldintp)
 779:         (void) signal(SIGPIPE, oldintp);
 780:     (void) gettimeofday(&stop, (struct timezone *)0);
 781:     (void) fclose(din);
 782:     (void) getreply(0);
 783:     if (bytes > 0 && verbose)
 784:         ptransfer("received", bytes, &start, &stop, local, remote);
 785:     if (oldtype) {
 786:         if (!debug)
 787:             verbose = 0;
 788:         switch (oldtype) {
 789:             case TYPE_I:
 790:                 setbinary();
 791:                 break;
 792:             case TYPE_E:
 793:                 setebcdic();
 794:                 break;
 795:             case TYPE_L:
 796:                 settenex();
 797:                 break;
 798:         }
 799:         verbose = oldverbose;
 800:     }
 801:     return;
 802: abort:
 803: 
 804: /* abort using RFC959 recommended IP,SYNC sequence  */
 805: 
 806:     (void) gettimeofday(&stop, (struct timezone *)0);
 807:     if (oldintp)
 808:         (void) signal(SIGPIPE, oldintr);
 809:     (void) signal(SIGINT,SIG_IGN);
 810:     if (oldtype) {
 811:         if (!debug)
 812:             verbose = 0;
 813:         switch (oldtype) {
 814:             case TYPE_I:
 815:                 setbinary();
 816:                 break;
 817:             case TYPE_E:
 818:                 setebcdic();
 819:                 break;
 820:             case TYPE_L:
 821:                 settenex();
 822:                 break;
 823:         }
 824:         verbose = oldverbose;
 825:     }
 826:     if (!cpend) {
 827:         code = -1;
 828:         (void) signal(SIGINT,oldintr);
 829:         return;
 830:     }
 831: 
 832:     fprintf(cout,"%c%c",IAC,IP);
 833:     (void) fflush(cout);
 834:     msg = IAC;
 835: /* send IAC in urgent mode instead of DM because UNIX places oob mark */
 836: /* after urgent byte rather than before as now is protocol            */
 837:     if (send(fileno(cout),&msg,1,MSG_OOB) != 1) {
 838:         perror("abort");
 839:     }
 840:     fprintf(cout,"%cABOR\r\n",DM);
 841:     (void) fflush(cout);
 842:     FD_ZERO(&mask);
 843:     FD_SET(fileno(cin), &mask);
 844:     if (din) {
 845:         FD_SET(fileno(din), &mask);
 846:     }
 847:     if ((nfnd = empty(&mask,10)) <= 0) {
 848:         if (nfnd < 0) {
 849:             perror("abort");
 850:         }
 851:         code = -1;
 852:         lostpeer();
 853:     }
 854:     if (din && FD_ISSET(fileno(din), &mask)) {
 855:         while ((c = read(fileno(din), buf, sizeof (buf))) > 0)
 856:             ;
 857:     }
 858:     if ((c = getreply(0)) == ERROR && code == 552) { /* needed for nic style abort */
 859:         if (data >= 0) {
 860:             (void) close(data);
 861:             data = -1;
 862:         }
 863:         (void) getreply(0);
 864:     }
 865:     (void) getreply(0);
 866:     code = -1;
 867:     if (data >= 0) {
 868:         (void) close(data);
 869:         data = -1;
 870:     }
 871:     if (closefunc != NULL && fout != NULL)
 872:         (*closefunc)(fout);
 873:     if (din)
 874:         (void) fclose(din);
 875:     if (bytes > 0 && verbose)
 876:         ptransfer("received", bytes, &start, &stop, local, remote);
 877:     (void) signal(SIGINT,oldintr);
 878: }
 879: 
 880: /*
 881:  * Need to start a listen on the data channel
 882:  * before we send the command, otherwise the
 883:  * server's connect may fail.
 884:  */
 885: static int sendport = -1;
 886: 
 887: initconn()
 888: {
 889:     register char *p, *a;
 890:     int result, len, tmpno = 0;
 891:     int on = 1;
 892: 
 893: noport:
 894:     data_addr = myctladdr;
 895:     if (sendport)
 896:         data_addr.sin_port = 0; /* let system pick one */
 897:     if (data != -1)
 898:         (void) close (data);
 899:     data = socket(AF_INET, SOCK_STREAM, 0);
 900:     if (data < 0) {
 901:         perror("ftp: socket");
 902:         if (tmpno)
 903:             sendport = 1;
 904:         return (1);
 905:     }
 906:     if (!sendport)
 907:         if (setsockopt(data, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof (on)) < 0) {
 908:             perror("ftp: setsockopt (resuse address)");
 909:             goto bad;
 910:         }
 911:     if (bind(data, (struct sockaddr *)&data_addr, sizeof (data_addr)) < 0) {
 912:         perror("ftp: bind");
 913:         goto bad;
 914:     }
 915:     if (options & SO_DEBUG &&
 916:         setsockopt(data, SOL_SOCKET, SO_DEBUG, (char *)&on, sizeof (on)) < 0)
 917:         perror("ftp: setsockopt (ignored)");
 918:     len = sizeof (data_addr);
 919:     if (getsockname(data, (char *)&data_addr, &len) < 0) {
 920:         perror("ftp: getsockname");
 921:         goto bad;
 922:     }
 923:     if (listen(data, 1) < 0)
 924:         perror("ftp: listen");
 925:     if (sendport) {
 926:         a = (char *)&data_addr.sin_addr;
 927:         p = (char *)&data_addr.sin_port;
 928: #define UC(b)   (((int)b)&0xff)
 929:         result =
 930:             command("PORT %d,%d,%d,%d,%d,%d",
 931:               UC(a[0]), UC(a[1]), UC(a[2]), UC(a[3]),
 932:               UC(p[0]), UC(p[1]));
 933:         if (result == ERROR && sendport == -1) {
 934:             sendport = 0;
 935:             tmpno = 1;
 936:             goto noport;
 937:         }
 938:         return (result != COMPLETE);
 939:     }
 940:     if (tmpno)
 941:         sendport = 1;
 942:     return (0);
 943: bad:
 944:     (void) close(data), data = -1;
 945:     if (tmpno)
 946:         sendport = 1;
 947:     return (1);
 948: }
 949: 
 950: FILE *
 951: dataconn(mode)
 952:     char *mode;
 953: {
 954:     struct sockaddr_in from;
 955:     int s, fromlen = sizeof (from);
 956: 
 957:     s = accept(data, (struct sockaddr *) &from, &fromlen);
 958:     if (s < 0) {
 959:         perror("ftp: accept");
 960:         (void) close(data), data = -1;
 961:         return (NULL);
 962:     }
 963:     (void) close(data);
 964:     data = s;
 965:     return (fdopen(data, mode));
 966: }
 967: 
 968: ptransfer(direction, bytes, t0, t1, local, remote)
 969:     char *direction, *local, *remote;
 970:     long bytes;
 971:     struct timeval *t0, *t1;
 972: {
 973:     struct timeval td;
 974:     float s, bs;
 975: 
 976:     tvsub(&td, t1, t0);
 977:     s = td.tv_sec + (td.tv_usec / 1000000.);
 978: #define nz(x)   ((x) == 0 ? 1 : (x))
 979:     bs = bytes / nz(s);
 980:     if (local && *local != '-')
 981:         printf("local: %s ", local);
 982:     if (remote)
 983:         printf("remote: %s\n", remote);
 984:     printf("%ld bytes %s in %.2g seconds (%.2g Kbytes/s)\n",
 985:         bytes, direction, s, bs / 1024.);
 986: }
 987: 
 988: /*tvadd(tsum, t0)
 989: 	struct timeval *tsum, *t0;
 990: {
 991: 
 992: 	tsum->tv_sec += t0->tv_sec;
 993: 	tsum->tv_usec += t0->tv_usec;
 994: 	if (tsum->tv_usec > 1000000)
 995: 		tsum->tv_sec++, tsum->tv_usec -= 1000000;
 996: } */
 997: 
 998: tvsub(tdiff, t1, t0)
 999:     struct timeval *tdiff, *t1, *t0;
1000: {
1001: 
1002:     tdiff->tv_sec = t1->tv_sec - t0->tv_sec;
1003:     tdiff->tv_usec = t1->tv_usec - t0->tv_usec;
1004:     if (tdiff->tv_usec < 0)
1005:         tdiff->tv_sec--, tdiff->tv_usec += 1000000;
1006: }
1007: 
1008: psabort()
1009: {
1010:     extern int abrtflag;
1011: 
1012:     abrtflag++;
1013: }
1014: 
1015: pswitch(flag)
1016:     int flag;
1017: {
1018:     extern int proxy, abrtflag;
1019:     int (*oldintr)();
1020:     static struct comvars {
1021:         int connect;
1022:         char name[MAXHOSTNAMELEN];
1023:         struct sockaddr_in mctl;
1024:         struct sockaddr_in hctl;
1025:         FILE *in;
1026:         FILE *out;
1027:         int tpe;
1028:         int cpnd;
1029:         int sunqe;
1030:         int runqe;
1031:         int mcse;
1032:         int ntflg;
1033:         char nti[17];
1034:         char nto[17];
1035:         int mapflg;
1036:         char mi[MAXPATHLEN];
1037:         char mo[MAXPATHLEN];
1038:         } proxstruct, tmpstruct;
1039:     struct comvars *ip, *op;
1040: 
1041:     abrtflag = 0;
1042:     oldintr = signal(SIGINT, psabort);
1043:     if (flag) {
1044:         if (proxy)
1045:             return;
1046:         ip = &tmpstruct;
1047:         op = &proxstruct;
1048:         proxy++;
1049:     }
1050:     else {
1051:         if (!proxy)
1052:             return;
1053:         ip = &proxstruct;
1054:         op = &tmpstruct;
1055:         proxy = 0;
1056:     }
1057:     ip->connect = connected;
1058:     connected = op->connect;
1059:     if (hostname) {
1060:         (void) strncpy(ip->name, hostname, sizeof(ip->name) - 1);
1061:         ip->name[strlen(ip->name)] = '\0';
1062:     } else
1063:         ip->name[0] = 0;
1064:     hostname = op->name;
1065:     ip->hctl = hisctladdr;
1066:     hisctladdr = op->hctl;
1067:     ip->mctl = myctladdr;
1068:     myctladdr = op->mctl;
1069:     ip->in = cin;
1070:     cin = op->in;
1071:     ip->out = cout;
1072:     cout = op->out;
1073:     ip->tpe = type;
1074:     type = op->tpe;
1075:     if (!type)
1076:         type = 1;
1077:     ip->cpnd = cpend;
1078:     cpend = op->cpnd;
1079:     ip->sunqe = sunique;
1080:     sunique = op->sunqe;
1081:     ip->runqe = runique;
1082:     runique = op->runqe;
1083:     ip->mcse = mcase;
1084:     mcase = op->mcse;
1085:     ip->ntflg = ntflag;
1086:     ntflag = op->ntflg;
1087:     (void) strncpy(ip->nti, ntin, 16);
1088:     (ip->nti)[strlen(ip->nti)] = '\0';
1089:     (void) strcpy(ntin, op->nti);
1090:     (void) strncpy(ip->nto, ntout, 16);
1091:     (ip->nto)[strlen(ip->nto)] = '\0';
1092:     (void) strcpy(ntout, op->nto);
1093:     ip->mapflg = mapflag;
1094:     mapflag = op->mapflg;
1095:     (void) strncpy(ip->mi, mapin, MAXPATHLEN - 1);
1096:     (ip->mi)[strlen(ip->mi)] = '\0';
1097:     (void) strcpy(mapin, op->mi);
1098:     (void) strncpy(ip->mo, mapout, MAXPATHLEN - 1);
1099:     (ip->mo)[strlen(ip->mo)] = '\0';
1100:     (void) strcpy(mapout, op->mo);
1101:     (void) signal(SIGINT, oldintr);
1102:     if (abrtflag) {
1103:         abrtflag = 0;
1104:         (*oldintr)();
1105:     }
1106: }
1107: 
1108: jmp_buf ptabort;
1109: int ptabflg;
1110: 
1111: abortpt()
1112: {
1113:     printf("\n");
1114:     (void) fflush(stdout);
1115:     ptabflg++;
1116:     mflag = 0;
1117:     abrtflag = 0;
1118:     longjmp(ptabort, 1);
1119: }
1120: 
1121: proxtrans(cmd, local, remote)
1122:     char *cmd, *local, *remote;
1123: {
1124:     int (*oldintr)(), abortpt(), tmptype, oldtype = 0, secndflag = 0, nfnd;
1125:     extern jmp_buf ptabort;
1126:     char *cmd2;
1127:     struct fd_set mask;
1128: 
1129:     if (strcmp(cmd, "RETR"))
1130:         cmd2 = "RETR";
1131:     else
1132:         cmd2 = runique ? "STOU" : "STOR";
1133:     if (command("PASV") != COMPLETE) {
1134:         printf("proxy server does not support third part transfers.\n");
1135:         return;
1136:     }
1137:     tmptype = type;
1138:     pswitch(0);
1139:     if (!connected) {
1140:         printf("No primary connection\n");
1141:         pswitch(1);
1142:         code = -1;
1143:         return;
1144:     }
1145:     if (type != tmptype) {
1146:         oldtype = type;
1147:         switch (tmptype) {
1148:             case TYPE_A:
1149:                 setascii();
1150:                 break;
1151:             case TYPE_I:
1152:                 setbinary();
1153:                 break;
1154:             case TYPE_E:
1155:                 setebcdic();
1156:                 break;
1157:             case TYPE_L:
1158:                 settenex();
1159:                 break;
1160:         }
1161:     }
1162:     if (command("PORT %s", pasv) != COMPLETE) {
1163:         switch (oldtype) {
1164:             case 0:
1165:                 break;
1166:             case TYPE_A:
1167:                 setascii();
1168:                 break;
1169:             case TYPE_I:
1170:                 setbinary();
1171:                 break;
1172:             case TYPE_E:
1173:                 setebcdic();
1174:                 break;
1175:             case TYPE_L:
1176:                 settenex();
1177:                 break;
1178:         }
1179:         pswitch(1);
1180:         return;
1181:     }
1182:     if (setjmp(ptabort))
1183:         goto abort;
1184:     oldintr = signal(SIGINT, abortpt);
1185:     if (command("%s %s", cmd, remote) != PRELIM) {
1186:         (void) signal(SIGINT, oldintr);
1187:         switch (oldtype) {
1188:             case 0:
1189:                 break;
1190:             case TYPE_A:
1191:                 setascii();
1192:                 break;
1193:             case TYPE_I:
1194:                 setbinary();
1195:                 break;
1196:             case TYPE_E:
1197:                 setebcdic();
1198:                 break;
1199:             case TYPE_L:
1200:                 settenex();
1201:                 break;
1202:         }
1203:         pswitch(1);
1204:         return;
1205:     }
1206:     sleep(2);
1207:     pswitch(1);
1208:     secndflag++;
1209:     if (command("%s %s", cmd2, local) != PRELIM)
1210:         goto abort;
1211:     ptflag++;
1212:     (void) getreply(0);
1213:     pswitch(0);
1214:     (void) getreply(0);
1215:     (void) signal(SIGINT, oldintr);
1216:     switch (oldtype) {
1217:         case 0:
1218:             break;
1219:         case TYPE_A:
1220:             setascii();
1221:             break;
1222:         case TYPE_I:
1223:             setbinary();
1224:             break;
1225:         case TYPE_E:
1226:             setebcdic();
1227:             break;
1228:         case TYPE_L:
1229:             settenex();
1230:             break;
1231:     }
1232:     pswitch(1);
1233:     ptflag = 0;
1234:     printf("local: %s remote: %s\n", local, remote);
1235:     return;
1236: abort:
1237:     (void) signal(SIGINT, SIG_IGN);
1238:     ptflag = 0;
1239:     if (strcmp(cmd, "RETR") && !proxy)
1240:         pswitch(1);
1241:     else if (!strcmp(cmd, "RETR") && proxy)
1242:         pswitch(0);
1243:     if (!cpend && !secndflag) {  /* only here if cmd = "STOR" (proxy=1) */
1244:         if (command("%s %s", cmd2, local) != PRELIM) {
1245:             pswitch(0);
1246:             switch (oldtype) {
1247:                 case 0:
1248:                     break;
1249:                 case TYPE_A:
1250:                     setascii();
1251:                     break;
1252:                 case TYPE_I:
1253:                     setbinary();
1254:                     break;
1255:                 case TYPE_E:
1256:                     setebcdic();
1257:                     break;
1258:                 case TYPE_L:
1259:                     settenex();
1260:                     break;
1261:             }
1262:             if (cpend) {
1263:                 char msg[2];
1264: 
1265:                 fprintf(cout,"%c%c",IAC,IP);
1266:                 (void) fflush(cout);
1267:                 *msg = IAC;
1268:                 *(msg+1) = DM;
1269:                 if (send(fileno(cout),msg,2,MSG_OOB) != 2)
1270:                     perror("abort");
1271:                 fprintf(cout,"ABOR\r\n");
1272:                 (void) fflush(cout);
1273:                 FD_ZERO(&mask);
1274:                 FD_SET(fileno(cin), &mask);
1275:                 if ((nfnd = empty(&mask,10)) <= 0) {
1276:                     if (nfnd < 0) {
1277:                         perror("abort");
1278:                     }
1279:                     if (ptabflg)
1280:                         code = -1;
1281:                     lostpeer();
1282:                 }
1283:                 (void) getreply(0);
1284:                 (void) getreply(0);
1285:             }
1286:         }
1287:         pswitch(1);
1288:         if (ptabflg)
1289:             code = -1;
1290:         (void) signal(SIGINT, oldintr);
1291:         return;
1292:     }
1293:     if (cpend) {
1294:         char msg[2];
1295: 
1296:         fprintf(cout,"%c%c",IAC,IP);
1297:         (void) fflush(cout);
1298:         *msg = IAC;
1299:         *(msg+1) = DM;
1300:         if (send(fileno(cout),msg,2,MSG_OOB) != 2)
1301:             perror("abort");
1302:         fprintf(cout,"ABOR\r\n");
1303:         (void) fflush(cout);
1304:         FD_ZERO(&mask);
1305:         FD_SET(fileno(cin), &mask);
1306:         if ((nfnd = empty(&mask,10)) <= 0) {
1307:             if (nfnd < 0) {
1308:                 perror("abort");
1309:             }
1310:             if (ptabflg)
1311:                 code = -1;
1312:             lostpeer();
1313:         }
1314:         (void) getreply(0);
1315:         (void) getreply(0);
1316:     }
1317:     pswitch(!proxy);
1318:     if (!cpend && !secndflag) {  /* only if cmd = "RETR" (proxy=1) */
1319:         if (command("%s %s", cmd2, local) != PRELIM) {
1320:             pswitch(0);
1321:             switch (oldtype) {
1322:                 case 0:
1323:                     break;
1324:                 case TYPE_A:
1325:                     setascii();
1326:                     break;
1327:                 case TYPE_I:
1328:                     setbinary();
1329:                     break;
1330:                 case TYPE_E:
1331:                     setebcdic();
1332:                     break;
1333:                 case TYPE_L:
1334:                     settenex();
1335:                     break;
1336:             }
1337:             if (cpend) {
1338:                 char msg[2];
1339: 
1340:                 fprintf(cout,"%c%c",IAC,IP);
1341:                 (void) fflush(cout);
1342:                 *msg = IAC;
1343:                 *(msg+1) = DM;
1344:                 if (send(fileno(cout),msg,2,MSG_OOB) != 2)
1345:                     perror("abort");
1346:                 fprintf(cout,"ABOR\r\n");
1347:                 (void) fflush(cout);
1348:                 FD_ZERO(&mask);
1349:                 FD_SET(fileno(cin), &mask);
1350:                 if ((nfnd = empty(&mask,10)) <= 0) {
1351:                     if (nfnd < 0) {
1352:                         perror("abort");
1353:                     }
1354:                     if (ptabflg)
1355:                         code = -1;
1356:                     lostpeer();
1357:                 }
1358:                 (void) getreply(0);
1359:                 (void) getreply(0);
1360:             }
1361:             pswitch(1);
1362:             if (ptabflg)
1363:                 code = -1;
1364:             (void) signal(SIGINT, oldintr);
1365:             return;
1366:         }
1367:     }
1368:     if (cpend) {
1369:         char msg[2];
1370: 
1371:         fprintf(cout,"%c%c",IAC,IP);
1372:         (void) fflush(cout);
1373:         *msg = IAC;
1374:         *(msg+1) = DM;
1375:         if (send(fileno(cout),msg,2,MSG_OOB) != 2)
1376:             perror("abort");
1377:         fprintf(cout,"ABOR\r\n");
1378:         (void) fflush(cout);
1379:         FD_ZERO(&mask);
1380:         FD_SET(fileno(cin), &mask);
1381:         if ((nfnd = empty(&mask,10)) <= 0) {
1382:             if (nfnd < 0) {
1383:                 perror("abort");
1384:             }
1385:             if (ptabflg)
1386:                 code = -1;
1387:             lostpeer();
1388:         }
1389:         (void) getreply(0);
1390:         (void) getreply(0);
1391:     }
1392:     pswitch(!proxy);
1393:     if (cpend) {
1394:         FD_ZERO(&mask);
1395:         FD_SET(fileno(cin), &mask);
1396:         if ((nfnd = empty(&mask,10)) <= 0) {
1397:             if (nfnd < 0) {
1398:                 perror("abort");
1399:             }
1400:             if (ptabflg)
1401:                 code = -1;
1402:             lostpeer();
1403:         }
1404:         (void) getreply(0);
1405:         (void) getreply(0);
1406:     }
1407:     if (proxy)
1408:         pswitch(0);
1409:     switch (oldtype) {
1410:         case 0:
1411:             break;
1412:         case TYPE_A:
1413:             setascii();
1414:             break;
1415:         case TYPE_I:
1416:             setbinary();
1417:             break;
1418:         case TYPE_E:
1419:             setebcdic();
1420:             break;
1421:         case TYPE_L:
1422:             settenex();
1423:             break;
1424:     }
1425:     pswitch(1);
1426:     if (ptabflg)
1427:         code = -1;
1428:     (void) signal(SIGINT, oldintr);
1429: }
1430: 
1431: reset()
1432: {
1433:     struct fd_set mask;
1434:     int nfnd = 1;
1435: 
1436:     FD_ZERO(&mask);
1437:     while (nfnd) {
1438:         FD_SET(fileno(cin), &mask);
1439:         if ((nfnd = empty(&mask,0)) < 0) {
1440:             perror("reset");
1441:             code = -1;
1442:             lostpeer();
1443:         }
1444:         else if (nfnd) {
1445:             (void) getreply(0);
1446:         }
1447:     }
1448: }
1449: 
1450: char *
1451: gunique(local)
1452:     char *local;
1453: {
1454:     static char new[MAXPATHLEN];
1455:     char *cp = rindex(local, '/');
1456:     int d, count=0;
1457:     char ext = '1';
1458: 
1459:     if (cp)
1460:         *cp = '\0';
1461:     d = access(cp ? local : ".", 2);
1462:     if (cp)
1463:         *cp = '/';
1464:     if (d < 0) {
1465:         perror(local);
1466:         return((char *) 0);
1467:     }
1468:     (void) strcpy(new, local);
1469:     cp = new + strlen(new);
1470:     *cp++ = '.';
1471:     while (!d) {
1472:         if (++count == 100) {
1473:             printf("runique: can't find unique file name.\n");
1474:             return((char *) 0);
1475:         }
1476:         *cp++ = ext;
1477:         *cp = '\0';
1478:         if (ext == '9')
1479:             ext = '0';
1480:         else
1481:             ext++;
1482:         if ((d = access(new, 0)) < 0)
1483:             break;
1484:         if (ext != '0')
1485:             cp--;
1486:         else if (*(cp - 2) == '.')
1487:             *(cp - 1) = '1';
1488:         else {
1489:             *(cp - 2) = *(cp - 2) + 1;
1490:             cp--;
1491:         }
1492:     }
1493:     return(new);
1494: }

Defined functions

abortpt defined in line 1111; used 2 times
abortrecv defined in line 551; used 2 times
abortsend defined in line 359; used 2 times
cmdabort defined in line 207; used 5 times
command defined in line 219; used 34 times
dataconn defined in line 950; used 3 times
empty defined in line 346; used 7 times
getreply defined in line 250; used 24 times
gunique defined in line 1450; used 3 times
hookup defined in line 42; used 2 times
initconn defined in line 887; used 2 times
login defined in line 147; used 1 times
proxtrans defined in line 1121; used 2 times
psabort defined in line 1008; used 1 times
pswitch defined in line 1015; used 29 times
ptransfer defined in line 968; used 4 times
recvrequest defined in line 561; used 5 times
reset defined in line 1431; used 2 times
sendrequest defined in line 369; used 4 times
tvsub defined in line 998; used 1 times

Defined variables

abrtflag defined in line 33; used 13 times
connected defined in line 35; used 3 times
data defined in line 32; used 32 times
data_addr defined in line 31; used 8 times
hisctladdr defined in line 30; used 17 times
myctladdr defined in line 36; used 5 times
ptabflg defined in line 1109; used 9 times
ptabort defined in line 1108; used 5 times
ptflag defined in line 34; used 4 times
recvabort defined in line 549; used 3 times
sccsid defined in line 8; never used
sendabort defined in line 357; used 3 times
sendport defined in line 885; used 8 times

Defined struct's

comvars defined in line 1020; used 2 times

Defined macros

UC defined in line 928; used 6 times
nz defined in line 978; used 1 times
Last modified: 1986-05-23
Generated: 2016-12-26
Generated by src2html V0.67
page hit count: 3356
Valid CSS Valid XHTML 1.0 Strict