home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / x / volume18 / ftptool-4.3 / part09 < prev    next >
Text File  |  1992-08-18  |  51KB  |  2,316 lines
  1. Path: uunet!usc!elroy.jpl.nasa.gov!swrinde!mips!msi!dcmartin
  2. From: Mike.Sullivan@EBay.Sun.COM (Mike Sullivan {AKA Simon BarSinister})
  3. Newsgroups: comp.sources.x
  4. Subject: v18i091: Ftptool 4.3 (XVIEW), Part09/12
  5. Message-ID: <1992Aug18.153737.29024@msi.com>
  6. Date: 18 Aug 92 15:37:37 GMT
  7. References: <csx-18i083-ftptool-4.3@uunet.UU.NET>
  8. Sender: dcmartin@msi.com (David C. Martin - Moderator)
  9. Organization: Molecular Simulations, Inc.
  10. Lines: 2302
  11. Approved: dcmartin@msi.com
  12. Originator: dcmartin@fascet
  13.  
  14. Submitted-by: Mike.Sullivan@EBay.Sun.COM (Mike Sullivan {AKA Simon BarSinister})
  15. Posting-number: Volume 18, Issue 91
  16. Archive-name: ftptool-4.3/part09
  17.  
  18. #!/bin/sh
  19. # this is part.09 (part 9 of a multipart archive)
  20. # do not concatenate these parts, unpack them in order with /bin/sh
  21. # file ftp.c continued
  22. #
  23. if test ! -r _shar_seq_.tmp; then
  24.     echo 'Please unpack part 1 first!'
  25.     exit 1
  26. fi
  27. (read Scheck
  28.  if test "$Scheck" != 9; then
  29.     echo Please unpack part "$Scheck" next!
  30.     exit 1
  31.  else
  32.     exit 0
  33.  fi
  34. ) < _shar_seq_.tmp || exit 1
  35. if test ! -f _shar_wnt_.tmp; then
  36.     echo 'x - still skipping ftp.c'
  37. else
  38. echo 'x - continuing file ftp.c'
  39. sed 's/^X//' << 'SHAR_EOF' >> 'ftp.c' &&
  40. X            dig++;
  41. X            if (c == EOF) {
  42. X                if (expecteof) {
  43. X                    code = 221;
  44. X                    notify_no_dispatch();
  45. X                    return (0);
  46. X                }
  47. X                lostpeer();
  48. X                if (verbose) {
  49. X                    sprintf(scratch, "421 Service not available, remote server has closed connection\n");
  50. X                    log_message(scratch);
  51. X                }
  52. X                code = 421;
  53. X                notify_no_dispatch();
  54. X                return(4);
  55. X            }
  56. X            if (c != '\r' && (verbose > 0 ||
  57. X                (verbose > -1 && n == '5' && dig > 4))) {
  58. X                /*
  59. X                (void) putchar(c);
  60. X                 */
  61. X                log_char(c);
  62. X            }
  63. X            if (dig < 4 && isdigit(c))
  64. X                code = code * 10 + (c - '0');
  65. X            if (!pflag && code == 227)
  66. X                pflag = 1;
  67. X            if (dig > 4 && pflag == 1 && isdigit(c))
  68. X                pflag = 2;
  69. /*
  70. X            if (pflag == 2) {
  71. X                if (c != '\r' && c != ')')
  72. X                    *pt++ = c;
  73. X                else {
  74. X                    *pt = '\0';
  75. X                    pflag = 3;
  76. X                }
  77. X            }
  78. */
  79. X            if (dig == 4 && c == '-') {
  80. X                if (continuation)
  81. X                    code = 0;
  82. X                continuation++;
  83. X            }
  84. X            if (n == 0)
  85. X                n = c;
  86. X            if (cp < &response_line[sizeof(response_line) - 1])
  87. X                *cp++ = c;
  88. X        }
  89. X        if (verbose > 0 || verbose > -1 && n == '5') {
  90. X            /*
  91. X            (void) putchar(c);
  92. X             */
  93. X            log_char(c);
  94. X            (void) fflush (stdout);
  95. X        }
  96. X        if (continuation && code != originalcode) {
  97. X            if (originalcode == 0)
  98. X                originalcode = code;
  99. X            continue;
  100. X        }
  101. X        *cp = '\0';
  102. X        if (n != '1')
  103. X            cpend = 0;
  104. X        if (code == 421 || originalcode == 421)
  105. X            lostpeer();
  106. X        notify_no_dispatch();
  107. X        return (n - '0');
  108. X    }
  109. }
  110. X
  111. #ifdef USE_PROTOTYPES
  112. int empty(fd_set *mask, int sec)
  113. #else
  114. int empty(mask, sec)
  115. fd_set *mask;
  116. int sec;
  117. #endif
  118. {
  119. X    struct timeval t;
  120. X
  121. X    t.tv_sec = (long) sec;
  122. X    t.tv_usec = 0;
  123. X    return select(32, mask, (fd_set *)NULL, (fd_set *)NULL, &t);
  124. }
  125. X
  126. jmp_buf    sendabort;
  127. X
  128. #define HASHBYTES 1024
  129. X
  130. #ifdef USE_PROTOTYPES
  131. int sendrequest(char *cmd, char *local, char *remote, size_t size)
  132. #else
  133. int sendrequest(cmd, local, remote, size)
  134. char    *cmd, *local, *remote;
  135. size_t    size;
  136. #endif
  137. {
  138. X    struct stat st;
  139. X    struct timeval start, stop;
  140. X    register int c, d;
  141. X    FILE *fin = NULL, *dout = 0, *popen();
  142. X    int (*closefunc)(), pclose(), fclose();
  143. X    long bytes = 0;
  144. X    char *lmode, buf[BUFSIZ], *bufp;
  145. X    char    *ftperr;
  146. X    int        errormsg=0;
  147. X
  148. X    closefunc = NULL;
  149. X    lmode = "w";
  150. X    update_status_label("Sending", remote, size);
  151. X    if (setjmp(sendabort)) {
  152. X        while (cpend) {
  153. X            (void) getreply(0);
  154. X        }
  155. X        if (data >= 0) {
  156. X            (void) close(data);
  157. X            data = -1;
  158. X        }
  159. X        code = -1;
  160. X        return 0;
  161. X    }
  162. X    fin = fopen(local, "r");
  163. X    if (fin == NULL) {
  164. X        local_footer_message("Open: %s: %s.", local, strerror(errno),
  165. X            (char *)NULL);
  166. X        /*
  167. X        fprintf(stderr, "local: %s: %s\n", local,
  168. X            strerror(errno));
  169. X         */
  170. X        code = -1;
  171. X        return 0;
  172. X    }
  173. X    closefunc = fclose;
  174. X    if (fstat(fileno(fin), &st) < 0 ||
  175. X        (st.st_mode&S_IFMT) != S_IFREG) {
  176. X        local_footer_message("%s: not a plain file.", local, (char *)NULL);
  177. X        fclose(fin);
  178. X        fin = NULL;
  179. X        code = -1;
  180. X        return 1;
  181. X    }
  182. X    if (initconn()) {
  183. X        code = -1;
  184. X        if (closefunc != NULL)
  185. X            (*closefunc)(fin);
  186. X        return 0;
  187. X    }
  188. X    if (setjmp(sendabort))
  189. X        goto abort;
  190. X
  191. X    if (restart_point &&
  192. X        (strcmp(cmd, "STOR") == 0 || strcmp(cmd, "APPE") == 0)) {
  193. X        if (fseek(fin, (long) restart_point, 0) < 0) {
  194. X            local_footer_message("Seek: %s: %s.", local, strerror(errno),
  195. X                (char *)NULL);
  196. X            /*
  197. X            fprintf(stderr, "local: %s: %s\n", local,
  198. X                strerror(errno));
  199. X             */
  200. X            restart_point = 0;
  201. X            if (closefunc != NULL)
  202. X                (*closefunc)(fin);
  203. X            return 0;
  204. X        }
  205. X        if (command("REST %ld", (long) restart_point)
  206. X            != CONTINUE) {
  207. X            restart_point = 0;
  208. X            if (closefunc != NULL)
  209. X                (*closefunc)(fin);
  210. X            return 0;
  211. X        }
  212. X        restart_point = 0;
  213. X        lmode = "r+w";
  214. X    }
  215. X    if (remote) {
  216. X        if (command_dataconn(&dout, lmode, "%s %s", cmd, remote) != PRELIM) {
  217. #ifdef notdef
  218. X        if (command("%s %s", cmd, remote) != PRELIM) {
  219. #endif
  220. X            if (closefunc != NULL)
  221. X                (*closefunc)(fin);
  222. X            /*
  223. X            fprintf(stderr, "remote-command != PRELIM\n");
  224. X             */
  225. X            /* Permission denied */
  226. X
  227. X            sprintf(scratch, "Put %s failed.", remote);
  228. X            ftperr = ftp_error(' ', scratch);
  229. X            local_footer_message(ftperr, (char *)NULL);
  230. X
  231. X            return 1;
  232. X        }
  233. X    } else
  234. X        if (command_dataconn(&dout, lmode, "%s", cmd) != PRELIM) {
  235. #ifdef notdef
  236. X        if (command("%s", cmd) != PRELIM) {
  237. #endif
  238. X            if (closefunc != NULL)
  239. X                (*closefunc)(fin);
  240. X            fprintf(stderr, "command != PRELIM\n");
  241. X            return 1;
  242. X        }
  243. #ifdef notdef
  244. X    dout = dataconn(lmode);
  245. #endif
  246. X    if (dout == NULL)
  247. X        goto abort;
  248. X    (void) gettimeofday(&start, (struct timezone *)0);
  249. X    switch (curtype) {
  250. X
  251. X    case TYPE_I:
  252. X    case TYPE_L:
  253. X        errno = d = 0;
  254. X        notify_do_dispatch();
  255. X        while ((c = read(fileno(fin), buf, sizeof (buf))) > 0) {
  256. X            if (abort_transfer) {
  257. X                notify_no_dispatch();
  258. X                goto abort;
  259. X            }
  260. X            bytes += c;
  261. X            for (bufp = buf; c > 0; c -= d, bufp += d)
  262. X                if ((d = write(fileno(dout), bufp, c)) <= 0) {
  263. X                    break;
  264. X                } else {
  265. X                    /* change image */
  266. X                    update_status_gauge(d);
  267. X                }
  268. X            if (abort_transfer) {
  269. X                notify_no_dispatch();
  270. X                goto abort;
  271. X            }
  272. X        }
  273. X        notify_no_dispatch();
  274. X        if (c < 0) {
  275. X            footer_message("Read %s: %s.", local, strerror(errno), (char *)NULL);
  276. X            /*
  277. X            fprintf(stderr, "local: %s: %s\n", local,
  278. X                strerror(errno));
  279. X             */
  280. X            errormsg = 1;
  281. X        }
  282. X        if (d < 0) {
  283. X            local_footer_message("Write failed (remote file system full?).", 
  284. X                (char *)NULL);
  285. X            errormsg = 1;
  286. X            goto abort;
  287. X        }
  288. X        break;
  289. X
  290. X    case TYPE_A:
  291. X        notify_do_dispatch();
  292. X        while ((c = getc(fin)) != EOF) {
  293. X            if (abort_transfer) {
  294. X                notify_no_dispatch();
  295. X                goto abort;
  296. X            }
  297. X            if (c == '\n') {
  298. X                if (ferror(dout))
  299. X                    break;
  300. X                (void) putc('\r', dout);
  301. X                /* change image */
  302. X                update_status_gauge(1);
  303. X                bytes++;
  304. X            }
  305. X            (void) putc(c, dout);
  306. X            /* change image */
  307. X            update_status_gauge(1);
  308. X            if (abort_transfer) {
  309. X                notify_no_dispatch();
  310. X                goto abort;
  311. X            }
  312. X            bytes++;
  313. X    /*        if (c == '\r') {                  */
  314. X    /*        (void)    putc('\0', dout);*/ /*this violates rfc */
  315. X    /*            bytes++;                */
  316. X    /*        }                                      */    
  317. X        }
  318. X        notify_no_dispatch();
  319. X        if (ferror(fin)) {
  320. X            errormsg = 1;
  321. X            local_footer_message("%s: %s.", local, strerror(errno), 
  322. X                (char *)NULL);
  323. X            /*
  324. X            fprintf(stderr, "local: %s: %s\n", local,
  325. X                strerror(errno));
  326. X             */
  327. X        }
  328. X        if (ferror(dout)) {
  329. X            if (errno != EPIPE)
  330. X                perror("netout");
  331. X            bytes = -1;
  332. X        }
  333. X        break;
  334. X    }
  335. X    (void) gettimeofday(&stop, (struct timezone *)0);
  336. X    if (closefunc != NULL)
  337. X        (*closefunc)(fin);
  338. X    (void) fclose(dout);
  339. X    dout = NULL;
  340. X    (void) getreply(0);
  341. X    if (!errormsg)
  342. X        local_footer_message("Send of %s complete.", remote, (char *)NULL);
  343. X    return 0;
  344. abort:
  345. X    (void) gettimeofday(&stop, (struct timezone *)0);
  346. X    if (!cpend) {
  347. X        code = -1;
  348. X        return 0;
  349. X    }
  350. X    if (data >= 0) {
  351. X        (void) close(data);
  352. X        data = -1;
  353. X    }
  354. X    if (dout) {
  355. X        (void) fclose(dout);
  356. X        dout = NULL;
  357. X    }
  358. X    (void) getreply(0);
  359. X    code = -1;
  360. X    if (closefunc != NULL && fin != NULL)
  361. X        (*closefunc)(fin);
  362. X    if (!errormsg)
  363. X        local_footer_message("Send of %s aborted.", remote, (char *)NULL);
  364. X    return 2;
  365. }
  366. X
  367. jmp_buf    recvabort;
  368. X
  369. #ifdef USE_PROTOTYPES
  370. int recvrequest(char *cmd, char *local, char *remote, 
  371. X    char *lmode, size_t size)
  372. #else
  373. int recvrequest(cmd, local, remote, lmode, size)
  374. char    *cmd, *local, *remote, *lmode;
  375. size_t    size;
  376. #endif
  377. {
  378. X    FILE *fout = NULL, *din = 0, *popen();
  379. X    int (*closefunc)(), pclose(), fclose();
  380. X    int is_retr, tcrflag, bare_lfs = 0;
  381. X    char *gunique();
  382. X    static int bufsize;
  383. X    static char *buf;
  384. X    long bytes = 0;
  385. X    register int c, d;
  386. X    struct timeval start, stop;
  387. X    struct stat st;
  388. X    off_t lseek();
  389. X    char    *ftperr;
  390. X    int        errormsg=0;
  391. X
  392. X    update_status_label("Receiving", remote, size);
  393. X    is_retr = strcmp(cmd, "RETR") == 0;
  394. X    closefunc = NULL;
  395. X    tcrflag = !crflag && is_retr;
  396. X    if (setjmp(recvabort)) {
  397. X        while (cpend) {
  398. X            (void) getreply(0);
  399. X        }
  400. X        if (data >= 0) {
  401. X            (void) close(data);
  402. X            data = -1;
  403. X        }
  404. X        code = -1;
  405. X        return 0;
  406. X    }
  407. X    if (strcmp(local, "-") && *local != '|') {
  408. X        if (access(local, 2) < 0) {
  409. X            char *dir = rindex(local, '/');
  410. X
  411. X            if (errno != ENOENT && errno != EACCES) {
  412. X                footer_message("Access: %s: %s.", local, strerror(errno),
  413. X                    (char *)NULL);
  414. X                /*
  415. X                fprintf(stderr, "local: %s: %s\n", local,
  416. X                    strerror(errno));
  417. X                 */
  418. X                code = -1;
  419. X                return 0;
  420. X            }
  421. X            if (dir != NULL)
  422. X                *dir = 0;
  423. X            d = access(dir ? local : ".", 2);
  424. X            if (dir != NULL)
  425. X                *dir = '/';
  426. X            if (d < 0) {
  427. X                footer_message("Access: %s: %s.", local, strerror(errno),
  428. X                    (char *)NULL);
  429. X                /*
  430. X                fprintf(stderr, "local: %s: %s\n", local,
  431. X                    strerror(errno));
  432. X                 */
  433. X                code = -1;
  434. X                return 0;
  435. X            }
  436. X            if (!unique_local_names && errno == EACCES &&
  437. X                chmod(local, 0600) < 0) {
  438. X                footer_message("Chmod: %s: %s.", local, strerror(errno),
  439. X                    (char *)NULL);
  440. X                /*
  441. X                fprintf(stderr, "local: %s: %s\n", local,
  442. X                    strerror(errno));
  443. X                 */
  444. X                code = -1;
  445. X                return 1;
  446. X            }
  447. X            if (unique_local_names && errno == EACCES &&
  448. X               (local = gunique(local)) == NULL) {
  449. X                code = -1;
  450. X                return 1;
  451. X            }
  452. X        }
  453. X        else if (unique_local_names && (local = gunique(local)) == NULL) {
  454. X            code = -1;
  455. X            return 1;
  456. X        }
  457. X    }
  458. X    if (initconn()) {
  459. X        code = -1;
  460. X        return 0;
  461. X    }
  462. X    if (setjmp(recvabort))
  463. X        goto abort;
  464. X    if (is_retr && restart_point &&
  465. X        command("REST %ld", (long) restart_point) != CONTINUE)
  466. X        return 0;
  467. X    if (remote) {
  468. X        if (command_dataconn(&din, "r", "%s %s", cmd, remote) != PRELIM) {
  469. #ifdef notdef
  470. X        if (command("%s %s", cmd, remote) != PRELIM) {
  471. #endif
  472. X            /*Not a plain file/Permission denied/No such file or directory*/
  473. X
  474. X            sprintf(scratch, "Get %s failed.", remote);
  475. X            ftperr = ftp_error(' ', scratch);
  476. X            footer_message(ftperr, (char *)NULL);
  477. X            return 1;
  478. X        }
  479. X    } else {
  480. X        if (command_dataconn(&din, "r", "%s", cmd) != PRELIM) {
  481. #ifdef notdef
  482. X        if (command("%s", cmd) != PRELIM) {
  483. #endif
  484. X            footer_message("command != PRELIM", (char *)NULL);
  485. X            /*
  486. X            fprintf(stderr, "command != PRELIM\n");
  487. X             */
  488. X            return 1;
  489. X        }
  490. X    }
  491. #ifdef notdef
  492. X    din = dataconn("r");
  493. #endif
  494. X    if (din == NULL)
  495. X        goto abort;
  496. X    if (strcmp(local, "-") == 0)
  497. X        fout = stdout;
  498. X    else if (*local == '|') {
  499. X        fout = popen(local + 1, "w");
  500. X        if (fout == NULL) {
  501. X            perror(local+1);
  502. X            goto abort;
  503. X        }
  504. X        closefunc = pclose;
  505. X    } else {
  506. X        fout = fopen(local, lmode);
  507. X        if (fout == NULL) {
  508. X            footer_message("Open: %s: %s.", local, strerror(errno),
  509. X                (char *)NULL);
  510. X            /*
  511. X            fprintf(stderr, "local: %s: %s\n", local,
  512. X                strerror(errno));
  513. X             */
  514. X            errormsg = 1;
  515. X            goto abort;
  516. X        }
  517. X        closefunc = fclose;
  518. X    }
  519. X    if (fstat(fileno(fout), &st) < 0 || st.st_blksize == 0)
  520. X        st.st_blksize = BUFSIZ;
  521. X    if (st.st_blksize > bufsize) {
  522. X        if (buf)
  523. X            (void) free(buf);
  524. X        buf = malloc((unsigned)st.st_blksize);
  525. X        if (buf == NULL) {
  526. X            perror("malloc");
  527. X            bufsize = 0;
  528. X            goto abort;
  529. X        }
  530. X        bufsize = st.st_blksize;
  531. X    }
  532. X    (void) gettimeofday(&start, (struct timezone *)0);
  533. X    switch (curtype) {
  534. X
  535. X    case TYPE_I:
  536. X    case TYPE_L:
  537. X        if (restart_point &&
  538. X            lseek(fileno(fout), (long) restart_point, SEEK_SET) < 0) {
  539. X            footer_message("Seek: %s: %s.", local, strerror(errno),
  540. X                (char *)NULL);
  541. X            /*
  542. X            fprintf(stderr, "local: %s: %s\n", local,
  543. X                strerror(errno));
  544. X             */
  545. X            if (closefunc != NULL)
  546. X                (*closefunc)(fout);
  547. X            return 0;
  548. X        }
  549. X        errno = d = 0;
  550. X        notify_do_dispatch();
  551. X        while ((c = read(fileno(din), buf, bufsize)) > 0) {
  552. X            if (abort_transfer) {
  553. X                notify_no_dispatch();
  554. X                goto abort;
  555. X            }
  556. X            if ((d = write(fileno(fout), buf, c)) <= 0)
  557. X                break;
  558. X            /* change image */
  559. X            update_status_gauge(d);
  560. X            if (d != c)
  561. X                break;
  562. X            /*
  563. X            if ((d = write(fileno(fout), buf, c)) != c)
  564. X                break;
  565. X             */
  566. X            if (abort_transfer) {
  567. X                notify_no_dispatch();
  568. X                goto abort;
  569. X            }
  570. X            bytes += c;
  571. X        }
  572. X        notify_no_dispatch();
  573. X        if (c < 0) {
  574. X            if (errno != EPIPE)
  575. X                perror("netin");
  576. X            bytes = -1;
  577. X        }
  578. X        if (d < c) {
  579. X            errormsg = 1;
  580. X            if (d < 0) {
  581. X                /*
  582. X                fprintf(stderr, "local: %s: %s\n", local,
  583. X                    strerror(errno));
  584. X                 */
  585. X                footer_message("Write failed: %s",strerror(errno),(char *)NULL);
  586. X                goto abort;
  587. X            } else {
  588. X              /*
  589. X                fprintf(stderr, "%s: short write\n", local);
  590. X               */
  591. X                footer_message("Short write: %s",strerror(errno),(char *)NULL);
  592. X            }
  593. X        }
  594. X        break;
  595. X
  596. X    case TYPE_A:
  597. X        if (restart_point) {
  598. X            register int i, n, ch;
  599. X
  600. X            if (fseek(fout, 0L, SEEK_SET) < 0)
  601. X                goto done;
  602. X            n = restart_point;
  603. X            for (i = 0; i++ < n;) {
  604. X                if ((ch = getc(fout)) == EOF)
  605. X                    goto done;
  606. X                if (ch == '\n')
  607. X                    i++;
  608. X            }
  609. X            if (fseek(fout, 0L, SEEK_CUR) < 0) {
  610. done:
  611. X                footer_message("Seek: %s: %s.", local, strerror(errno),
  612. X                    (char *)NULL);
  613. X                /*
  614. X                fprintf(stderr, "local: %s: %s\n", local,
  615. X                    strerror(errno));
  616. X                 */
  617. X                if (closefunc != NULL)
  618. X                    (*closefunc)(fout);
  619. X                return 0;
  620. X            }
  621. X        }
  622. X        notify_do_dispatch();
  623. X        while ((c = getc(din)) != EOF) {
  624. X            if (abort_transfer) {
  625. X                notify_no_dispatch();
  626. X                goto abort;
  627. X            }
  628. X            if (c == '\n')
  629. X                bare_lfs++;
  630. X            while (c == '\r') {
  631. X                bytes++;
  632. X                if ((c = getc(din)) != '\n' || tcrflag) {
  633. X                    if (ferror(fout))
  634. X                        goto break2;
  635. X                    (void) putc('\r', fout);
  636. X                    /* change image */
  637. X                    update_status_gauge(1);
  638. X                    if (c == '\0') {
  639. X                        bytes++;
  640. X                        goto contin2;
  641. X                    }
  642. X                    if (c == EOF)
  643. X                        goto contin2;
  644. X                }
  645. X            }
  646. X            (void) putc(c, fout);
  647. X            /* change image */
  648. X            update_status_gauge(1);
  649. X            if (abort_transfer) {
  650. X                notify_no_dispatch();
  651. X                goto abort;
  652. X            }
  653. X            bytes++;
  654. X    contin2:    ;
  655. X        }
  656. break2:
  657. X        notify_no_dispatch();
  658. X        if (bare_lfs) {
  659. X            fprintf(stderr,"WARNING! %d bare linefeeds received in ASCII mode\n",
  660. X                bare_lfs);
  661. X            fprintf(stderr,"File may not have transferred correctly.\n");
  662. X        }
  663. X        if (ferror(din)) {
  664. X            if (errno != EPIPE)
  665. X                perror("netin");
  666. X            bytes = -1;
  667. X        }
  668. X        if (ferror(fout)) {
  669. X            errormsg = 1;
  670. X            footer_message("%s: %s.", local, strerror(errno),
  671. X                (char *)NULL);
  672. X            /*
  673. X            fprintf(stderr, "local: %s: %s\n", local,
  674. X                strerror(errno));
  675. X             */
  676. X        }
  677. X        break;
  678. X    }
  679. X    if (closefunc != NULL)
  680. X        (*closefunc)(fout);
  681. X    (void) gettimeofday(&stop, (struct timezone *)0);
  682. X    (void) fclose(din);
  683. X    din = NULL;
  684. X    (void) getreply(0);
  685. X    if (!errormsg)
  686. X        footer_message("Receive of %s complete.", remote, (char *)NULL);
  687. X    return 0;
  688. abort:
  689. X
  690. /* abort using RFC959 recommended IP,SYNC sequence  */
  691. X
  692. X    (void) gettimeofday(&stop, (struct timezone *)0);
  693. X    if (!cpend) {
  694. X        code = -1;
  695. X        return 0;
  696. X    }
  697. X
  698. X    abort_remote(din);
  699. X    code = -1;
  700. X    if (data >= 0) {
  701. X        (void) close(data);
  702. X        data = -1;
  703. X    }
  704. X    if (closefunc != NULL && fout != NULL)
  705. X        (*closefunc)(fout);
  706. X    if (din) {
  707. X        (void) fclose(din);
  708. X        din = NULL;
  709. X    }
  710. X    if (!errormsg)
  711. X        footer_message("Receive of %s aborted.", remote, (char *)NULL);
  712. X    return 2;
  713. }
  714. X
  715. /*
  716. X * Need to start a listen on the data channel before we send the command,
  717. X * otherwise the server's connect may fail.
  718. X */
  719. #ifdef USE_PROTOTYPES
  720. int initconn(void)
  721. #else
  722. int initconn()
  723. #endif
  724. {
  725. X    register char *p, *a;
  726. X    int result, len, tmpno = 0;
  727. X    int on = 1;
  728. #ifdef SYSV386
  729. X    ushort    data_port;
  730. #endif
  731. X
  732. noport:
  733. X    data_addr = myctladdr;
  734. X    if (sendport)
  735. X        data_addr.sin_port = 0;    /* let system pick one */ 
  736. X    if (data != -1) {
  737. X        (void) close(data);
  738. X        data = -1;
  739. X    }
  740. X    data = socket(AF_INET, SOCK_STREAM, 0);
  741. X    if (data < 0) {
  742. X        perror("ftptool: socket");
  743. X        if (tmpno)
  744. X            sendport = 1;
  745. X        return (1);
  746. X    }
  747. X    if (!sendport)
  748. X        if (setsockopt(data, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof (on)) < 0) {
  749. X            perror("ftptool: setsockopt (reuse address)");
  750. X            goto bad;
  751. X        }
  752. X    if (bind(data, (struct sockaddr *)&data_addr, sizeof (data_addr)) < 0) {
  753. X        perror("ftptool: bind");
  754. X        goto bad;
  755. X    }
  756. /*
  757. X    if (options & SO_DEBUG &&
  758. X        setsockopt(data, SOL_SOCKET, SO_DEBUG, (char *)&on, sizeof (on)) < 0)
  759. X        perror("ftptool: setsockopt (ignored)");
  760. */
  761. X    len = sizeof (data_addr);
  762. X    if (getsockname(data, (struct sockaddr *)&data_addr, &len) < 0) {
  763. X        perror("ftptool: getsockname");
  764. X        goto bad;
  765. X    }
  766. X    if (listen(data, 5) < 0)
  767. X        perror("ftptool: listen");
  768. X    if (sendport) {
  769. X        a = (char *)&data_addr.sin_addr;
  770. #ifdef SYSV386
  771. X    data_port = htons(data_addr.sin_port);
  772. X    p = (char *)&data_port;
  773. X    p[0] += p[1];        /* Switches variables, without a temp var */
  774. X    p[1] = p[0] - p[1];
  775. X    p[0] -= p[1];
  776. #else
  777. X        p = (char *)&data_addr.sin_port;
  778. #endif
  779. #define    UC(b)    (((int)b)&0xff)
  780. X        result =
  781. X            command("PORT %d,%d,%d,%d,%d,%d",
  782. X              UC(a[0]), UC(a[1]), UC(a[2]), UC(a[3]),
  783. X              UC(p[0]), UC(p[1]));
  784. X        if (result == ERROR && sendport == -1) {
  785. X            sendport = 0;
  786. X            tmpno = 1;
  787. X            goto noport;
  788. X        }
  789. X        return (result != COMPLETE);
  790. X    }
  791. X    if (tmpno)
  792. X        sendport = 1;
  793. X    return (0);
  794. bad:
  795. X    (void) close(data), data = -1;
  796. X    if (tmpno)
  797. X        sendport = 1;
  798. X    return (1);
  799. }
  800. X
  801. #ifdef USE_PROTOTYPES
  802. FILE *dataconn(char *lmode)
  803. #else
  804. FILE *dataconn(lmode)
  805. char *lmode;
  806. #endif
  807. {
  808. X    struct sockaddr_in from;
  809. X    int s, fromlen = sizeof (from);
  810. X
  811. restart:
  812. X    s = accept(data, (struct sockaddr *) &from, &fromlen);
  813. X    if (s < 0) {
  814. X        if (errno == EINTR)
  815. X            goto restart;
  816. X        perror("ftptool: accept");
  817. X        (void) close(data);
  818. X        data = -1;
  819. X        return (NULL);
  820. X    }
  821. X    (void) close(data);
  822. X    data = s;
  823. X    return (fdopen(data, lmode));
  824. }
  825. X
  826. #ifdef USE_PROTOTYPES
  827. char *gunique(char *local)
  828. #else
  829. char *gunique(local)
  830. char    *local;
  831. #endif
  832. {
  833. X    static char new[MAXPATHLEN + 1];
  834. X    static char first[MAXPATHLEN + 1], last[MAXNAMLEN + 1];
  835. X    char *slash;
  836. X    int d, count=0;
  837. X    extern char *newname; /* from view_remote_file */
  838. X
  839. X    if ((strlen(local) + 3) > (size_t)MAXPATHLEN) {
  840. X        sprintf(scratch, "Unique name for %s too long.", local);
  841. X        footer_message(scratch, (char *)NULL);
  842. X        log_message(scratch);
  843. X        log_char('\n');
  844. X        return NULL;
  845. X    }
  846. X    slash = rindex(local, '/');
  847. X    if (slash) {
  848. X        *slash = '\0';
  849. X        strcpy(first, local);
  850. X        strcpy(last, slash + 1);
  851. X        *slash = '/';
  852. X    } else {
  853. X        *first = '\0';
  854. X        strcpy(last, local);
  855. X    }
  856. X    d = 0;
  857. X    while (!d) {
  858. X        if (++count == 100) {
  859. X            sprintf(scratch, "Cannot find unique name for %s.", local);
  860. X            footer_message(scratch, (char *)NULL);
  861. X            log_message(scratch);
  862. X            log_char('\n');
  863. X            return NULL;
  864. X        }
  865. X        if (slash)
  866. X            sprintf(new, "%s/%02d.%s", first, count, last);
  867. X        else
  868. X            sprintf(new, "%02d.%s", count, last);
  869. X        if ((d = access(new, 0)) < 0)
  870. X            break;
  871. X    }
  872. X        
  873. X    newname = new;
  874. X    footer_message("Unique name %s generated.", new, (char *)NULL);
  875. X    return new ;
  876. }
  877. X
  878. #ifdef USE_PROTOTYPES
  879. void abort_remote(FILE *din)
  880. #else
  881. void abort_remote(din)
  882. FILE *din;
  883. #endif
  884. {
  885. X    char buf[BUFSIZ];
  886. X    int nfnd;
  887. X    fd_set mask;
  888. X    int    rval;
  889. X
  890. X    /*
  891. X     * send IAC in urgent mode instead of DM because 4.3BSD places oob mark
  892. X     * after urgent byte rather than before as is protocol now
  893. X     */
  894. X    sprintf(buf, "%c%c%c", IAC, IP, IAC);
  895. restart:
  896. X    rval = send(fileno(commandfp), buf, 3, MSG_OOB);
  897. X    if (rval == -1 && errno == EINTR)
  898. X        goto restart;
  899. X    if (rval != 3)
  900. X        perror("abort_remote1");
  901. X    fprintf(commandfp,"%cABOR\r\n", DM);
  902. X    (void) fflush(commandfp);
  903. X    FD_ZERO(&mask);
  904. X    FD_SET(fileno(responsefp), &mask);
  905. X    if (din) { 
  906. X        FD_SET(fileno(din), &mask);
  907. X    }
  908. X    if ((nfnd = empty(&mask, 10)) <= 0) {
  909. X        if (nfnd < 0) {
  910. X            perror("abort_remote2");
  911. X        }
  912. X        /*
  913. X        if (ptabflg)
  914. X            code = -1;
  915. X        */
  916. X        lostpeer();
  917. X    }
  918. X    if (din && FD_ISSET(fileno(din), &mask)) {
  919. X        while (read(fileno(din), buf, BUFSIZ) > 0)
  920. X            /* LOOP */;
  921. X    }
  922. X    if (getreply(0) == ERROR && code == 552) {
  923. X        /* 552 needed for nic style abort */
  924. X        (void) getreply(0);
  925. X    }
  926. X    (void) getreply(0);
  927. }
  928. X
  929. #ifdef USE_PROTOTYPES
  930. void lostpeer(void)
  931. #else
  932. void lostpeer()
  933. #endif
  934. {
  935. X 
  936. X    if (connected) {
  937. X        if (commandfp != NULL) {
  938. X            (void) shutdown(fileno(commandfp), 1+1);
  939. X            (void) fclose(commandfp);
  940. X            commandfp = NULL;
  941. X        }
  942. X        if (data >= 0) {
  943. X            (void) shutdown(data, 1+1);
  944. X            (void) close(data);
  945. X            data = -1;
  946. X        }
  947. X        connected = 0;
  948. X    }
  949. }
  950. X
  951. #ifdef USE_PROTOTYPES
  952. FILE *open_remote_ls(int nlst)
  953. #else
  954. FILE *open_remote_ls(nlst)
  955. int    nlst;
  956. #endif
  957. {
  958. X    char    *ftperr;
  959. X    char    *cmd;
  960. X    FILE *din = 0;
  961. X    char *gunique();
  962. X    off_t lseek();
  963. X
  964. X    if (nlst)
  965. X        cmd = "NLST"; /* dir */
  966. X    else
  967. X        cmd = "LIST"; /* ls */
  968. X
  969. X    settype(ASCII);
  970. X    if (initconn()) {
  971. X        code = -1;
  972. X        return NULL;
  973. X    }
  974. X    if (command_dataconn(&din, "r", "%s", cmd) != PRELIM) {
  975. #ifdef notdef
  976. X    if (command("%s", cmd) != PRELIM) {
  977. #endif
  978. X        if (code == 530) {
  979. X            /* 530 You must define working directory with CWD */
  980. X            ftperr = ftp_error(' ', "cd somewhere first or invalid directory");
  981. X        } else if (code == 550) {
  982. X            /* 550 No files found. */
  983. X            ftperr = ftp_error(' ', "No files found.");
  984. X        } else
  985. X            ftperr = "Unknown error.";
  986. X        footer_message(ftperr, (char *)NULL);
  987. X        return NULL;
  988. X    }
  989. #ifdef notdef
  990. X    din = dataconn("r");
  991. #endif
  992. X    if (din == NULL)
  993. X        return NULL;
  994. X    return din;
  995. }
  996. X
  997. #ifdef USE_PROTOTYPES
  998. char *next_remote_line(FILE *din)
  999. #else
  1000. char *next_remote_line(din)
  1001. FILE    *din;
  1002. #endif
  1003. {
  1004. X    char    *str = response_line;
  1005. X    char    *cptr = str;
  1006. X    int        c;
  1007. X
  1008. X    notify_do_dispatch();
  1009. X    while ((c = getc(din)) != '\n' && c != EOF && c != '\0') {
  1010. X        if (c == '\r')
  1011. X            continue;
  1012. X        *cptr++ = (char)c;
  1013. X    }
  1014. X    *cptr = '\0';
  1015. X    notify_no_dispatch();
  1016. X    if (c == EOF)
  1017. X        return NULL;
  1018. X    return str;
  1019. }
  1020. X
  1021. #ifdef USE_PROTOTYPES
  1022. void close_remote_ls(FILE *din)
  1023. #else
  1024. void close_remote_ls(din)
  1025. FILE    *din;
  1026. #endif
  1027. {
  1028. X    if (ferror(din))
  1029. X        perror("netin");
  1030. X    (void) fclose(din);
  1031. X    (void) getreply(0);
  1032. X    return;
  1033. }
  1034. X
  1035. struct    types {
  1036. X    char    *t_name;
  1037. X    char    *t_mode;
  1038. X    int    t_type;
  1039. X    char    *t_arg;
  1040. } types[] = {
  1041. X    { "binary",    "I",    TYPE_I,    0 },
  1042. X    { "ascii",    "A",    TYPE_A,    0 },
  1043. X    { "tenex",    "L",    TYPE_L,    "8" },
  1044. /*
  1045. X    { "image",    "I",    TYPE_I,    0 },
  1046. X    { "ebcdic",    "E",    TYPE_E,    0 },
  1047. */
  1048. };
  1049. X
  1050. /*
  1051. X * Set transfer type.
  1052. X */
  1053. #ifdef USE_PROTOTYPES
  1054. void settype(int type)
  1055. #else
  1056. void settype(type)
  1057. int    type;
  1058. #endif
  1059. {
  1060. X    register struct types *p;
  1061. X    int comret;
  1062. X
  1063. X    if (type > (sizeof(types)/sizeof(types[0]))) {
  1064. X        printf("%d: unknown mode\n", type);
  1065. X        code = -1;
  1066. X        return;
  1067. X    }
  1068. X    /* make sure values in window match table! */
  1069. X    p = &types[type];
  1070. X
  1071. X    if ((p->t_arg != NULL) && (*(p->t_arg) != '\0'))
  1072. X        comret = command ("TYPE %s %s", p->t_mode, p->t_arg);
  1073. X    else
  1074. X        comret = command("TYPE %s", p->t_mode);
  1075. X    if (comret == COMPLETE) {
  1076. X        curtype = p->t_type;
  1077. X    }
  1078. }
  1079. SHAR_EOF
  1080. echo 'File ftp.c is complete' &&
  1081. chmod 0644 ftp.c ||
  1082. echo 'restore of ftp.c failed'
  1083. Wc_c="`wc -c < 'ftp.c'`"
  1084. test 30712 -eq "$Wc_c" ||
  1085.     echo 'ftp.c: original size 30712, current size' "$Wc_c"
  1086. rm -f _shar_wnt_.tmp
  1087. fi
  1088. # ============= host_list.c ==============
  1089. if test -f 'host_list.c' -a X"$1" != X"-c"; then
  1090.     echo 'x - skipping host_list.c (File already exists)'
  1091.     rm -f _shar_wnt_.tmp
  1092. else
  1093. > _shar_wnt_.tmp
  1094. echo 'x - extracting host_list.c (Text)'
  1095. sed 's/^X//' << 'SHAR_EOF' > 'host_list.c' &&
  1096. #include "ftptool.h"
  1097. X
  1098. #ifdef USE_PROTOTYPES
  1099. void host_list_clean_proc(Panel_item item, Event *event)
  1100. #else
  1101. void host_list_clean_proc(item, event)
  1102. Panel_item    item;
  1103. Event    *event;
  1104. #endif
  1105. {
  1106. X    xv_set(host_window.advanced.alias, 
  1107. X        PANEL_VALUE, "", 
  1108. X        NULL);
  1109. X    xv_set(host_window.advanced.last_visited, 
  1110. X        PANEL_LABEL_STRING, "Never", 
  1111. X        NULL);
  1112. X    xv_set(host_window.basic.host, 
  1113. X        PANEL_VALUE, "", 
  1114. X        NULL);
  1115. X    if (!strcmp((char *)xv_get(item, PANEL_LABEL_STRING), "New")) {
  1116. X        xv_set(host_window.basic.login, 
  1117. X            PANEL_VALUE, "", 
  1118. X            NULL);
  1119. X        xv_set(host_window.basic.password, 
  1120. X            PANEL_VALUE, "", 
  1121. X            NULL);
  1122. X    } else {
  1123. X        xv_set(host_window.basic.login, 
  1124. X            PANEL_VALUE, "anonymous", 
  1125. X            NULL);
  1126. X        xv_set(host_window.basic.password, 
  1127. X            PANEL_VALUE, anonftp_password, 
  1128. X            NULL);
  1129. X        xv_set(host_window.basic.panel,
  1130. X            PANEL_CARET_ITEM, host_window.basic.host,
  1131. X            NULL);
  1132. X    }
  1133. X    xv_set(host_window.advanced.proxy, 
  1134. X        PANEL_VALUE, DEFAULT_PROXY, 
  1135. X        NULL);
  1136. X    xv_set(host_window.advanced.transfer_mode, 
  1137. X        PANEL_VALUE, BINARY, 
  1138. X        NULL);
  1139. X    xv_set(host_window.advanced.remote_auto_cd, 
  1140. X        PANEL_VALUE, ".", 
  1141. X        NULL);
  1142. X    xv_set(host_window.advanced.local_auto_cd, 
  1143. X        PANEL_VALUE, ".", 
  1144. X        NULL);
  1145. X    xv_set(host_window.advanced.dir_parse, 
  1146. X        PANEL_VALUE, DEFAULT_PARSE, 
  1147. X        NULL);
  1148. X    xv_set(host_window.advanced.comment, 
  1149. X        PANEL_VALUE, "", 
  1150. X        NULL);
  1151. X
  1152. X    if (try_proxy) {
  1153. X        xv_set(host_window.advanced.proxy, 
  1154. X            XV_SHOW, TRUE, 
  1155. X            NULL);
  1156. X    } else {
  1157. X        xv_set(host_window.advanced.proxy, 
  1158. X            XV_SHOW, FALSE, 
  1159. X            NULL);
  1160. X    }
  1161. X    xv_set(item, 
  1162. X        PANEL_NOTIFY_STATUS, XV_ERROR, 
  1163. X        NULL);
  1164. }
  1165. X
  1166. #ifdef USE_PROTOTYPES
  1167. void host_list_item_proc(Menu menu, Menu_item menu_item)
  1168. #else
  1169. void host_list_item_proc(menu, menu_item)
  1170. Menu    menu;
  1171. Menu_item menu_item;
  1172. #endif
  1173. {
  1174. X    char    *alias = (char *)xv_get(menu_item, MENU_STRING);
  1175. X    struct    hostlist *tmp;
  1176. X
  1177. X    tmp = gethostlist(hostlist_head, alias);
  1178. X    if (tmp == NULL) {
  1179. X        fprintf(stderr, "Entry %s in menu not found in list.\n", alias);
  1180. X        exit(1);
  1181. X    }
  1182. X    xv_set(host_window.advanced.alias, 
  1183. X        PANEL_VALUE, tmp->aliasname, 
  1184. X        NULL);
  1185. X    xv_set(host_window.advanced.last_visited, 
  1186. X        PANEL_LABEL_STRING, tmp->last_visited, 
  1187. X        NULL);
  1188. X    xv_set(host_window.basic.host, 
  1189. X        PANEL_VALUE, tmp->host, 
  1190. X        NULL);
  1191. X    xv_set(host_window.basic.login, 
  1192. X        PANEL_VALUE, tmp->login, 
  1193. X        NULL);
  1194. X    xv_set(host_window.basic.password, 
  1195. X        PANEL_VALUE, tmp->password, 
  1196. X        NULL);
  1197. X    xv_set(host_window.advanced.proxy, 
  1198. X        PANEL_VALUE, tmp->proxy, 
  1199. X        NULL);
  1200. X    xv_set(host_window.advanced.transfer_mode, 
  1201. X        PANEL_VALUE, tmp->transfer_mode, 
  1202. X        NULL);
  1203. X    xv_set(host_window.advanced.remote_auto_cd, 
  1204. X        PANEL_VALUE, tmp->remote_directory, 
  1205. X        NULL);
  1206. X    xv_set(host_window.advanced.local_auto_cd, 
  1207. X        PANEL_VALUE, tmp->local_directory, 
  1208. X        NULL);
  1209. X    xv_set(host_window.advanced.dir_parse, 
  1210. X        PANEL_VALUE, tmp->dir_parse, 
  1211. X        NULL);
  1212. X    xv_set(host_window.advanced.comment, 
  1213. X        PANEL_VALUE, tmp->comment, 
  1214. X        NULL);
  1215. X
  1216. X    if (try_proxy) {
  1217. X        xv_set(host_window.advanced.proxy, 
  1218. X            XV_SHOW, TRUE, 
  1219. X            NULL);
  1220. X    } else {
  1221. X        xv_set(host_window.advanced.proxy, 
  1222. X            XV_SHOW, FALSE, 
  1223. X            NULL);
  1224. X    }
  1225. X    xv_set(menu, 
  1226. X        MENU_NOTIFY_STATUS, XV_ERROR, 
  1227. X        NULL);
  1228. X    if (!connected && auto_connect == TRUE) {
  1229. X        dowhat = DOCONNECT;
  1230. X        notify_stop();
  1231. X    }
  1232. }
  1233. X
  1234. X
  1235. #ifdef USE_PROTOTYPES
  1236. void host_list_add_proc(Menu menu, Menu_item menu_item)
  1237. #else
  1238. void host_list_add_proc(menu, menu_item)
  1239. Menu    menu;
  1240. Menu_item menu_item;
  1241. #endif
  1242. {
  1243. X    enter_host_info(1);
  1244. X    xv_set(menu, 
  1245. X        MENU_NOTIFY_STATUS, XV_ERROR, 
  1246. X        NULL);
  1247. }
  1248. X
  1249. #ifdef USE_PROTOTYPES
  1250. void host_list_change_proc(Menu menu, Menu_item menu_item)
  1251. #else
  1252. void host_list_change_proc(menu, menu_item)
  1253. Menu    menu;
  1254. Menu_item menu_item;
  1255. #endif
  1256. {
  1257. X    enter_host_info(0);
  1258. X    xv_set(menu, 
  1259. X        MENU_NOTIFY_STATUS, XV_ERROR, 
  1260. X        NULL);
  1261. }
  1262. X
  1263. #ifdef USE_PROTOTYPES
  1264. void    host_save_proc(Menu menu, Menu_item menu_item)
  1265. #else
  1266. void    host_save_proc(menu, menu_item)
  1267. Menu    menu;
  1268. Menu_item    menu_item;
  1269. #endif
  1270. {
  1271. X    write_ftptoolrc();
  1272. X    list_changed = 0;
  1273. X    timestamped = 0;
  1274. X    reload_host_list_menu(hostlist_head);
  1275. X    xv_set(menu, 
  1276. X        MENU_NOTIFY_STATUS, XV_ERROR, 
  1277. X        NULL);
  1278. }
  1279. X
  1280. #ifdef USE_PROTOTYPES
  1281. void    host_load_proc(Menu menu, Menu_item menu_item)
  1282. #else
  1283. void    host_load_proc(menu, menu_item)
  1284. Menu    menu;
  1285. Menu_item    menu_item;
  1286. #endif
  1287. {
  1288. X    int answer;
  1289. #ifdef XVIEW3
  1290. X    Xv_notice    notice;
  1291. #endif
  1292. X
  1293. X    if (timestamped || list_changed) {
  1294. #ifdef XVIEW3
  1295. X        notice = xv_create(host_window.panel, NOTICE,
  1296. X            NOTICE_MESSAGE_STRINGS,
  1297. X                "Your host list has changed since the last save.",
  1298. X                "Really load original?",
  1299. X                NULL,
  1300. X            NOTICE_BUTTON_YES, "Yes",
  1301. X            NOTICE_BUTTON_NO, "No",
  1302. X            NOTICE_STATUS, &answer,
  1303. X            XV_SHOW, TRUE,
  1304. X            NULL);
  1305. X        xv_destroy_safe(notice);
  1306. #else
  1307. X        answer = notice_prompt(host_window.panel, NULL,
  1308. X            NOTICE_MESSAGE_STRINGS,
  1309. X                "Your host list has changed since the last save.",
  1310. X                "Really load original?",
  1311. X                NULL,
  1312. X            NOTICE_BUTTON_YES, "Yes",
  1313. X            NOTICE_BUTTON_NO, "No",
  1314. X            NULL);
  1315. #endif
  1316. X        if (answer != NOTICE_YES)
  1317. X            return;
  1318. X    }
  1319. X    free_hostlist(hostlist_head);
  1320. X    hostlist_head = new_hostlist();
  1321. X    read_ftptoolrc();
  1322. X    list_changed = 0;
  1323. X    timestamped = 0;
  1324. X    reload_host_list_menu(hostlist_head);
  1325. X    xv_set(menu, 
  1326. X        MENU_NOTIFY_STATUS, XV_ERROR, 
  1327. X        NULL);
  1328. }
  1329. X
  1330. #ifdef USE_PROTOTYPES
  1331. void update_timestamp(void)
  1332. #else
  1333. void update_timestamp()
  1334. #endif
  1335. {
  1336. X    time_t    t;
  1337. X    time_t    time();
  1338. X    char    *ctime();
  1339. X    char    *s, *nl;
  1340. X    char    *aliasname;
  1341. X    struct hostlist *tmp;
  1342. X
  1343. X    t = time((time_t *)NULL);
  1344. X    s = ctime(&t);
  1345. X    if (nl = index(s, '\n'))
  1346. X        *nl = '\0';
  1347. X    xv_set(host_window.advanced.last_visited,
  1348. X        PANEL_LABEL_STRING, s,
  1349. X        NULL);
  1350. X    aliasname = (char *)xv_get(host_window.advanced.alias, PANEL_VALUE);
  1351. X    tmp = gethostlist(hostlist_head, aliasname);
  1352. X    if (tmp == NULL) {
  1353. X        return;
  1354. X    }
  1355. X    free(tmp->last_visited);
  1356. X    tmp->last_visited = strdup(s);
  1357. X    if (tmp->last_visited == NULL) {
  1358. X        fprintf(stderr, "Out of memory.\n");
  1359. X        goto out;
  1360. X    }
  1361. X
  1362. X    timestamped++;
  1363. out:
  1364. X    return;
  1365. }
  1366. X
  1367. #ifdef USE_PROTOTYPES
  1368. void enter_host_info(int warnchange)
  1369. #else
  1370. void enter_host_info(warnchange)
  1371. int        warnchange;
  1372. #endif
  1373. {
  1374. X    char    *aliasname;
  1375. X    char    *last_visited="Never";
  1376. X    char     *proxy;
  1377. X    char     *host;
  1378. X    char    *login;
  1379. X    char    *password;
  1380. X    char    *comment;
  1381. X    int        transfer_mode;
  1382. X    char    *remote_directory;
  1383. X    char    *local_directory;
  1384. X    char    *dir_parse;
  1385. X    int        answer;
  1386. #ifdef XVIEW3
  1387. X    Xv_notice notice;
  1388. #endif
  1389. X
  1390. X    aliasname = (char *)xv_get(host_window.advanced.alias, PANEL_VALUE);
  1391. X    if (aliasname[0] == '\0') {
  1392. X        xv_set(host_window.frame, 
  1393. X            FRAME_SHOW_FOOTER, TRUE, 
  1394. X            FRAME_LEFT_FOOTER, "Please specify an alias name.",
  1395. X            NULL);
  1396. X        goto out;
  1397. X    }
  1398. X    proxy = (char *)xv_get(host_window.advanced.proxy, PANEL_VALUE);
  1399. X    host = (char *)xv_get(host_window.basic.host, PANEL_VALUE);
  1400. X    login = (char *)xv_get(host_window.basic.login, PANEL_VALUE);
  1401. X    password = (char *)xv_get(host_window.basic.password, PANEL_VALUE);
  1402. X    transfer_mode = xv_get(host_window.advanced.transfer_mode, PANEL_VALUE);
  1403. X    remote_directory = (char *)xv_get(host_window.advanced.remote_auto_cd, 
  1404. X        PANEL_VALUE);
  1405. X    local_directory = (char *)xv_get(host_window.advanced.local_auto_cd, 
  1406. X        PANEL_VALUE);
  1407. X    dir_parse = (char *)xv_get(host_window.advanced.dir_parse, PANEL_VALUE);
  1408. X    comment = (char *)xv_get(host_window.advanced.comment, PANEL_VALUE);
  1409. X
  1410. X    if (gethostlist(hostlist_head, aliasname)) {
  1411. X        if (warnchange) {
  1412. #ifdef XVIEW3
  1413. X            notice = xv_create(host_window.panel, NOTICE,
  1414. X                NOTICE_MESSAGE_STRINGS,
  1415. X                    "That alias exists. Do you really want to change it?",
  1416. X                    NULL,
  1417. X                NOTICE_BUTTON_YES, "Yes",
  1418. X                NOTICE_BUTTON_NO, "No",
  1419. X                NOTICE_STATUS, &answer,
  1420. X                XV_SHOW, TRUE,
  1421. X                NULL);
  1422. X            xv_destroy_safe(notice);
  1423. #else
  1424. X            answer = notice_prompt(host_window.panel, NULL,
  1425. X                NOTICE_MESSAGE_STRINGS,
  1426. X                    "That alias exists. Do you really want to change it?",
  1427. X                    NULL,
  1428. X                NOTICE_BUTTON_YES, "Yes",
  1429. X                NOTICE_BUTTON_NO, "No",
  1430. X                NULL);
  1431. #endif
  1432. X            if (answer != NOTICE_YES)
  1433. X                goto out;
  1434. X        }
  1435. X        last_visited = (char *)xv_get(host_window.advanced.last_visited, 
  1436. X            PANEL_LABEL_STRING);
  1437. X        delete_hostlist(hostlist_head, aliasname);
  1438. X    }
  1439. X    if ((hostlist_head = add_hostalias(hostlist_head, aliasname, 
  1440. X        last_visited, proxy, host, login, password, transfer_mode,
  1441. X        remote_directory, local_directory, dir_parse, comment)) == NULL) {
  1442. X        xv_set(host_window.frame, 
  1443. X            FRAME_SHOW_FOOTER, TRUE, 
  1444. X            FRAME_LEFT_FOOTER, "Add failed.",
  1445. X            NULL);
  1446. X        goto out;
  1447. X    }
  1448. X    list_changed++;
  1449. X    reload_host_list_menu(hostlist_head);
  1450. out:
  1451. X    return;
  1452. }
  1453. X
  1454. #ifdef USE_PROTOTYPES
  1455. void host_list_delete_proc(Menu menu, Menu_item menu_item)
  1456. #else
  1457. void host_list_delete_proc(menu, menu_item)
  1458. Menu    menu;
  1459. Menu_item menu_item;
  1460. #endif
  1461. {
  1462. X    char    *aliasname;
  1463. X
  1464. X    aliasname = (char *)xv_get(host_window.advanced.alias, PANEL_VALUE);
  1465. X
  1466. X    if (gethostlist(hostlist_head, aliasname) == NULL) {
  1467. X        xv_set(host_window.frame, 
  1468. X            FRAME_SHOW_FOOTER, TRUE, 
  1469. X            FRAME_LEFT_FOOTER, "No such alias",
  1470. X            NULL);
  1471. X        return;
  1472. X    }
  1473. X    delete_hostlist(hostlist_head, aliasname);
  1474. X    list_changed++;
  1475. X    reload_host_list_menu(hostlist_head);
  1476. X    xv_set(menu, 
  1477. X        MENU_NOTIFY_STATUS, XV_ERROR, 
  1478. X        NULL);
  1479. }
  1480. X
  1481. #ifdef USE_PROTOTYPES
  1482. int host_list_use_proc(Panel_item item, char *string, 
  1483. X    Xv_opaque client_data, Panel_list_op op, Event *event)
  1484. #else
  1485. int host_list_use_proc(item,string,client_data,op,event)
  1486. Panel_item        item;
  1487. char            *string;
  1488. XXv_opaque        client_data;
  1489. Panel_list_op   op;
  1490. Event            *event;
  1491. #endif
  1492. {
  1493. X    struct hostlist *tmp;
  1494. X
  1495. X    switch(op) {
  1496. X    case PANEL_LIST_OP_SELECT:
  1497. X        tmp = gethostlist(hostlist_head, string);
  1498. X        if (tmp == NULL) {
  1499. X            fprintf(stderr, "gethostlist failed in select\n");
  1500. X            return XV_ERROR;
  1501. X        }
  1502. X        xv_set(host_window.advanced.alias, 
  1503. X            PANEL_VALUE, tmp->aliasname, 
  1504. X            NULL);
  1505. X        xv_set(host_window.advanced.last_visited, 
  1506. X            PANEL_LABEL_STRING, tmp->last_visited, 
  1507. X            NULL);
  1508. X        if (try_proxy) {
  1509. X            xv_set(host_window.advanced.proxy, 
  1510. X                XV_SHOW, TRUE, 
  1511. X                NULL);
  1512. X        } else {
  1513. X            xv_set(host_window.advanced.proxy, 
  1514. X                XV_SHOW, FALSE, 
  1515. X                NULL);
  1516. X        }
  1517. X        xv_set(host_window.basic.host, 
  1518. X            PANEL_VALUE, tmp->host, 
  1519. X            NULL);
  1520. X        xv_set(host_window.basic.login, 
  1521. X            PANEL_VALUE, tmp->login, 
  1522. X            NULL);
  1523. X        xv_set(host_window.basic.password, 
  1524. X            PANEL_VALUE, tmp->password, 
  1525. X            NULL);
  1526. X        xv_set(host_window.advanced.transfer_mode, 
  1527. X            PANEL_VALUE, tmp->transfer_mode, 
  1528. X            NULL);
  1529. X        xv_set(host_window.advanced.remote_auto_cd, 
  1530. X            PANEL_VALUE, tmp->remote_directory, 
  1531. X            NULL);
  1532. X        xv_set(host_window.advanced.local_auto_cd, 
  1533. X            PANEL_VALUE, tmp->local_directory, 
  1534. X            NULL);
  1535. X        xv_set(host_window.advanced.dir_parse, 
  1536. X            PANEL_VALUE, tmp->dir_parse, 
  1537. X            NULL);
  1538. X        xv_set(host_window.advanced.comment, 
  1539. X            PANEL_VALUE, tmp->comment, 
  1540. X            NULL);
  1541. X        break;
  1542. X    case PANEL_LIST_OP_DESELECT:
  1543. X        break;
  1544. X    default:
  1545. X        break;
  1546. X    }
  1547. X
  1548. X    return XV_OK;
  1549. }
  1550. X
  1551. #ifdef USE_PROTOTYPES
  1552. struct hostlist *new_hostlist(void)
  1553. #else
  1554. struct hostlist *new_hostlist()
  1555. #endif
  1556. {
  1557. X    struct hostlist *tmp;
  1558. X
  1559. X    tmp = (struct hostlist *)malloc(sizeof(struct hostlist));
  1560. X    if (tmp == NULL)
  1561. X        return NULL;
  1562. X    bzero((char *)tmp, sizeof(struct hostlist));
  1563. X    tmp->next = NULL;
  1564. X    tmp->aliasname = NULL;
  1565. X    tmp->last_visited = NULL;
  1566. X    tmp->proxy = NULL;
  1567. X    tmp->host = NULL;
  1568. X    tmp->login = NULL;
  1569. X    tmp->password = NULL;
  1570. X    tmp->remote_directory = NULL;
  1571. X    tmp->local_directory = NULL;
  1572. X    tmp->dir_parse = NULL;
  1573. X    tmp->comment = NULL;
  1574. X    return tmp;
  1575. }
  1576. X
  1577. #ifdef USE_PROTOTYPES
  1578. struct hostlist *add_hostalias(struct hostlist *head, char *aliasname, 
  1579. X    char *last_visited, char *proxy, char *host, char *login, 
  1580. X    char *password, int transfer_mode, char *remote_directory, 
  1581. X    char *local_directory, char *dir_parse, char *comment)
  1582. #else
  1583. struct hostlist *add_hostalias(head, aliasname, last_visited, proxy, 
  1584. X    host, login, password, transfer_mode, remote_directory, 
  1585. X    local_directory, dir_parse, comment)
  1586. struct hostlist *head;
  1587. char    *aliasname;
  1588. char    *last_visited;
  1589. char    *proxy;
  1590. char    *host;
  1591. char    *login;
  1592. char    *password;
  1593. int        transfer_mode;
  1594. char    *remote_directory;
  1595. char    *local_directory;
  1596. char    *dir_parse;
  1597. char    *comment;
  1598. #endif
  1599. {
  1600. X    struct hostlist *tmp;
  1601. X    struct hostlist *oldnext;
  1602. X    int        rval = 0;
  1603. X
  1604. X    /* add in sorted order */
  1605. X    for (tmp = head; tmp->next != NULL; tmp = tmp->next)  {
  1606. X        if (ignore_case)
  1607. X            rval = strcasecmp(aliasname, tmp->next->aliasname);
  1608. X        else
  1609. X            rval = strcmp(aliasname, tmp->next->aliasname);
  1610. X        if (rval < 0)
  1611. X            break;
  1612. X    }
  1613. X    oldnext = tmp->next;
  1614. X    tmp->next = new_hostlist();
  1615. X    if (tmp->next == NULL) {
  1616. X        tmp->next = oldnext;
  1617. X        return NULL;
  1618. X    }
  1619. X
  1620. X    tmp->next->aliasname = strdup(aliasname);
  1621. X    if (tmp->next->aliasname == NULL) {
  1622. X        goto out;
  1623. X    }
  1624. X
  1625. X    tmp->next->last_visited = strdup(last_visited);
  1626. X    if (tmp->next->last_visited == NULL) {
  1627. X        goto out;
  1628. X    }
  1629. X
  1630. X    tmp->next->proxy = strdup(proxy);
  1631. X    if (tmp->next->proxy == NULL) {
  1632. X        goto out;
  1633. X    }
  1634. X
  1635. X    tmp->next->host = strdup(host);
  1636. X    if (tmp->next->host == NULL) {
  1637. X        goto out;
  1638. X    }
  1639. X
  1640. X    tmp->next->login = strdup(login);
  1641. X    if (tmp->next->login == NULL) {
  1642. X        goto out;
  1643. X    }
  1644. X
  1645. X    tmp->next->password = strdup(password);
  1646. X    if (tmp->next->password == NULL) {
  1647. X        goto out;
  1648. X    }
  1649. X
  1650. X    tmp->next->transfer_mode = transfer_mode;
  1651. X
  1652. X    tmp->next->remote_directory = strdup(remote_directory);
  1653. X    if (tmp->next->remote_directory == NULL) {
  1654. X        goto out;
  1655. X    }
  1656. X
  1657. X    tmp->next->local_directory = strdup(local_directory);
  1658. X    if (tmp->next->local_directory == NULL) {
  1659. X        goto out;
  1660. X    }
  1661. X
  1662. X    tmp->next->dir_parse = strdup(dir_parse);
  1663. X    if (tmp->next->dir_parse == NULL) {
  1664. X        goto out;
  1665. X    }
  1666. X
  1667. X    tmp->next->comment = strdup(comment);
  1668. X    if (tmp->next->comment == NULL) {
  1669. X        goto out;
  1670. X    }
  1671. X
  1672. X    tmp->next->next = oldnext;
  1673. X    return head;
  1674. out:
  1675. X    tmp->next->next = NULL;
  1676. X    free_hostlist(tmp->next);
  1677. X    tmp->next = oldnext;
  1678. X    return NULL;
  1679. }
  1680. X
  1681. #ifdef USE_PROTOTYPES
  1682. void free_hostlist(struct hostlist *head)
  1683. #else
  1684. void free_hostlist(head)
  1685. struct hostlist *head;
  1686. #endif
  1687. {
  1688. X    struct hostlist *tmp;
  1689. X
  1690. X    while (head) {
  1691. X        tmp = head->next;
  1692. X        if (head->aliasname)
  1693. X            free(head->aliasname);
  1694. X        if (head->last_visited)
  1695. X            free(head->last_visited);
  1696. X        if (head->proxy)
  1697. X            free(head->proxy);
  1698. X        if (head->host)
  1699. X            free(head->host);
  1700. X        if (head->login)
  1701. X            free(head->login);
  1702. X        if (head->password)
  1703. X            free(head->password);
  1704. X        if (head->remote_directory)
  1705. X            free(head->remote_directory);
  1706. X        if (head->local_directory)
  1707. X            free(head->local_directory);
  1708. X        if (head->dir_parse)
  1709. X            free(head->dir_parse);
  1710. X        if (head->comment)
  1711. X            free(head->comment);
  1712. X        free((char *)head);
  1713. X        head = tmp;
  1714. X    }
  1715. }
  1716. X
  1717. #ifdef USE_PROTOTYPES
  1718. struct hostlist *gethostlist(struct hostlist *head, char *aliasname)
  1719. #else
  1720. struct hostlist *gethostlist(head, aliasname)
  1721. struct hostlist *head;
  1722. char    *aliasname;
  1723. #endif
  1724. {
  1725. X    struct hostlist *tmp;
  1726. X
  1727. X    for (tmp = head->next; tmp != NULL; tmp = tmp->next)
  1728. X        if (!strcmp(aliasname, tmp->aliasname)) 
  1729. X            return tmp;
  1730. X    return NULL;
  1731. }
  1732. X
  1733. #ifdef USE_PROTOTYPES
  1734. int delete_hostlist(struct hostlist *head, char *aliasname)
  1735. #else
  1736. int delete_hostlist(head, aliasname)
  1737. struct hostlist *head;
  1738. char    *aliasname;
  1739. #endif
  1740. {
  1741. X    struct hostlist *tmp;
  1742. X    struct hostlist *tmp2;
  1743. X
  1744. X    for (tmp = head; tmp->next != NULL; tmp = tmp->next) {
  1745. X        if (!strcmp(aliasname, tmp->next->aliasname)) {
  1746. X            /* delete existing entry */
  1747. X            tmp2 = tmp->next->next;
  1748. X            tmp->next->next = NULL;
  1749. X            free_hostlist(tmp->next);
  1750. X            tmp->next = tmp2;
  1751. X            return 1;
  1752. X        }
  1753. X    }
  1754. X    return 0;
  1755. }
  1756. X
  1757. #ifdef USE_PROTOTYPES
  1758. void read_ftptoolrc(void)
  1759. #else
  1760. void read_ftptoolrc()
  1761. #endif
  1762. {
  1763. X    int    fd;
  1764. X    static char    aliasname[MAXCOMMENTLEN + 1];
  1765. X    static char    host[MAXHOSTNAMELEN + 1];
  1766. X    static char    login[MAXLOGINLEN + 1];
  1767. X    static char    password[MAXHOSTNAMELEN + 1];
  1768. X    static char    comment[MAXCOMMENTLEN + 1];
  1769. X    FILE    *fp;
  1770. X    int ch;
  1771. X
  1772. X    fd = ftptoolrc_fd(O_RDONLY, 0600);
  1773. X    if (fd == -1) {
  1774. X        if (netrc_filename)
  1775. X            host_append_netrc_proc();
  1776. X        return;
  1777. X    }
  1778. X    /* ftptoolrc file format */
  1779. X    /*
  1780. X     Alias
  1781. X     direct (ignored)
  1782. X     host
  1783. X     login
  1784. X     password
  1785. X     Comment
  1786. X     */
  1787. X    fp = fdopen(fd, "r");
  1788. X    if (fp == NULL) {
  1789. X        close(fd);
  1790. X        return;
  1791. X    }
  1792. X    /* see if it's a 'new' format */
  1793. X    ch = getc(fp);
  1794. X    if (ch == '#') {
  1795. X        fclose(fp);
  1796. X        read_newftptoolrc();
  1797. X        return;
  1798. X    }
  1799. X    ungetc(ch, fp);
  1800. X    while (read_entry(0, fp,aliasname,(char *)NULL, (char *)NULL,
  1801. X        host,login, password,(int *)NULL, (char *)NULL, (char *)NULL, 
  1802. X        DEFAULT_PARSE, comment))
  1803. X            if (add_hostalias(hostlist_head, aliasname, "Never", 
  1804. X                DEFAULT_PROXY, host, login, password, BINARY,
  1805. X                ".", ".", DEFAULT_PARSE, comment) == NULL)
  1806. X                    break;
  1807. X    fclose(fp);
  1808. }
  1809. X
  1810. #ifdef USE_PROTOTYPES
  1811. int read_entry(int version, FILE *fp, char *aliasname, char *last_visited, 
  1812. X    char *proxy, char *host, char *login, char *password, int *transfer_mode, 
  1813. X    char *rdir, char *ldir, char *dir_parse, char *comment)
  1814. #else
  1815. int read_entry(version, fp, aliasname, last_visited, proxy, host, 
  1816. X    login, password, transfer_mode, rdir, ldir, dir_parse, comment)
  1817. int        version;
  1818. FILE    *fp;
  1819. char    *aliasname;
  1820. char    *last_visited;
  1821. char    *proxy;
  1822. char    *host;
  1823. char    *login;
  1824. char    *password;
  1825. int        *transfer_mode;
  1826. char    *rdir;
  1827. char    *ldir;
  1828. char    *dir_parse;
  1829. char    *comment;
  1830. #endif
  1831. {
  1832. X    char    *nl;
  1833. X    char    *dpasswd;
  1834. X
  1835. X    if (fgets(aliasname, MAXCOMMENTLEN+1,fp) == NULL) 
  1836. X        if (feof(fp))
  1837. X            return 0;
  1838. X        else
  1839. X            goto out;
  1840. X    if (nl = index(aliasname, '\n'))
  1841. X        *nl = '\0';
  1842. X    if (version > 2) {
  1843. X        if (fgets(last_visited, MAXPATHLEN+1,fp) == NULL) 
  1844. X            goto out;
  1845. X        if (nl = index(last_visited, '\n'))
  1846. X            *nl = '\0';
  1847. X    }
  1848. X    if (fgets(scratch, MAXHOSTNAMELEN+1,fp) == NULL) 
  1849. X        goto out;
  1850. X    if (version > 0) {
  1851. X        if (fgets(proxy, MAXHOSTNAMELEN+1,fp) == NULL) 
  1852. X            goto out;
  1853. X        if (nl = index(proxy, '\n'))
  1854. X            *nl = '\0';
  1855. X    }
  1856. X    if (fgets(host, MAXHOSTNAMELEN+1,fp) == NULL) 
  1857. X        goto out;
  1858. X    if (nl = index(host, '\n'))
  1859. X        *nl = '\0';
  1860. X    if (fgets(login, MAXLOGINLEN+1,fp) == NULL) 
  1861. X        goto out;
  1862. X    if (nl = index(login, '\n'))
  1863. X        *nl = '\0';
  1864. X    if (fgets(password, MAXPASSWORDLEN+1,fp) == NULL) 
  1865. X        goto out;
  1866. X    if (nl = index(password, '\n'))
  1867. X        *nl = '\0';
  1868. X    if (version > 2) {
  1869. X        /* decrypt it */
  1870. X        if (version > 3)
  1871. X            dpasswd = ftptool_decrypt(password, login_name);
  1872. X        else
  1873. X            dpasswd = old_ftptool_decrypt(password, login_name);
  1874. X        if (dpasswd != NULL) {
  1875. X            strcpy(password, dpasswd);
  1876. X            free(dpasswd);
  1877. X        }
  1878. X    } 
  1879. X    if (version > 4) {
  1880. X        if (fgets(scratch, MAXHOSTNAMELEN+1,fp) == NULL) 
  1881. X            goto out;
  1882. X        *transfer_mode = atoi(scratch);
  1883. X    }
  1884. X    if (version > 0) {
  1885. X        if (fgets(rdir, MAXPATHLEN+1,fp) == NULL) 
  1886. X            goto out;
  1887. X        if (nl = index(rdir, '\n'))
  1888. X            *nl = '\0';
  1889. X    }
  1890. X    if (version > 1) {
  1891. X        if (fgets(ldir, MAXPATHLEN+1,fp) == NULL) 
  1892. X            goto out;
  1893. X        if (nl = index(ldir, '\n'))
  1894. X            *nl = '\0';
  1895. X    }
  1896. X    if (version > 2) {
  1897. X        if (fgets(dir_parse, MAXPATHLEN+1,fp) == NULL) 
  1898. X            goto out;
  1899. X        if (nl = index(dir_parse, '\n'))
  1900. X            *nl = '\0';
  1901. X    }
  1902. X    if (fgets(comment, MAXCOMMENTLEN+1,fp) == NULL) 
  1903. X        goto out;
  1904. X    if (nl = index(comment, '\n'))
  1905. X        *nl = '\0';
  1906. X    return 1;
  1907. out:
  1908. X    fprintf(stderr, "bad entry for %s in .netrc\n", aliasname);
  1909. X    return 0;
  1910. }
  1911. X
  1912. #ifdef USE_PROTOTYPES
  1913. void read_newftptoolrc(void)
  1914. #else
  1915. void read_newftptoolrc()
  1916. #endif
  1917. {
  1918. X    int    fd;
  1919. X    static char    aliasname[MAXALIASLEN + 1];
  1920. X    static char    last_visited[41];
  1921. X    static int        transfer_mode;
  1922. X    static char    proxy[MAXHOSTNAMELEN + 1];
  1923. X    static char    host[MAXHOSTNAMELEN + 1];
  1924. X    static char    login[MAXLOGINLEN + 1];
  1925. X    static char    password[MAXPASSWORDLEN + 1];
  1926. X    static char    remote_directory[MAXPATHLEN + 1];
  1927. X    static char    local_directory[MAXPATHLEN + 1];
  1928. X    static char    dir_parse[MAXPATHLEN + 1];
  1929. X    static char    comment[MAXCOMMENTLEN + 1];
  1930. X    FILE    *fp;
  1931. X    int    version, patch;
  1932. X    int    list_version;
  1933. X
  1934. X    fd = ftptoolrc_fd(O_RDONLY, 0600);
  1935. X    if (fd == -1) {
  1936. X        if (netrc_filename)
  1937. X            host_append_netrc_proc();
  1938. X        return;
  1939. X    }
  1940. X    /* new ftptoolrc file format */
  1941. X    /* first line */
  1942. X    /* # Host List : Ftptool Version 3.3 */
  1943. X    /*
  1944. X     Alias
  1945. X     direct (ignored)
  1946. X     proxy
  1947. X     host
  1948. X     login
  1949. X     password
  1950. X     remote directory
  1951. X     local directory
  1952. X     dir parse line
  1953. X     Comment
  1954. X     */
  1955. X    fp = fdopen(fd, "r");
  1956. X    if (fp == NULL) {
  1957. X        close(fd);
  1958. X        return;
  1959. X    }
  1960. X    /* first line is a comment line */
  1961. X    fgets(comment, MAXCOMMENTLEN + 1, fp);
  1962. X    sscanf(comment, "# Host List : Ftptool Version %d.%d\n", &version, &patch);
  1963. X    if (version >= 4 && patch >= 1)
  1964. X        list_version = 5;
  1965. X    else if (version == 4 && patch == 0)
  1966. X        list_version = 4;
  1967. X    else if (version == 3 && patch == 3)
  1968. X        list_version = 3;
  1969. X    else if (version == 3 && patch == 2)
  1970. X        list_version = 2;
  1971. X    else
  1972. X        list_version = 1;
  1973. X
  1974. X    while (read_entry(list_version, fp, 
  1975. X        aliasname, last_visited, proxy, host, login, password, 
  1976. X        &transfer_mode, remote_directory, local_directory, dir_parse, 
  1977. X        comment)) {
  1978. X            if (add_hostalias(hostlist_head, aliasname, 
  1979. X                list_version >= 3 ? last_visited : "Never", 
  1980. X                proxy, host, login, password, 
  1981. X                list_version >= 5 ? transfer_mode : BINARY,
  1982. X                remote_directory, 
  1983. X                list_version >= 2 ? local_directory : ".", 
  1984. X                list_version >= 3 ? dir_parse : DEFAULT_PARSE,
  1985. X                comment) == NULL)
  1986. X                    break;
  1987. X    }
  1988. X    fclose(fp);
  1989. }
  1990. X
  1991. #ifdef USE_PROTOTYPES
  1992. void write_ftptoolrc(void)
  1993. #else
  1994. void write_ftptoolrc()
  1995. #endif
  1996. {
  1997. X    int    fd;
  1998. X    struct hostlist *tmp;
  1999. X    FILE    *fp;
  2000. X    char    *epasswd;
  2001. X
  2002. X    fd = ftptoolrc_fd(O_WRONLY | O_TRUNC | O_CREAT, 0600);
  2003. X    if (fd == -1) {
  2004. X        perror("writing host list");
  2005. X        return;
  2006. X    }
  2007. X    /* ftptoolrc file format */
  2008. X    /*
  2009. X     Alias
  2010. X     Last Visited
  2011. X     direct (ignored) XXX
  2012. X     proxy
  2013. X     host
  2014. X     login
  2015. X     password
  2016. X     transfer_mode
  2017. X     remote directory
  2018. X     local directory
  2019. X     dir parse
  2020. X     Comment
  2021. X     */
  2022. X    fp = fdopen(fd, "w"); 
  2023. X    if (fp == NULL) {
  2024. X        close(fd);
  2025. X        return;
  2026. X    }
  2027. X    fprintf(fp, "# Host List : %s\n", header_name);
  2028. X    for (tmp = hostlist_head->next; tmp != NULL; tmp = tmp->next) {
  2029. X        epasswd = ftptool_encrypt(tmp->password, login_name);
  2030. X        if (epasswd == NULL) {
  2031. X            fprintf(stderr, "Out of memory.\n");
  2032. X            exit(1);
  2033. X        }
  2034. X        fprintf(fp, "%s\n", tmp->aliasname);
  2035. X        fprintf(fp, "%s\n", tmp->last_visited);
  2036. X        fprintf(fp, "%d\n", 1);
  2037. X        fprintf(fp, "%s\n", tmp->proxy);
  2038. X        fprintf(fp, "%s\n", tmp->host);
  2039. X        fprintf(fp, "%s\n", tmp->login);
  2040. X        fprintf(fp, "%s\n", epasswd);
  2041. X        fprintf(fp, "%d\n", tmp->transfer_mode);
  2042. X        fprintf(fp, "%s\n", tmp->remote_directory);
  2043. X        fprintf(fp, "%s\n", tmp->local_directory);
  2044. X        fprintf(fp, "%s\n", tmp->dir_parse);
  2045. X        fprintf(fp, "%s\n", tmp->comment);
  2046. X        free(epasswd);
  2047. X    }
  2048. X
  2049. X    fclose(fp);
  2050. }
  2051. X
  2052. #ifdef USE_PROTOTYPES
  2053. int ftptoolrc_fd(int flags, int mode)
  2054. #else
  2055. int ftptoolrc_fd(flags, mode)
  2056. int        flags;
  2057. int        mode;
  2058. #endif
  2059. {
  2060. X    char    *filename=NULL;
  2061. X    int        fd;
  2062. X
  2063. X    filename = find_dotfile(FTPTOOL_RC);
  2064. X    if (filename == NULL) {
  2065. X        if (flags == O_RDONLY) {
  2066. X            /* try global one */
  2067. X            filename = strdup(GLOBAL_FTPTOOLRC);
  2068. X            if (filename == NULL) {
  2069. X                return -1;
  2070. X            }
  2071. X        } else {
  2072. X            if ((filename = create_dotfile(FTPTOOL_RC, 0600)) == NULL)
  2073. X                return -1;
  2074. X        }
  2075. X    }
  2076. X
  2077. X    /* try current directory */
  2078. X    if ((fd = open(filename, flags, mode)) != -1) {
  2079. X        free(filename);
  2080. X        return fd;
  2081. X    }
  2082. X    free(filename);
  2083. X    return -1;
  2084. }
  2085. X
  2086. #ifdef USE_PROTOTYPES
  2087. void reload_host_list_menu(struct hostlist *head)
  2088. #else
  2089. void reload_host_list_menu(head)
  2090. struct hostlist *head;
  2091. #endif
  2092. {
  2093. X    Menu    menu = xv_get(host_window.hosts, PANEL_ITEM_MENU);
  2094. X    int    nitems = xv_get(menu, MENU_NITEMS);
  2095. X    int    row;
  2096. X    struct hostlist *tmp;
  2097. X    Menu_item    mi;
  2098. X    Frame    frame;
  2099. X    int        isshown;
  2100. X    int        maxwidth=0;
  2101. X    int        width=0;
  2102. X    double    cols;
  2103. X
  2104. X    frame = (Panel)xv_get(menu, MENU_PIN_WINDOW);
  2105. X    isshown = FALSE;
  2106. X    if (frame) 
  2107. X        isshown = xv_get(frame, XV_SHOW);
  2108. X
  2109. X    if (isshown) {
  2110. X        xv_set(frame, 
  2111. #ifdef XVIEW3
  2112. X            FRAME_CMD_PIN_STATE, FRAME_CMD_PIN_OUT,
  2113. #else
  2114. X            FRAME_CMD_PUSHPIN_IN, FALSE,
  2115. #endif
  2116. X            XV_SHOW, FALSE,
  2117. X            NULL);
  2118. X    }
  2119. X    /* 2 items minimum, 1 for title */
  2120. X    for (row = nitems; row > 1; row--)
  2121. X        xv_set(menu,
  2122. X            MENU_REMOVE, row,
  2123. X            NULL);
  2124. X
  2125. X    nhostlist_items = 0;
  2126. X    for (tmp=head->next; tmp != NULL; tmp=tmp->next) {
  2127. X        width = strlen(tmp->aliasname);
  2128. X        maxwidth = MAX(maxwidth, width);
  2129. X        mi = (Menu_item)xv_create(XV_NULL, MENUITEM,
  2130. X            MENU_STRING, tmp->aliasname,
  2131. X            MENU_NOTIFY_PROC, host_list_item_proc,
  2132. X            MENU_RELEASE,
  2133. X            NULL);
  2134. X        if (mi == XV_NULL) {
  2135. X            fprintf(stderr, "Out of memory for menu item.\n");
  2136. X            exit(1);
  2137. X        }
  2138. X        xv_set(menu,
  2139. X            MENU_APPEND_ITEM, mi,
  2140. X            PANEL_PAINT, PANEL_NONE,
  2141. X            NULL);
  2142. X        nhostlist_items++;
  2143. X    }
  2144. X    if (nhostlist_items == 0) {
  2145. X        mi = (Menu_item)xv_create(XV_NULL, MENUITEM,
  2146. X            MENU_STRING, "No Hosts!",
  2147. X            MENU_RELEASE,
  2148. X            NULL);
  2149. X        if (mi == XV_NULL) {
  2150. X            fprintf(stderr, "Out of memory for menu item.\n");
  2151. X            exit(1);
  2152. X        }
  2153. X        xv_set(menu,
  2154. X            MENU_APPEND_ITEM, mi,
  2155. X            NULL);
  2156. X    }
  2157. X
  2158. X    if (maxwidth == 0)
  2159. X        maxwidth = 1;
  2160. X    
  2161. X    cols = 2.0 * nhostlist_items;
  2162. X    cols /= maxwidth;
  2163. X    cols = ceil(sqrt(cols));
  2164. X    xv_set(menu,
  2165. X        MENU_NCOLS,(int)cols,
  2166. X        NULL);
  2167. X    if (isshown) {
  2168. X        xv_set(frame, 
  2169. #ifdef XVIEW3
  2170. X            FRAME_CMD_PIN_STATE, FRAME_CMD_PIN_IN,
  2171. #else
  2172. X            FRAME_CMD_PUSHPIN_IN, TRUE,
  2173. #endif
  2174. X            XV_SHOW, TRUE,
  2175. X            NULL);
  2176. X    }
  2177. }
  2178. X
  2179. #ifdef USE_PROTOTYPES
  2180. char *create_dotfile(char *dotfile, int mode)
  2181. #else
  2182. char *create_dotfile(dotfile, mode)
  2183. char    *dotfile;
  2184. int        mode;
  2185. #endif
  2186. {
  2187. X    char    *home;
  2188. X    char    *filename=NULL;
  2189. X    int        fd;
  2190. X
  2191. X    home = getenv("HOME");
  2192. X    if (home != NULL && home[0] != '\0') {
  2193. X        /* try $HOME/dotfile */
  2194. X        filename = malloc((unsigned int)(strlen(home)+1+strlen(dotfile)+1));
  2195. X        if (filename == NULL)
  2196. X            return NULL;
  2197. X        sprintf(filename, "%s/%s", home, dotfile);
  2198. X        if ((fd = creat(filename, mode)) == -1) {
  2199. X            free(filename);
  2200. X            return NULL;
  2201. X        }
  2202. X        close(fd);
  2203. X        /* found it */
  2204. X        return filename;
  2205. X    }
  2206. X    filename = strdup(dotfile);
  2207. X    if (filename == NULL)
  2208. X        return NULL;
  2209. X    if ((fd = creat(filename, mode)) == -1) {
  2210. X        free(filename);
  2211. X        return NULL;
  2212. X    }
  2213. X    close(fd);
  2214. X
  2215. X    return filename;
  2216. }
  2217. X
  2218. #ifdef USE_PROTOTYPES
  2219. char *find_dotfile(char *dotfile)
  2220. #else
  2221. char *find_dotfile(dotfile)
  2222. char    *dotfile;
  2223. #endif
  2224. {
  2225. X    char    *home;
  2226. X    char    *filename=NULL;
  2227. X
  2228. X    home = getenv("HOME");
  2229. X    if (home != NULL && home[0] != '\0') {
  2230. X        /* try $HOME/dotfile */
  2231. X        filename = malloc((unsigned int)(strlen(home)+1+strlen(dotfile)+1));
  2232. X        if (filename == NULL)
  2233. X            return NULL;
  2234. X        sprintf(filename, "%s/%s", home, dotfile);
  2235. X        if (access(filename, F_OK) == -1) {
  2236. X            free(filename);
  2237. X            return NULL;
  2238. X        }
  2239. X        /* found it */
  2240. X        return filename;
  2241. X    }
  2242. X    filename = strdup(dotfile);
  2243. X    if (filename == NULL)
  2244. X        return NULL;
  2245. X    if (access(filename, F_OK) == -1) {
  2246. X        free(filename);
  2247. X        return NULL;
  2248. X    }
  2249. X
  2250. X    return filename;
  2251. }
  2252. X
  2253. #define MACHINE        1
  2254. #define LOGIN        2
  2255. #define PASSWORD    3
  2256. #define ACCOUNT        4
  2257. #define MACDEF        5
  2258. X
  2259. #ifdef USE_PROTOTYPES
  2260. int netrc_token(FILE *fp)
  2261. #else
  2262. int netrc_token(fp)
  2263. FILE    *fp;
  2264. #endif
  2265. {
  2266. X    char    keyword[MAXPATHLEN + 1];
  2267. X    int        ch, lastchar;
  2268. X
  2269. X    for (;;) {
  2270. X        if (fscanf(fp,"%s", keyword) == EOF)
  2271. X            return EOF;
  2272. X        if (!strcmp(keyword, "machine"))
  2273. X            return MACHINE;
  2274. X        if (!strcmp(keyword, "login"))
  2275. X            return LOGIN;
  2276. X        if (!strcmp(keyword, "password"))
  2277. X            return PASSWORD;
  2278. X        if (!strcmp(keyword, "macdef")) {
  2279. X            lastchar = 'e';
  2280. X            ch = 'f';
  2281. X            do {
  2282. X                lastchar = ch;
  2283. X                ch = getc(fp);
  2284. X            } while (ch != EOF && (ch != '\n' && lastchar != '\n'));
  2285. X        }
  2286. X    }
  2287. }
  2288. X
  2289. X
  2290. #ifdef USE_PROTOTYPES
  2291. void    host_append_netrc_proc(void)
  2292. #else
  2293. void    host_append_netrc_proc()
  2294. #endif
  2295. {
  2296. X    FILE     *fp;
  2297. X    char    machine[MAXHOSTNAMELEN + 1];
  2298. X    char    login[MAXHOSTNAMELEN + 1];
  2299. X    char    password[MAXPASSWORDLEN+ 1];
  2300. X    int        foundmachine=0;
  2301. X
  2302. X    if ((fp = fopen(netrc_filename, "r")) == NULL) {
  2303. X        footer_message("%s exists but can not be read.", 
  2304. SHAR_EOF
  2305. true || echo 'restore of host_list.c failed'
  2306. fi
  2307. echo 'End of  part 9'
  2308. echo 'File host_list.c is continued in part 10'
  2309. echo 10 > _shar_seq_.tmp
  2310. exit 0
  2311. -- 
  2312. Senior Systems Scientist        mail: dcmartin@msi.com
  2313. Molecular Simulations, Inc.        uucp: uunet!dcmartin
  2314. 796 North Pastoria Avenue        at&t: 408/522-9236
  2315. Sunnyvale, California 94086        fax: 408/732-0831
  2316.