开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 代理服务器 > 查看源码
ftp.c
资源名称：socks5.zip　[点击查看]
上传用户：sddyfurun
上传日期：2007-01-04
资源大小：525k
文件大小：35k
源码类别：

代理服务器

开发平台：

Unix_Linux

ftp.c：源码内容
  1. /* Copyright (c) 1985, 1989 Regents of the University of California.  All    */
  2. /* rights reserved.                                                          */
  3. /*                                                                           */
  4. /* Redistribution and use in source and binary forms, with or without        */
  5. /* modification, are permitted provided that the following conditions are    */
  6. /* met: 1. Redistributions of source code must retain the above copyright    */
  7. /*    notice, this list of conditions and the following disclaimer.          */
  8. /* 2. Redistributions in binary form must reproduce the above copyright      */
  9. /*    notice, this list of conditions and the following disclaimer in the    */
  10. /*    documentation and/or other materials provided with the distribution.   */
  11. /* 3. All advertising materials mentioning features or use of this software  */
  12. /*    must display the following acknowledgement:                            */
  13. /*  This product includes software developed by the University of        */
  14. /*  California, Berkeley and its contributors.  4. Neither the name      */
  15. /* of the University nor the names of its contributors                       */
  16. /*    may be used to endorse or promote products derived from this software  */
  17. /*    without specific prior written permission.                             */
  18. /*                                                                           */
  19. /* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND   */
  20. /* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE     */
  21. /* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR        */
  22. /* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE */
  23. /* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR       */
  24. /* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF      */
  25. /* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS  */
  26. /* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN   */
  27. /* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)   */
  28. /* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF    */
  29. /* THE POSSIBILITY OF SUCH DAMAGE.                                           */
  31. #include "ftp_var.h"
  33. #define DONT_NEED_SIGBLOCK
  34. #define DONT_NEED_SIGPAUSE
  35. #define DONT_NEED_SIGUNBLOCK
  36. #define DONT_NEED_SIGPENDING
  37. #include "sigfix.h"
  39. #ifdef HAVE_SYS_IOCTL_H
  40. #include <sys/ioctl.h>
  41. #endif
  43. #include <netinet/ip.h>
  44. #include <arpa/ftp.h>
  45. #include <arpa/telnet.h>
  47. #ifdef HAVE_FCNTL_H
  48. #include <fcntl.h>
  49. #endif
  51. #include <varargs.h>
  53. #ifdef FASCIST
  54. #include <syslog.h>
  55. #endif
  57. #ifdef HAVE_BSTRING_H
  58. #include <bstring.h>
  59. #endif
  61. #ifndef HAVE_BCOPY
  62. #define bcopy(b1,b2,len) memmove(b2, b1, (size_t)(len))
  63. #endif
  65. #ifndef HAVE_BZERO
  66. #define bzero(b,len)     memset(b, 0, (size_t)(len))
  67. #endif
  69. #ifndef HAVE_BCMP
  70. #define bcmp(b1,b2,len)  memcmp(b1, b2, (size_t)(len))
  71. #endif
  73. sig_t lostpeer();
  75. struct sockaddr_in hisctladdr;
  76. struct sockaddr_in data_addr;
  77. struct sockaddr_in myctladdr;
  78. int data = -1;
  79. int abrtflag = 0;
  80. int ptflag = 0;
  81. off_t restart_point = 0;
  82. unsigned long socks_bind_remoteAddr; /* Socks */
  84. extern int connected, errno;
  86. FILE *cin, *cout;
  87. FILE *dataconn();
  89. jmp_buf ptabort;
  90. int ptabflg;
  92. #ifndef HAVE_HERROR
  93. char *h_errlist[] = {
  94.     "Error 0",
  95.     "Unknown host", /* 1 HOST_NOT_FOUND */
  96.     "Host name lookup failure", /* 2 TRY_AGAIN */
  97.     "Unknown server error", /* 3 NO_RECOVERY */
  98.     "No address associated with name", /* 4 NO_ADDRESS */
  99. };
  101. int h_nerr = { sizeof(h_errlist)/sizeof(h_errlist[0]) };
  102. int h_errno;
  104. /* herror --                                                                 */
  105. /* print the error indicated by the h_errno value.                           */
  106. /*                                                                           */
  107. void herror(const char *s) {
  108.     if (s && *s) {
  109. fprintf(stderr, "%s: ", s);
  110.     }
  111.     if ((h_errno < 0) || (h_errno >= h_nerr)) {
  112. fprintf(stderr, "Unknown errorn");
  113.     } else if (h_errno == 0) {
  114. #ifdef sun
  115. fprintf(stderr, "Host unknownn");
  116. #endif
  117.     } else {
  118. fprintf(stderr, "%sn", h_errlist[h_errno]);
  119.     }
  120. }
  121. #endif
  123. char *hookup(char *host, int port) {
  124.     register struct hostent *hp = 0;
  125.     static char hostnamebuf[80];
  126.     int s, len, tos;
  128.     bzero((char *)&hisctladdr, sizeof (hisctladdr));
  129.     hisctladdr.sin_addr.s_addr = inet_addr(host);
  131.     if (hisctladdr.sin_addr.s_addr != -1) {
  132. hisctladdr.sin_family = AF_INET;
  133. strncpy(hostnamebuf, host, sizeof(hostnamebuf));
  134.     } else {
  135. if ((hp = gethostbyname(host)) == NULL) {
  136.     fprintf(stderr, "ftp: %s: ", host);
  137.     herror(NULL);
  138.     code = -1;
  139.     return NULL;
  140. }
  142. hisctladdr.sin_family = hp->h_addrtype;
  143. bcopy(hp->h_addr_list[0], (caddr_t)&hisctladdr.sin_addr, hp->h_length);
  144. strncpy(hostnamebuf, hp->h_name, sizeof(hostnamebuf));
  145.     }
  147.     hostname = hostnamebuf;
  148.     
  149.     if ((s = socket(hisctladdr.sin_family, SOCK_STREAM, 0)) < 0) {
  150. perror("ftp: socket");
  151. code = -1;
  152. return NULL;
  153.     }
  155.     hisctladdr.sin_port = port;
  157.     while (connect(s, (struct sockaddr *)&hisctladdr, sizeof (hisctladdr)) < 0) {
  158. if (hp && hp->h_addr_list[1]) {
  159.     int oerrno = errno;
  161.     fprintf(stderr, "ftp: connect to address %s: ", inet_ntoa(hisctladdr.sin_addr));
  162.     errno = oerrno;
  163.     perror(NULL);
  164.     hp->h_addr_list++;
  165.     bcopy(hp->h_addr_list[0], (caddr_t)&hisctladdr.sin_addr, hp->h_length);
  167.     fprintf(stdout, "Trying %s...n", inet_ntoa(hisctladdr.sin_addr));
  168.     close(s);
  170.     if ((s = socket(hisctladdr.sin_family, SOCK_STREAM, 0)) < 0) {
  171. perror("ftp: socket");
  172. code = -1;
  173. return NULL;
  174.     }
  176.     continue;
  177. }
  179. perror("ftp: connect");
  180. code = -1;
  181. goto bad;
  182.     }
  184.     socks_bind_remoteAddr = hisctladdr.sin_addr.s_addr;  /* Socks */
  185.     len = sizeof (myctladdr);
  187.     if (getsockname(s, (struct sockaddr *)&myctladdr, &len) < 0) {
  188. perror("ftp: getsockname");
  189. code = -1;
  190. goto bad;
  191.     }
  193. #if defined(IP_TOS) && defined(IPTOS_LOWDELAY)
  194.     tos = IPTOS_LOWDELAY;
  195.     if (setsockopt(s, IPPROTO_IP, IP_TOS, (char *)&tos, sizeof(int)) < 0)
  196. perror("ftp: setsockopt TOS (ignored)");
  197. #endif
  199.     cin  = fdopen(s, "r");
  200.     cout = fdopen(dup(s), "w"); /* when (if ever) do we need the dup ? */
  201.     if (cin == NULL || cout == NULL) {
  202. fprintf(stderr, "ftp: fdopen failed.n");
  203. if (cin)  fclose(cin);
  204. if (cout) fclose(cout);
  205. code = -1;
  206. goto bad;
  207.     }
  208.     
  209.     if (verbose) printf("Connected to %s.n", hostname);
  210.     if (getreply(0) > 2) {  /* read startup message from server */
  211. if (cin)  fclose(cin);
  212. if (cout) fclose(cout);
  213. code = -1;
  214. goto bad;
  215.     }
  216. #ifdef SO_OOBINLINE
  217.     {
  218. int on = 1;
  219.     
  220. if (setsockopt(s, SOL_SOCKET, SO_OOBINLINE, (char *)&on, sizeof(on)) < 0 && debug) {
  221.     perror("ftp: setsockopt");
  222. }
  223.     }
  224. #endif
  226.     return (hostname);
  227. bad:
  228.     close(s);
  229.     return NULL;
  230. }
  232. void cmdabort() {
  233.     extern jmp_buf ptabort;
  234.     
  235.     printf("n");
  236.     fflush(stdout);
  237.     abrtflag++;
  239.     if (!ptflag) return;
  240.     longjmp(ptabort,1);
  241. }
  243. /*VARARGS*/
  244. int command(va_alist) va_dcl {
  245.     va_list ap;
  246.     char *fmt;
  247.     int r;
  248.     sig_t oldintr;
  249.     
  250.     abrtflag = 0;
  251.     if (debug) {
  252. printf("---> ");
  254. va_start(ap);
  255. fmt = va_arg(ap, char *);
  256. if (strncmp("PASS ", fmt, 5) == 0)
  257.     printf("PASS XXXX");
  258. else 
  259.     vfprintf(stdout, fmt, ap);
  260. va_end(ap);
  262. printf("n");
  263. fflush(stdout);
  264.     }
  266.     if (cout == NULL) {
  267. perror ("No control connection for command");
  268. code = -1;
  269. return (0);
  270.     }
  272.     oldintr = (sig_t)Signal(SIGINT, cmdabort);
  274.     va_start(ap);
  275.     fmt = va_arg(ap, char *);
  276.     vfprintf(cout, fmt, ap);
  277.     va_end(ap);
  279.     fprintf(cout, "rn");
  280.     fflush(cout);
  282.     cpend = 1;
  283.     r = getreply(!strcmp(fmt, "QUIT"));
  285.     if (abrtflag && oldintr != SIG_IGN) (*oldintr)(SIGINT);
  286.     Signal(SIGINT, oldintr);
  287.     return(r);
  288. }
  290. int login(char *host) {
  291.     char tmp[80];
  292.     char *user, *pass, *acct, *getlogin(), *getpass();
  293.     int n, aflag = 0;
  295.     user = pass = acct = 0;
  296.     if (ruserpass(host, &user, &pass, &acct) < 0) {
  297. code = -1;
  298. return(0);
  299.     }
  300.     while (user == NULL) {
  301. char *myname = getlogin();
  303. if (myname == NULL) {
  304.     struct passwd *pp = getpwuid(getuid());
  306.     if (pp != NULL)
  307. myname = pp->pw_name;
  308. }
  309. if (myname)
  310.     printf("Name (%s:%s): ", host, myname);
  311. else
  312.     printf("Name (%s): ", host);
  313. fgets(tmp, sizeof(tmp) - 1, stdin);
  314. tmp[strlen(tmp) - 1] = '';
  315. if (*tmp == '')
  316.     user = myname;
  317. else
  318.     user = tmp;
  319.     }
  320.     n = command("USER %s", user);
  321.     if (n == CONTINUE) {
  322. if (pass == NULL) {
  323.     if (!strcmp(user, "anonymous") || !strcmp(user, "ftp")) {
  324. printf("Password: "); fflush(stdout);
  325. fgets(tmp, sizeof(tmp) - 1, stdin);
  326. tmp[strlen(tmp) - 1] = '';
  327. pass = tmp;
  328.     } else
  329. pass = getpass("Password:");
  330. }
  331. n = command("PASS %s", pass);
  332.     }
  333.     if (n == CONTINUE) {
  334. aflag++;
  335. acct = getpass("Account:");
  336. n = command("ACCT %s", acct);
  337.     }
  338.     if (n != COMPLETE) {
  339. fprintf(stderr, "Login failed.n");
  340. return (0);
  341.     }
  342.     if (!aflag && acct != NULL)
  343. command("ACCT %s", acct);
  344.     if (proxy)
  345. return(1);
  346.     for (n = 0; n < macnum; ++n) {
  347. if (!strcmp("init", macros[n].mac_name)) {
  348.     strcpy(line, "$init");
  349.     makeargv();
  350.     domacro(margc, margv);
  351.     break;
  352. }
  353.     }
  354.     return (1);
  355. }
  357. char reply_string[BUFSIZ]; /* last line of previous reply */
  359. #include <ctype.h>
  361. int getreply(int expecteof) {
  362.     register int c, n;
  363.     register int dig;
  364.     register char *cp;
  365.     int originalcode = 0, continuation = 0;
  366.     sig_t oldintr;
  367.     int pflag = 0;
  368.     char *pt = pasv;
  369.     void cmdabort();
  371.     oldintr = (sig_t)Signal(SIGINT, cmdabort);
  372.     for (;;) {
  373. dig = n = code = 0;
  374. cp = reply_string;
  375. while ((c = getc(cin)) != 'n') {
  376.     if (c == IAC) {     /* handle telnet commands */
  377. switch (c = getc(cin)) {
  378.     case WILL:
  379.     case WONT:
  380. c = getc(cin);
  381. fprintf(cout, "%c%c%c", IAC, DONT, c);
  382. fflush(cout);
  383. break;
  384.     case DO:
  385.     case DONT:
  386. c = getc(cin);
  387. fprintf(cout, "%c%c%c", IAC, WONT, c);
  388. fflush(cout);
  389. break;
  390.     default:
  391. break;
  392. }
  393. continue;
  394.     }
  395.     dig++;
  396.     if (c == EOF) {
  397. if (expecteof) {
  398.     Signal(SIGINT,oldintr);
  399.     code = 221;
  400.     return (0);
  401. }
  402. lostpeer();
  403. if (verbose) {
  404.     printf("421 Service not available, remote server has closed connectionn");
  405.     fflush(stdout);
  406. }
  407. code = 421;
  408. return(4);
  409.     }
  410.     if (c != 'r' && (verbose > 0 ||
  411.       (verbose > -1 && n == '5' && dig > 4))) {
  412. if (proxflag && (dig == 1 || (dig == 5 && verbose == 0)))
  413.     printf("%s:",hostname);
  414. putchar(c);
  415.     }
  416.     if (dig < 4 && isdigit(c))
  417. code = code * 10 + (c - '0');
  418.     if (!pflag && code == 227)
  419. pflag = 1;
  420.     if (dig > 4 && pflag == 1 && isdigit(c))
  421. pflag = 2;
  422.     if (pflag == 2) {
  423. if (c != 'r' && c != ')')
  424.     *pt++ = c;
  425. else {
  426.     *pt = '';
  427.     pflag = 3;
  428. }
  429.     }
  430.     if (dig == 4 && c == '-') {
  431. if (continuation) code = 0;
  432. continuation++;
  433.     }
  434.     if (n == 0)
  435. n = c;
  436.     if (cp < &reply_string[sizeof(reply_string) - 1])
  437. *cp++ = c;
  438. }
  439. if (verbose > 0 || (verbose > -1 && n == '5')) {
  440.     putchar(c);
  441.     fflush(stdout);
  442. }
  443. if (continuation && code != originalcode) {
  444.     if (originalcode == 0) originalcode = code;
  445.     continue;
  446. }
  447. *cp = '';
  448. if (n != '1')
  449.     cpend = 0;
  450. Signal(SIGINT,oldintr);
  451. if (code == 421 || originalcode == 421)
  452.     lostpeer();
  453. if (abrtflag && oldintr != cmdabort && oldintr != SIG_IGN)
  454.     (*oldintr)(SIGINT);
  455. return (n - '0');
  456.     }
  457. }
  459. int empty(fd_set *mask, int sec) {
  460.     struct timeval t;
  461.     
  462.     t.tv_sec = (long) sec;
  463.     t.tv_usec = 0;
  464.     return(select(32, mask, NULL, NULL, &t));
  465. }
  467. jmp_buf sendabort;
  469. void abortsend() {
  471.     mflag = 0;
  472.     abrtflag = 0;
  473.     printf("nsend abortednwaiting for remote to finish abortn");
  474.     fflush(stdout);
  475.     longjmp(sendabort, 1);
  476. }
  478. #define HASHBYTES 1024
  480. void tvsub(struct timeval *tdiff, struct timeval *t1, struct timeval *t0) {
  481.     tdiff->tv_sec = t1->tv_sec - t0->tv_sec;
  482.     tdiff->tv_usec = t1->tv_usec - t0->tv_usec;
  483.     
  484.     if (tdiff->tv_usec < 0) tdiff->tv_sec--, tdiff->tv_usec += 1000000;
  485. }
  487. void ptransfer(char *direction, long bytes, struct timeval *t0, struct timeval *t1) {
  488.     struct timeval td;
  489.     float s, bs;
  490.     
  491.     if (verbose) {
  492. tvsub(&td, t1, t0);
  493. s = td.tv_sec + (td.tv_usec / 1000000.);
  494. #define nz(x) ((x) ? (x) : 1)
  495. bs = bytes / nz(s);
  496. printf("%ld bytes %s in %.2g seconds (%.2g Kbytes/s)n",
  497.        bytes, direction, s, bs / 1024.);
  498.     }
  499. }
  501. void abort_remote(FILE *din) {
  502.     char buf[BUFSIZ];
  503.     int nfnd;
  504.     fd_set mask;
  506.     /*
  507.      * send IAC in urgent mode instead of DM because 4.3BSD places oob mark
  508.      * after urgent byte rather than before as is protocol now
  509.      */
  510.     sprintf(buf, "%c%c%c", IAC, IP, IAC);
  511.     if (send(fileno(cout), buf, 3, MSG_OOB) != 3)
  512. perror("abort");
  513.     fprintf(cout,"%cABORrn", DM);
  514.     fflush(cout);
  515.     FD_ZERO(&mask);
  516.     FD_SET(fileno(cin), &mask);
  517.     if (din) { 
  518. FD_SET(fileno(din), &mask);
  519.     }
  520.     if ((nfnd = empty(&mask, 10)) <= 0) {
  521. if (nfnd < 0) {
  522.     perror("abort");
  523. }
  524. if (ptabflg)
  525.     code = -1;
  526. lostpeer();
  527.     }
  528.     if (din && FD_ISSET(fileno(din), &mask)) {
  529. while (read(fileno(din), buf, BUFSIZ) > 0)
  530.     /* LOOP */;
  531.     }
  532.     if (getreply(0) == ERROR && code == 552) {
  533. /* 552 needed for nic style abort */
  534. getreply(0);
  535.     }
  536.     getreply(0);
  537. }
  539. void proxtrans(char *cmd, char *local, char *remote) {
  540.     sig_t oldintr;
  541.     int secndflag = 0, prox_type, nfnd;
  542.     extern jmp_buf ptabort;
  543.     char *cmd2;
  544.     fd_set mask;
  545.     void abortpt();
  547.     if (strcmp(cmd, "RETR"))
  548. cmd2 = "RETR";
  549.     else
  550. cmd2 = runique ? "STOU" : "STOR";
  551.     if ((prox_type = type) == 0) {
  552. if (unix_server && unix_proxy)
  553.     prox_type = TYPE_I;
  554. else
  555.     prox_type = TYPE_A;
  556.     }
  557.     if (curtype != prox_type) changetype(prox_type, 1);
  558.     if (command("PASV") != COMPLETE) {
  559. printf("proxy server does not support third party transfers.n");
  560. return;
  561.     }
  562.     pswitch(0);
  563.     if (!connected) {
  564. printf("No primary connectionn");
  565. pswitch(1);
  566. code = -1;
  567. return;
  568.     }
  569.     if (curtype != prox_type) changetype(prox_type, 1);
  570.     if (command("PORT %s", pasv) != COMPLETE) {
  571. pswitch(1);
  572. return;
  573.     }
  574.     if (setjmp(ptabort)) goto abort;
  575.     oldintr = (sig_t)Signal(SIGINT, abortpt);
  576.     if (command("%s %s", cmd, remote) != PRELIM) {
  577. Signal(SIGINT, oldintr);
  578. pswitch(1);
  579. return;
  580.     }
  581.     sleep(2);
  582.     pswitch(1);
  583.     secndflag++;
  584.     if (command("%s %s", cmd2, local) != PRELIM)
  585. goto abort;
  586.     ptflag++;
  587.     getreply(0);
  588.     pswitch(0);
  589.     getreply(0);
  590.     Signal(SIGINT, oldintr);
  591.     pswitch(1);
  592.     ptflag = 0;
  593.     printf("local: %s remote: %sn", local, remote);
  594.     return;
  595. abort:
  596.     Signal(SIGINT, SIG_IGN);
  597.     ptflag = 0;
  598.     if (strcmp(cmd, "RETR") && !proxy) pswitch(1);
  599.     else if (!strcmp(cmd, "RETR") && proxy) pswitch(0);
  600.     if (!cpend && !secndflag) {  /* only here if cmd = "STOR" (proxy=1) */
  601. if (command("%s %s", cmd2, local) != PRELIM) {
  602.     pswitch(0);
  603.     if (cpend) abort_remote((FILE *) NULL);
  604. }
  605. pswitch(1);
  606. if (ptabflg) code = -1;
  607. Signal(SIGINT, oldintr);
  608. return;
  609.     }
  610.     if (cpend)
  611. abort_remote((FILE *) NULL);
  612.     pswitch(!proxy);
  613.     if (!cpend && !secndflag) {  /* only if cmd = "RETR" (proxy=1) */
  614. if (command("%s %s", cmd2, local) != PRELIM) {
  615.     pswitch(0);
  616.     if (cpend) abort_remote((FILE *) NULL);
  617.     pswitch(1);
  618.     if (ptabflg) code = -1;
  619.     Signal(SIGINT, oldintr);
  620.     return;
  621. }
  622.     }
  623.     if (cpend) abort_remote((FILE *) NULL);
  624.     pswitch(!proxy);
  625.     if (cpend) {
  626. FD_ZERO(&mask);
  627. FD_SET(fileno(cin), &mask);
  628. if ((nfnd = empty(&mask, 10)) <= 0) {
  629.     if (nfnd < 0) perror("abort");
  630.     if (ptabflg) code = -1;
  631.     lostpeer();
  632. }
  633. getreply(0);
  634. getreply(0);
  635.     }
  636.     if (proxy) pswitch(0);
  637.     pswitch(1);
  638.     if (ptabflg) code = -1;
  639.     Signal(SIGINT, oldintr);
  640. }
  642. /*
  643.  * Need to start a listen on the data channel before we send the command,
  644.  * otherwise the server's connect may fail.
  645.  */
  646. int initconn() {
  647.     register char *p, *a;
  648.     int result, len, tmpno = 0;
  649.     int on = 1;
  651. noport:
  652.     data_addr = myctladdr;
  653.     if (sendport)
  654. data_addr.sin_port = 0; /* let system pick one */ 
  655.     if (data != -1)
  656. close(data);
  657.     data = socket(AF_INET, SOCK_STREAM, 0);
  658.     if (data < 0) {
  659. perror("ftp: socket");
  660. if (tmpno)
  661.     sendport = 1;
  662. return (1);
  663.     }
  664.     if (!sendport)
  665. if (setsockopt(data, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof (on)) < 0) {
  666.     perror("ftp: setsockopt (reuse address)");
  667.     goto bad;
  668. }
  669.     if (bind(data, (struct sockaddr *)&data_addr, sizeof(data_addr)) < 0) {
  670. perror("ftp: bind");
  671. goto bad;
  672.     }
  673.     if (options & SO_DEBUG &&
  674. setsockopt(data, SOL_SOCKET, SO_DEBUG, (char *)&on, sizeof (on)) < 0)
  675. perror("ftp: setsockopt (ignored)");
  676.     len = sizeof (data_addr);
  677.     if (getsockname(data, (struct sockaddr *)&data_addr, &len) < 0) {
  678. perror("ftp: getsockname");
  679. goto bad;
  680.     }
  681.     if (listen(data, 1) < 0)
  682. perror("ftp: listen");
  683.     if (sendport) {
  684. a = (char *)&data_addr.sin_addr;
  685. p = (char *)&data_addr.sin_port;
  686. #define UC(b) (((int)b)&0xff)
  687. result =
  688.     command("PORT %d,%d,%d,%d,%d,%d",
  689.     UC(a[0]), UC(a[1]), UC(a[2]), UC(a[3]),
  690.     UC(p[0]), UC(p[1]));
  691. if (result == ERROR && sendport == -1) {
  692.     sendport = 0;
  693.     tmpno = 1;
  694.     goto noport;
  695. }
  696. return (result != COMPLETE);
  697.     }
  698.     if (tmpno)
  699. sendport = 1;
  700. #if defined(IP_TOS) && defined(IPTOS_THROUGHPUT)
  701.     on = IPTOS_THROUGHPUT;
  702.     if (setsockopt(data, IPPROTO_IP, IP_TOS, (char *)&on, sizeof(int)) < 0)
  703. perror("ftp: setsockopt TOS (ignored)");
  704. #endif
  705.     return (0);
  706. bad:
  707.     close(data), data = -1;
  708.     if (tmpno)
  709. sendport = 1;
  710.     return (1);
  711. }
  713. void sendrequest(char *cmd, char *local, char *remote, int printnames) {
  714.     struct stat st;
  715.     struct timeval start, stop;
  716.     register int c, d;
  717.     FILE *fin, *dout = 0, *popen();
  718.     int (*closefunc)(), pclose(), fclose();
  719.     sig_t oldintr, oldintp;
  720.     long bytes = 0, hashbytes = HASHBYTES;
  721.     char *lmode, buf[BUFSIZ], *bufp;
  722.     void abortsend();
  724.     if (verbose && printnames) {
  725. if (local && *local != '-')
  726.     printf("local: %s ", local);
  727. if (remote)
  728.     printf("remote: %sn", remote);
  729.     }
  730.     if (proxy) {
  731. proxtrans(cmd, local, remote);
  732. return;
  733.     }
  734.     if (curtype != type)
  735. changetype(type, 0);
  736.     closefunc = NULL;
  737.     oldintr = NULL;
  738.     oldintp = NULL;
  739.     lmode = "w";
  740.     if (setjmp(sendabort)) {
  741. while (cpend) {
  742.     getreply(0);
  743. }
  744. if (data >= 0) {
  745.     close(data);
  746.     data = -1;
  747. }
  748. if (oldintr)
  749.     Signal(SIGINT,oldintr);
  750. if (oldintp)
  751.     Signal(SIGPIPE,oldintp);
  752. code = -1;
  753. return;
  754.     }
  755.     oldintr = (sig_t)Signal(SIGINT, abortsend);
  756.     if (strcmp(local, "-") == 0)
  757. fin = stdin;
  758.     else if (*local == '|') {
  759. oldintp = (sig_t)Signal(SIGPIPE,SIG_IGN);
  760. fin = popen(local + 1, "r");
  761. if (fin == NULL) {
  762.     perror(local + 1);
  763.     Signal(SIGINT, oldintr);
  764.     Signal(SIGPIPE, oldintp);
  765.     code = -1;
  766.     return;
  767. }
  768. closefunc = pclose;
  769.     } else {
  770. fin = fopen(local, "r");
  771. if (fin == NULL) {
  772.     fprintf(stderr, "local: %s: %sn", local,
  773.     strerror(errno));
  774.     Signal(SIGINT, oldintr);
  775.     code = -1;
  776.     return;
  777. }
  778. closefunc = fclose;
  779. if (fstat(fileno(fin), &st) < 0 ||
  780.     (st.st_mode&S_IFMT) != S_IFREG) {
  781.     fprintf(stdout, "%s: not a plain file.n", local);
  782.     Signal(SIGINT, oldintr);
  783.     fclose(fin);
  784.     code = -1;
  785.     return;
  786. }
  787.     }
  788.     if (initconn()) {
  789. Signal(SIGINT, oldintr);
  790. if (oldintp)
  791.     Signal(SIGPIPE, oldintp);
  792. code = -1;
  793. if (closefunc != NULL)
  794.     (*closefunc)(fin);
  795. return;
  796.     }
  797.     if (setjmp(sendabort))
  798. goto abort;
  800.     if (restart_point &&
  801. (strcmp(cmd, "STOR") == 0 || strcmp(cmd, "APPE") == 0)) {
  802. if (fseek(fin, (long) restart_point, 0) < 0) {
  803.     fprintf(stderr, "local: %s: %sn", local,
  804.     strerror(errno));
  805.     restart_point = 0;
  806.     if (closefunc != NULL)
  807. (*closefunc)(fin);
  808.     return;
  809. }
  810. if (command("REST %ld", (long) restart_point)
  811.     != CONTINUE) {
  812.     restart_point = 0;
  813.     if (closefunc != NULL)
  814. (*closefunc)(fin);
  815.     return;
  816. }
  817. restart_point = 0;
  818. lmode = "r+w";
  819.     }
  820.     if (remote) {
  821. if (command("%s %s", cmd, remote) != PRELIM) {
  822.     Signal(SIGINT, oldintr);
  823.     if (oldintp)
  824. Signal(SIGPIPE, oldintp);
  825.     if (closefunc != NULL)
  826. (*closefunc)(fin);
  827.     return;
  828. }
  829.     } else
  830. if (command("%s", cmd) != PRELIM) {
  831.     Signal(SIGINT, oldintr);
  832.     if (oldintp)
  833. Signal(SIGPIPE, oldintp);
  834.     if (closefunc != NULL)
  835. (*closefunc)(fin);
  836.     return;
  837. }
  838.     dout = dataconn(lmode);
  839.     if (dout == NULL)
  840. goto abort;
  841.     gettimeofday(&start, (struct timezone *)0);
  842.     oldintp = (sig_t)Signal(SIGPIPE, SIG_IGN);
  843.     switch (curtype) {
  845. case TYPE_I:
  846. case TYPE_L:
  847.     errno = d = 0;
  848.     while ((c = read(fileno(fin), buf, sizeof (buf))) > 0) {
  849. bytes += c;
  850. for (bufp = buf; c > 0; c -= d, bufp += d)
  851.     if ((d = write(fileno(dout), bufp, c)) <= 0)
  852. break;
  853. if (hash) {
  854.     while (bytes >= hashbytes) {
  855. putchar('#');
  856. hashbytes += HASHBYTES;
  857.     }
  858.     fflush(stdout);
  859. }
  860.     }
  861.     if (hash && bytes > 0) {
  862. if (bytes < HASHBYTES)
  863.     putchar('#');
  864. putchar('n');
  865. fflush(stdout);
  866.     }
  867.     if (c < 0)
  868. fprintf(stderr, "local: %s: %sn", local,
  869. strerror(errno));
  870.     if (d < 0) {
  871. if (errno != EPIPE) 
  872.     perror("netout");
  873. bytes = -1;
  874.     }
  875.     break;
  877. case TYPE_A:
  878.     while ((c = getc(fin)) != EOF) {
  879. if (c == 'n') {
  880.     while (hash && (bytes >= hashbytes)) {
  881. putchar('#');
  882. fflush(stdout);
  883. hashbytes += HASHBYTES;
  884.     }
  885.     if (ferror(dout))
  886. break;
  887.     putc('r', dout);
  888.     bytes++;
  889. }
  890. putc(c, dout);
  891. bytes++;
  892. /* if (c == 'r') {    */
  893. /* (void) putc('', dout);  /* this violates rfc */
  894. /* bytes++; */
  895. /* }                           */
  896.     }
  897.     if (hash) {
  898. if (bytes < hashbytes)
  899.     putchar('#');
  900. putchar('n');
  901. fflush(stdout);
  902.     }
  903.     if (ferror(fin))
  904. fprintf(stderr, "local: %s: %sn", local,
  905. strerror(errno));
  906.     if (ferror(dout)) {
  907. if (errno != EPIPE)
  908.     perror("netout");
  909. bytes = -1;
  910.     }
  911.     break;
  912.     }
  913.     gettimeofday(&stop, (struct timezone *)0);
  914.     if (closefunc != NULL)
  915. (*closefunc)(fin);
  916.     fclose(dout);
  917.     getreply(0);
  918.     Signal(SIGINT, oldintr);
  919.     if (oldintp)
  920. Signal(SIGPIPE, oldintp);
  921.     if (bytes > 0) {
  922. #ifdef FASCIST
  923. syslog(LOG_NOTICE, "Sent local file %s as %s -- %d bytes", local, remote, bytes);
  924. #endif
  925. ptransfer("sent", bytes, &start, &stop);
  926.     }
  927.     return;
  928. abort:
  929.     gettimeofday(&stop, (struct timezone *)0);
  930.     Signal(SIGINT, oldintr);
  931.     if (oldintp)
  932. Signal(SIGPIPE, oldintp);
  933.     if (!cpend) {
  934. code = -1;
  935. return;
  936.     }
  937.     if (data >= 0) {
  938. close(data);
  939. data = -1;
  940.     }
  941.     if (dout)
  942. fclose(dout);
  943.     getreply(0);
  944.     code = -1;
  945.     if (closefunc != NULL && fin != NULL)
  946. (*closefunc)(fin);
  947.     if (bytes > 0) {
  948. #ifdef FASCIST
  949. syslog(LOG_NOTICE, "Sent local file %s as %s -- %d bytes", local, remote, bytes);
  950. #endif
  952. ptransfer("sent", bytes, &start, &stop);
  953.     }
  954. }
  956. jmp_buf recvabort;
  958. void
  959. abortrecv()
  960. {
  962.     mflag = 0;
  963.     abrtflag = 0;
  964.     printf("nreceive abortednwaiting for remote to finish abortn");
  965.     fflush(stdout);
  966.     longjmp(recvabort, 1);
  967. }
  969. void recvrequest(char *cmd, char *local, char *remote, char *lmode, int printnames) {
  970.     FILE *fout, *din = 0, *popen();
  971.     int (*closefunc)(), pclose(), fclose();
  972.     sig_t oldintr, oldintp;
  973.     int is_retr, tcrflag, bare_lfs = 0;
  974.     char *gunique();
  975.     static int bufsize;
  976.     static char *buf;
  977.     long bytes = 0, hashbytes = HASHBYTES;
  978.     register int c, d;
  979.     struct timeval start, stop;
  980.     struct stat st;
  981.     off_t lseek();
  982.     void abortrecv();
  984.     is_retr = strcmp(cmd, "RETR") == 0;
  985.     if (is_retr && verbose && printnames) {
  986. if (local && *local != '-')
  987.     printf("local: %s ", local);
  988. if (remote)
  989.     printf("remote: %sn", remote);
  990.     }
  991.     if (proxy && is_retr) {
  992. proxtrans(cmd, local, remote);
  993. return;
  994.     }
  995.     closefunc = NULL;
  996.     oldintr = NULL;
  997.     oldintp = NULL;
  998.     tcrflag = !crflag && is_retr;
  999.     if (setjmp(recvabort)) {
  1000. while (cpend) {
  1001.     getreply(0);
  1002. }
  1003. if (data >= 0) {
  1004.     close(data);
  1005.     data = -1;
  1006. }
  1007. if (oldintr)
  1008.     Signal(SIGINT, oldintr);
  1009. code = -1;
  1010. return;
  1011.     }
  1012.     oldintr = (sig_t)Signal(SIGINT, abortrecv);
  1013.     if (strcmp(local, "-") && *local != '|') {
  1014. if (access(local, 2) < 0) {
  1015.     char *dir = rindex(local, '/');
  1017.     if (errno != ENOENT && errno != EACCES) {
  1018. fprintf(stderr, "local: %s: %sn", local,
  1019. strerror(errno));
  1020. Signal(SIGINT, oldintr);
  1021. code = -1;
  1022. return;
  1023.     }
  1024.     if (dir != NULL)
  1025. *dir = 0;
  1026.     d = access(dir ? local : ".", 2);
  1027.     if (dir != NULL)
  1028. *dir = '/';
  1029.     if (d < 0) {
  1030. fprintf(stderr, "local: %s: %sn", local,
  1031. strerror(errno));
  1032. Signal(SIGINT, oldintr);
  1033. code = -1;
  1034. return;
  1035.     }
  1036.     if (!runique && errno == EACCES &&
  1037. chmod(local, 0600) < 0) {
  1038. fprintf(stderr, "local: %s: %sn", local,
  1039. strerror(errno));
  1040. Signal(SIGINT, oldintr);
  1041. Signal(SIGINT, oldintr);
  1042. code = -1;
  1043. return;
  1044.     }
  1045.     if (runique && errno == EACCES &&
  1046. (local = gunique(local)) == NULL) {
  1047. Signal(SIGINT, oldintr);
  1048. code = -1;
  1049. return;
  1050.     }
  1051. }
  1052. else if (runique && (local = gunique(local)) == NULL) {
  1053.     Signal(SIGINT, oldintr);
  1054.     code = -1;
  1055.     return;
  1056. }
  1057.     }
  1058.     if (!is_retr) {
  1059. if (curtype != TYPE_A)
  1060.     changetype(TYPE_A, 0);
  1061.     } else if (curtype != type)
  1062. changetype(type, 0);
  1063.     if (initconn()) {
  1064. Signal(SIGINT, oldintr);
  1065. code = -1;
  1066. return;
  1067.     }
  1068.     if (setjmp(recvabort))
  1069. goto abort;
  1070.     if (is_retr && restart_point &&
  1071. command("REST %ld", (long) restart_point) != CONTINUE)
  1072. return;
  1073.     if (remote) {
  1074. if (command("%s %s", cmd, remote) != PRELIM) {
  1075.     Signal(SIGINT, oldintr);
  1076.     return;
  1077. }
  1078.     } else {
  1079. if (command("%s", cmd) != PRELIM) {
  1080.     Signal(SIGINT, oldintr);
  1081.     return;
  1082. }
  1083.     }
  1084.     din = dataconn("r");
  1085.     if (din == NULL)
  1086. goto abort;
  1087.     if (strcmp(local, "-") == 0)
  1088. fout = stdout;
  1089.     else if (*local == '|') {
  1090. oldintp = (sig_t)Signal(SIGPIPE, SIG_IGN);
  1091. fout = popen(local + 1, "w");
  1092. if (fout == NULL) {
  1093.     perror(local+1);
  1094.     goto abort;
  1095. }
  1096. closefunc = pclose;
  1097.     } else {
  1098. fout = fopen(local, lmode);
  1099. if (fout == NULL) {
  1100.     fprintf(stderr, "local: %s: %sn", local,
  1101.     strerror(errno));
  1102.     goto abort;
  1103. }
  1104. closefunc = fclose;
  1105.     }
  1107. #ifndef SVR3
  1108.     if (fstat(fileno(fout), &st) < 0 || st.st_blksize == 0)
  1109. #endif
  1110. st.st_blksize = BUFSIZ;
  1112.     if (st.st_blksize > bufsize) {
  1113. if (buf) free(buf);
  1114. buf = malloc((unsigned)st.st_blksize);
  1116. if (buf == NULL) {
  1117.     perror("malloc");
  1118.     bufsize = 0;
  1119.     goto abort;
  1120. }
  1121.     
  1122. bufsize = st.st_blksize;
  1123.     
  1124.     }
  1126.     gettimeofday(&start, (struct timezone *)0);
  1128.     switch (curtype) {
  1129. case TYPE_I:
  1130. case TYPE_L:
  1131. #ifdef SEEK_SET
  1132. #define FTP_SEEK_SET SEEK_SET
  1133. #else
  1134. #define FTP_SEEK_SET L_SET
  1135. #endif
  1137. #ifdef SEEK_CUR
  1138. #define FTP_SEEK_CUR SEEK_CUR
  1139. #else
  1140. #define FTP_SEEK_CUR L_CUR
  1141. #endif
  1142.     if (restart_point && lseek(fileno(fout), (long) restart_point, FTP_SEEK_SET) < 0) {
  1143. fprintf(stderr, "local: %s: %sn", local, strerror(errno));
  1144. if (closefunc != NULL) (*closefunc)(fout);
  1145. return;
  1146.     }
  1148.     errno = d = 0;
  1150.     while ((c = read(fileno(din), buf, bufsize)) > 0) {
  1151. if ((d = write(fileno(fout), buf, c)) != c) break;
  1152. bytes += c;
  1153.   
  1154. if (hash) {
  1155.     while (bytes >= hashbytes) {
  1156. putchar('#');
  1157. hashbytes += HASHBYTES;
  1158.     }
  1159.     fflush(stdout);
  1160. }
  1161.     }
  1163.     if (hash && bytes > 0) {
  1164. if (bytes < HASHBYTES) putchar('#');
  1165. putchar('n');
  1166. fflush(stdout);
  1167.     }
  1169.     if (c < 0) {
  1170. if (errno != EPIPE) perror("netin");
  1171. bytes = -1;
  1172.     }
  1174.     if (d < c) {
  1175. if (d < 0) fprintf(stderr, "local: %s: %sn", local, strerror(errno));
  1176. else fprintf(stderr, "%s: short writen", local);
  1177.     }
  1179.     break;
  1180. case TYPE_A:
  1181.     if (restart_point) {
  1182. register int i, n, ch;
  1184. if (fseek(fout, 0L, FTP_SEEK_SET) < 0) goto done;
  1185. n = restart_point;
  1187. for (i = 0; i++ < n;) {
  1188.     if ((ch = getc(fout)) == EOF) goto done;
  1189.     if (ch == 'n') i++;
  1190. }
  1191.   
  1192. if (fseek(fout, 0L, FTP_SEEK_CUR) < 0) {
  1193. done:
  1194.     fprintf(stderr, "local: %s: %sn", local, strerror(errno));
  1195.     if (closefunc != NULL) (*closefunc)(fout);
  1196.     return;
  1197. }
  1198.     }
  1200.     while ((c = getc(din)) != EOF) {
  1201. if (c == 'n') bare_lfs++;
  1203. while (c == 'r') {
  1204.     while (hash && (bytes >= hashbytes)) {
  1205. putchar('#');
  1206. fflush(stdout);
  1207. hashbytes += HASHBYTES;
  1208.     }
  1210.     bytes++;
  1212.     if ((c = getc(din)) != 'n' || tcrflag) {
  1213. if (ferror(fout)) goto break2;
  1214. putc('r', fout);
  1216. if (c == '') {
  1217.     bytes++;
  1218.     goto contin2;
  1219. }
  1221. if (c == EOF) goto contin2;
  1222.     }
  1223. }
  1225. putc(c, fout);
  1226. bytes++;
  1227.     contin2: ;
  1228.     }
  1229.     break2:
  1230.     if (bare_lfs) {
  1231. printf("WARNING! %d bare linefeeds received in ASCII moden", bare_lfs);
  1232. printf("File may not have transferred correctly.n");
  1233.     }
  1234.     if (hash) {
  1235. if (bytes < hashbytes) putchar('#');
  1236. putchar('n');
  1237. fflush(stdout);
  1238.     }
  1240.     if (ferror(din)) {
  1241. if (errno != EPIPE) perror("netin");
  1242. bytes = -1;
  1243.     }
  1245.     if (ferror(fout)) fprintf(stderr, "local: %s: %sn", local, strerror(errno));
  1246.     break;
  1247.     }
  1249.     if (closefunc != NULL) (*closefunc)(fout);
  1251.     Signal(SIGINT, oldintr);
  1252.     if (oldintp) Signal(SIGPIPE, oldintp);
  1254.     gettimeofday(&stop, (struct timezone *)0);
  1255.     fclose(din);
  1256.     getreply(0);
  1258.     if (bytes > 0 && is_retr) {
  1259. #ifdef FASCIST
  1260. syslog(LOG_NOTICE, "Received remote file %s as %s -- %d bytes", remote, local, bytes);
  1261. #endif
  1262. ptransfer("received", bytes, &start, &stop);
  1263.     }
  1264.     return;
  1266. abort:
  1268.     /* abort using RFC959 recommended IP,SYNC sequence  */
  1269.   
  1270.     gettimeofday(&stop, (struct timezone *)0);
  1271.     if (oldintp) Signal(SIGPIPE, oldintr);
  1272.     Signal(SIGINT, SIG_IGN);
  1274.     if (!cpend) {
  1275. code = -1;
  1276. Signal(SIGINT, oldintr);
  1277. return;
  1278.     }
  1279.   
  1280.     abort_remote(din);
  1281.     code = -1;
  1283.     if (data >= 0) {
  1284. close(data);
  1285. data = -1;
  1286.     }
  1288.     if (closefunc != NULL && fout != NULL) (*closefunc)(fout);
  1289.     if (din) fclose(din);
  1291.     if (bytes > 0) {
  1292. #ifdef FASCIST
  1293. syslog(LOG_NOTICE, "Received remote file %s as %s -- %d bytes", remote, local, bytes);
  1294. #endif
  1295. ptransfer("received", bytes, &start, &stop);
  1296.     }
  1298.     Signal(SIGINT, oldintr);
  1299. }
  1301. FILE *
  1302. dataconn(lmode)
  1303.     char *lmode;
  1304. {
  1305.     struct sockaddr_in from;
  1306.     int s, fromlen = sizeof (from), tos;
  1308.     if ((s = accept(data, (struct sockaddr *) &from, &fromlen)) < 0) {
  1309. perror("ftp: accept");
  1310. close(data), data = -1;
  1311. return (NULL);
  1312.     }
  1313.     close(data);
  1314.     data = s;
  1316. #if defined(IP_TOS) && defined(IPTOS_THROUGHPUT)
  1317.     tos = IPTOS_THROUGHPUT;
  1318.     if (setsockopt(s, IPPROTO_IP, IP_TOS, (char *)&tos, sizeof(int)) < 0)
  1319. perror("ftp: setsockopt TOS (ignored)");
  1320. #endif
  1322.     return (fdopen(data, lmode));
  1323. }
  1325. void psabort() {
  1326.     extern int abrtflag;
  1327.     abrtflag++;
  1328. }
  1330. void pswitch(int flag) {
  1331.     extern int proxy, abrtflag;
  1332.     sig_t oldintr;
  1334.     static struct comvars {
  1335. int connect;
  1336. char name[MAXHOSTNAMELEN];
  1337. struct sockaddr_in mctl;
  1338. struct sockaddr_in hctl;
  1339. FILE *in;
  1340. FILE *out;
  1341. int tpe;
  1342. int curtpe;
  1343. int cpnd;
  1344. int sunqe;
  1345. int runqe;
  1346. int mcse;
  1347. int ntflg;
  1348. char nti[17];
  1349. char nto[17];
  1350. int mapflg;
  1351. char mi[MAXPATHLEN];
  1352. char mo[MAXPATHLEN];
  1353.     } proxstruct, tmpstruct;
  1355.     struct comvars *ip, *op;
  1357.     abrtflag = 0;
  1358.     oldintr = (sig_t)Signal(SIGINT, psabort);
  1360.     if (flag) {
  1361. if (proxy) return;
  1362. ip = &tmpstruct;
  1363. op = &proxstruct;
  1364. proxy++;
  1365.     } else {
  1366. if (!proxy) return;
  1367. ip = &proxstruct;
  1368. op = &tmpstruct;
  1369. proxy = 0;
  1370.     }
  1372.     ip->connect = connected;
  1373.     connected = op->connect;
  1375.     if (hostname) {
  1376. strncpy(ip->name, hostname, sizeof(ip->name) - 1);
  1377. ip->name[strlen(ip->name)] = '';
  1378.     } else {
  1379. ip->name[0] = '';
  1380.     }
  1381.     hostname = op->name;
  1382.     ip->hctl = hisctladdr;
  1383.     hisctladdr = op->hctl;
  1384.     ip->mctl = myctladdr;
  1385.     myctladdr = op->mctl;
  1386.     ip->in = cin;
  1387.     cin = op->in;
  1388.     ip->out = cout;
  1389.     cout = op->out;
  1390.     ip->tpe = type;
  1391.     type = op->tpe;
  1392.     ip->curtpe = curtype;
  1393.     curtype = op->curtpe;
  1394.     ip->cpnd = cpend;
  1395.     cpend = op->cpnd;
  1396.     ip->sunqe = sunique;
  1397.     sunique = op->sunqe;
  1398.     ip->runqe = runique;
  1399.     runique = op->runqe;
  1400.     ip->mcse = mcase;
  1401.     mcase = op->mcse;
  1402.     ip->ntflg = ntflag;
  1403.     ntflag = op->ntflg;
  1404.     strncpy(ip->nti, ntin, 16);
  1405.     (ip->nti)[strlen(ip->nti)] = '';
  1406.     strcpy(ntin, op->nti);
  1407.     strncpy(ip->nto, ntout, 16);
  1408.     (ip->nto)[strlen(ip->nto)] = '';
  1409.     strcpy(ntout, op->nto);
  1410.     ip->mapflg = mapflag;
  1411.     mapflag = op->mapflg;
  1412.     strncpy(ip->mi, mapin, MAXPATHLEN - 1);
  1413.     (ip->mi)[strlen(ip->mi)] = '';
  1414.     strcpy(mapin, op->mi);
  1415.     strncpy(ip->mo, mapout, MAXPATHLEN - 1);
  1416.     (ip->mo)[strlen(ip->mo)] = '';
  1417.     strcpy(mapout, op->mo);
  1418.     Signal(SIGINT, oldintr);
  1420.     if (abrtflag) {
  1421. abrtflag = 0;
  1422. (*oldintr)(SIGINT);
  1423.     }
  1424. }
  1426. void abortpt() {
  1427.     printf("n");
  1428.     fflush(stdout);
  1430.     ptabflg++;
  1431.     mflag    = 0;
  1432.     abrtflag = 0;
  1434.     longjmp(ptabort, 1);
  1435. }
  1437. void reset() {
  1438.     fd_set mask;
  1439.     int nfnd = 1;
  1440.     
  1441.     FD_ZERO(&mask);
  1443.     while (nfnd > 0) {
  1444. FD_SET(fileno(cin), &mask);
  1446. if ((nfnd = empty(&mask,0)) < 0) {
  1447.     perror("reset");
  1448.     code = -1;
  1449.     lostpeer();
  1450. } else if (nfnd) {
  1451.     getreply(0);
  1452. }
  1453.     }
  1454. }
  1456. char *gunique(char *local) {
  1457.     static char new[MAXPATHLEN];
  1458.     char *cp = rindex(local, '/');
  1459.     int d, count=0;
  1460.     char ext = '1';
  1462.     if (cp) *cp = '';
  1463.     d = access(cp ? local : ".", 2);
  1464.     if (cp) *cp = '/';
  1466.     if (d < 0) {
  1467. fprintf(stderr, "local: %s: %sn", local, strerror(errno));
  1468. return((char *) 0);
  1469.     }
  1470.     
  1471.     strcpy(new, local);
  1472.     cp = new + strlen(new);
  1473.     *cp++ = '.';
  1475.     while (!d) {
  1476. if (++count == 100) {
  1477.     printf("runique: can't find unique file name.n");
  1478.     return((char *) 0);
  1479. }
  1481. *cp++ = ext;
  1482. *cp = '';
  1483. if (ext == '9') ext = '0';
  1484. else            ext++;
  1486. if ((d = access(new, 0)) < 0) break;
  1487. if (ext != '0') cp--;
  1488. else if (*(cp - 2) == '.') *(cp - 1) = '1';
  1489. else {
  1490.     *(cp - 2) = *(cp - 2) + 1;
  1491.     cp--;
  1492. }
  1493.     }
  1495.     return(new);
  1496. }