home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / x / volume18 / ftptool-4.3 / part06 < prev    next >
Text File  |  1992-08-18  |  51KB  |  2,209 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: v18i088: Ftptool 4.3 (XVIEW), Part06/12
  5. Message-ID: <1992Aug18.153646.28847@msi.com>
  6. Date: 18 Aug 92 15:36:46 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: 2195
  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 88
  16. Archive-name: ftptool-4.3/part06
  17.  
  18. #!/bin/sh
  19. # this is part.06 (part 6 of a multipart archive)
  20. # do not concatenate these parts, unpack them in order with /bin/sh
  21. # file schedule.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" != 6; 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 schedule.c'
  37. else
  38. echo 'x - continuing file schedule.c'
  39. sed 's/^X//' << 'SHAR_EOF' >> 'schedule.c' &&
  40. X        NULL);
  41. X    update_date(0);
  42. X    tm = localtime(&tmp->date);
  43. X    xv_set(schedule_window.frame,
  44. X        XV_SHOW, TRUE,
  45. X        NULL);
  46. X    xv_set(schedule_window.hour,
  47. X        PANEL_VALUE, tm->tm_hour,
  48. X        NULL);
  49. X    xv_set(schedule_window.minute,
  50. X        PANEL_VALUE, tm->tm_min,
  51. X        NULL);
  52. X    xv_set(schedule_window.month,
  53. X        PANEL_VALUE, tm->tm_mon,
  54. X        NULL);
  55. X    xv_set(schedule_window.day,
  56. X        PANEL_VALUE, tm->tm_mday,
  57. X        NULL);
  58. X    xv_set(schedule_window.year,
  59. X        PANEL_VALUE, tm->tm_year + 1900,
  60. X        NULL);
  61. X
  62. X    xv_set(menu, 
  63. X        MENU_NOTIFY_STATUS, XV_ERROR, 
  64. X        NULL);
  65. }
  66. X
  67. #ifdef USE_PROTOTYPES
  68. void reload_schedule_menu(struct schedule *head)
  69. #else
  70. void reload_schedule_menu(head)
  71. struct schedule *head;
  72. #endif
  73. {
  74. X    Menu    menu = xv_get(schedule_window.hosts, PANEL_ITEM_MENU);
  75. X    int    nitems = xv_get(menu, MENU_NITEMS);
  76. X    int    row;
  77. X    Menu_item    mi;
  78. X    Frame    frame;
  79. X    int        isshown;
  80. X    int        maxwidth=0;
  81. X    int        width=0;
  82. X    double    cols;
  83. X    struct schedule *tmp=NULL;
  84. X
  85. X    frame = (Panel)xv_get(menu, MENU_PIN_WINDOW);
  86. X    isshown = FALSE;
  87. X    if (frame) 
  88. X        isshown = xv_get(frame, XV_SHOW);
  89. X
  90. X    if (isshown) {
  91. X        xv_set(frame, 
  92. #ifdef XVIEW3
  93. X            FRAME_CMD_PIN_STATE, FRAME_CMD_PIN_OUT,
  94. #else
  95. X            FRAME_CMD_PUSHPIN_IN, FALSE,
  96. #endif
  97. X            XV_SHOW, FALSE,
  98. X            NULL);
  99. X    }
  100. X    /* 2 items minimum, 1 for title */
  101. X    for (row = nitems; row > 1; row--)
  102. X        xv_set(menu,
  103. X            MENU_REMOVE, row,
  104. X            NULL);
  105. X
  106. X    nitems = 0;
  107. X    for (tmp=head->next; tmp != NULL; tmp=tmp->next) {
  108. X        width = strlen(tmp->menu_name);
  109. X        maxwidth = MAX(maxwidth, width);
  110. X        mi = (Menu_item)xv_create(XV_NULL, MENUITEM,
  111. X            MENU_STRING, tmp->menu_name,
  112. X            MENU_NOTIFY_PROC, schedule_item_proc,
  113. X            MENU_CLIENT_DATA, tmp,
  114. X            MENU_RELEASE,
  115. X            NULL);
  116. X        if (mi == XV_NULL) {
  117. X            fprintf(stderr, "Out of memory for menu item.\n");
  118. X            exit(1);
  119. X        }
  120. X        xv_set(menu,
  121. X            MENU_APPEND_ITEM, mi,
  122. X            PANEL_PAINT, PANEL_NONE,
  123. X            NULL);
  124. X        nitems++;
  125. X    }
  126. X    if (nitems == 0) {
  127. X        mi = (Menu_item)xv_create(XV_NULL, MENUITEM,
  128. X            MENU_STRING, "No Hosts!",
  129. X            MENU_RELEASE,
  130. X            NULL);
  131. X        if (mi == XV_NULL) {
  132. X            fprintf(stderr, "Out of memory for menu item.\n");
  133. X            exit(1);
  134. X        }
  135. X        xv_set(menu,
  136. X            MENU_APPEND_ITEM, mi,
  137. X            NULL);
  138. X    }
  139. X
  140. X    if (maxwidth == 0)
  141. X        maxwidth = 1;
  142. X    
  143. X    cols = 2.0 * nitems;
  144. X    cols /= maxwidth;
  145. X    cols = ceil(sqrt(cols));
  146. X    xv_set(menu,
  147. X        MENU_NCOLS,(int)cols,
  148. X        NULL);
  149. X    if (isshown) {
  150. X        xv_set(frame, 
  151. #ifdef XVIEW3
  152. X            FRAME_CMD_PIN_STATE, FRAME_CMD_PIN_IN,
  153. #else
  154. X            FRAME_CMD_PUSHPIN_IN, TRUE,
  155. #endif
  156. X            XV_SHOW, TRUE,
  157. X            NULL);
  158. X    }
  159. }
  160. X
  161. #ifdef USE_PROTOTYPES
  162. void action_choice_proc(Panel_item item, unsigned int value, 
  163. X    Event *event)
  164. #else
  165. void action_choice_proc(item, value, event)
  166. Panel_item    item;
  167. unsigned int    value;
  168. Event    *event;
  169. #endif
  170. {
  171. X    schedule_footer_message("", (char *)NULL);
  172. X    if (value == RECV) {
  173. X        xv_set(schedule_window.send_list,
  174. X            XV_SHOW, FALSE,
  175. X            NULL);
  176. X        xv_set(schedule_window.receive_list,
  177. X            XV_SHOW, TRUE,
  178. X            NULL);
  179. X    } else {
  180. X        xv_set(schedule_window.receive_list,
  181. X            XV_SHOW, FALSE,
  182. X            NULL);
  183. X        xv_set(schedule_window.send_list,
  184. X            XV_SHOW, TRUE,
  185. X            NULL);
  186. X    }
  187. }
  188. X
  189. #ifdef USE_PROTOTYPES
  190. Notify_value schedule_timer_proc(void)
  191. #else
  192. Notify_value schedule_timer_proc()
  193. #endif
  194. {
  195. X    dowhat = DOSCHEDULE;
  196. X    notify_stop();
  197. X    return NOTIFY_DONE;
  198. }
  199. X
  200. #ifdef USE_PROTOTYPES
  201. void activate_schedule_timer(void)
  202. #else
  203. void activate_schedule_timer()
  204. #endif
  205. {
  206. X    time_t    t;
  207. X    struct itimerval itimer;
  208. X
  209. X    if (schedule_list.next == NULL) {
  210. X        xv_set(schedule_window.process,
  211. X            PANEL_LABEL_STRING, "Process Batch",
  212. X            XV_HELP_DATA, "ftptool:ProcessBatch",
  213. X            NULL);
  214. X        return;
  215. X    }
  216. X    if (!strcmp((char *)xv_get(schedule_window.process, PANEL_LABEL_STRING),
  217. X        "Process Batch"))
  218. X            return;    /* cancelled already */
  219. X    t = time((time_t *)NULL);
  220. X    itimer.it_value.tv_sec = schedule_list.next->date - t;
  221. X    itimer.it_value.tv_usec = 0;
  222. X    itimer.it_interval.tv_sec = 0;
  223. X    itimer.it_interval.tv_usec = 0;
  224. X    if (itimer.it_value.tv_sec < 0)
  225. X        itimer.it_value.tv_sec = 1;
  226. X    notify_set_itimer_func(schedule_window.frame, schedule_timer_proc,
  227. X        ITIMER_REAL, &itimer, (struct itimerval *)NULL);
  228. }
  229. X
  230. #ifdef USE_PROTOTYPES
  231. void batch_process_proc(Panel_item item, Event *event)
  232. #else
  233. void batch_process_proc(item, event)
  234. Panel_item    item;
  235. Event    *event;
  236. #endif
  237. {
  238. X    schedule_footer_message("", (char *)NULL);
  239. X    if (!strcmp("Process Batch", (char *)xv_get(item, PANEL_LABEL_STRING))) {
  240. X        if (schedule_list.next == NULL) {
  241. X            schedule_footer_message("Nothing to process.", (char *)NULL);
  242. X            xv_set(item,
  243. X                PANEL_NOTIFY_STATUS, XV_ERROR,
  244. X                NULL);
  245. X            return;
  246. X        }
  247. X        xv_set(item,
  248. X            PANEL_LABEL_STRING, "Abort Batch",
  249. X            XV_HELP_DATA, "ftptool:AbortBatch",
  250. X            NULL);
  251. X        xv_set(base_window.connect,
  252. X            PANEL_INACTIVE, TRUE,
  253. X            NULL);
  254. X        xv_set(host_window.basic.connect,
  255. X            PANEL_INACTIVE, TRUE,
  256. X            NULL);
  257. X        activate_schedule_timer();
  258. X    } else {
  259. X        xv_set(item,
  260. X            PANEL_LABEL_STRING, "Process Batch",
  261. X            XV_HELP_DATA, "ftptool:ProcessBatch",
  262. X            NULL);
  263. X        xv_set(base_window.connect,
  264. X            PANEL_INACTIVE, FALSE,
  265. X            NULL);
  266. X        xv_set(host_window.basic.connect,
  267. X            PANEL_INACTIVE, FALSE,
  268. X            NULL);
  269. X        notify_set_itimer_func(schedule_window.frame, NOTIFY_FUNC_NULL,
  270. X            ITIMER_REAL, (struct itimerval *)NULL, (struct itimerval *)NULL);
  271. X    }
  272. X    xv_set(item,
  273. X        PANEL_NOTIFY_STATUS, XV_ERROR,
  274. X        NULL);
  275. }
  276. X
  277. #ifdef USE_PROTOTYPES
  278. void doschedule(void)
  279. #else
  280. void doschedule()
  281. #endif
  282. {
  283. X    struct schedule *tmp = schedule_list.next;
  284. X
  285. X    xv_set(host_window.advanced.alias, 
  286. X        PANEL_VALUE, tmp->hl->aliasname, 
  287. X        NULL);
  288. X    xv_set(host_window.advanced.last_visited, 
  289. X        PANEL_LABEL_STRING, tmp->hl->last_visited, 
  290. X        NULL);
  291. X    xv_set(host_window.advanced.proxy, 
  292. X        PANEL_VALUE, tmp->hl->proxy, 
  293. X        NULL);
  294. X    xv_set(host_window.basic.host, 
  295. X        PANEL_VALUE, tmp->hl->host, 
  296. X        NULL);
  297. X    xv_set(host_window.basic.login, 
  298. X        PANEL_VALUE, tmp->hl->login, 
  299. X        NULL);
  300. X    xv_set(host_window.basic.password, 
  301. X        PANEL_VALUE, tmp->hl->password, 
  302. X        NULL);
  303. X    xv_set(host_window.advanced.transfer_mode, 
  304. X        PANEL_VALUE, tmp->hl->transfer_mode, 
  305. X        NULL);
  306. X    xv_set(host_window.advanced.remote_auto_cd, 
  307. X        PANEL_VALUE, tmp->hl->remote_directory, 
  308. X        NULL);
  309. X    xv_set(host_window.advanced.local_auto_cd, 
  310. X        PANEL_VALUE, tmp->hl->local_directory, 
  311. X        NULL);
  312. X    xv_set(host_window.advanced.dir_parse, 
  313. X        PANEL_VALUE, tmp->hl->dir_parse, 
  314. X        NULL);
  315. X    xv_set(host_window.advanced.comment, 
  316. X        PANEL_VALUE, tmp->hl->comment, 
  317. X        NULL);
  318. X
  319. X    if (try_proxy) {
  320. X        xv_set(host_window.advanced.proxy, 
  321. X            XV_SHOW, TRUE, 
  322. X            NULL);
  323. X    } else {
  324. X        xv_set(host_window.advanced.proxy, 
  325. X            XV_SHOW, FALSE, 
  326. X            NULL);
  327. X    }
  328. X    if (doconnect()) {
  329. X        /* failed. Try again later. */
  330. X        schedule_list.next->date += 300;
  331. X        reorder_list(&schedule_list);
  332. X        goto out;
  333. X    }
  334. X    if (tmp->direction == RECV) {
  335. X        load_batch_list(schedule_window.receive_list, tmp->filename);
  336. X        dobatchget();
  337. X    } else {
  338. X        load_batch_list(schedule_window.send_list, tmp->filename);
  339. X        dobatchput();
  340. X    }
  341. X    disconnect();
  342. X    delete_schedule(&schedule_list, &tmp->menu_name[2], tmp->direction);
  343. out:
  344. X    reload_schedule_menu(&schedule_list);
  345. X    activate_schedule_timer();
  346. }
  347. SHAR_EOF
  348. echo 'File schedule.c is complete' &&
  349. chmod 0644 schedule.c ||
  350. echo 'restore of schedule.c failed'
  351. Wc_c="`wc -c < 'schedule.c'`"
  352. test 17319 -eq "$Wc_c" ||
  353.     echo 'schedule.c: original size 17319, current size' "$Wc_c"
  354. rm -f _shar_wnt_.tmp
  355. fi
  356. # ============= transfer.c ==============
  357. if test -f 'transfer.c' -a X"$1" != X"-c"; then
  358.     echo 'x - skipping transfer.c (File already exists)'
  359.     rm -f _shar_wnt_.tmp
  360. else
  361. > _shar_wnt_.tmp
  362. echo 'x - extracting transfer.c (Text)'
  363. sed 's/^X//' << 'SHAR_EOF' > 'transfer.c' &&
  364. #include "ftptool.h"
  365. X
  366. #ifdef USE_PROTOTYPES
  367. int get_file(char *name, char *localname, size_t size)
  368. #else
  369. int get_file(name, localname, size)
  370. char    *name;
  371. char    *localname;
  372. size_t    size;
  373. #endif
  374. {
  375. X    char    *ftperr;
  376. X    int        rval;
  377. X
  378. X    footer_message("Receiving %s...", name, (char *)NULL);
  379. X    if (abort_transfer) {
  380. X        return EINTR;
  381. X    }
  382. X    xv_set(base_window.abort,
  383. X        PANEL_INACTIVE, FALSE,
  384. X        NULL);
  385. X    restart_point = 0;
  386. X    settype((int)xv_get(host_window.advanced.transfer_mode, PANEL_VALUE));
  387. X    rval = recvrequest("RETR", localname, name, "w", size);
  388. X    restart_point = 0;
  389. X    switch (rval) {
  390. X    case 1:
  391. X        /* non_fatal error */
  392. X        ftperr = index(response_line, ':');
  393. X        if (ftperr != NULL) {
  394. X            ftperr++;
  395. X            if (!strncmp(ftperr, "Permission", 10))
  396. X                rval = EPERM;
  397. X            else if (!strncmp(ftperr, "not a plain file", 16))
  398. X                rval = EISDIR;
  399. X            else
  400. X                rval = 0;
  401. X        } else
  402. X            rval = 0;
  403. X        break;
  404. X    case 2:
  405. X        rval = EIO;
  406. X        break;
  407. X    default:
  408. X        break;
  409. X    }
  410. X
  411. X    return rval;
  412. }
  413. X
  414. #ifdef USE_PROTOTYPES
  415. int put_file(char *name, char *remote_name, size_t size)
  416. #else
  417. int put_file(name, remote_name, size)
  418. char    *name;
  419. char    *remote_name;
  420. size_t    size;
  421. #endif
  422. {
  423. X    char    *ftperr;
  424. X    int        rval;
  425. X
  426. X    local_footer_message("Sending %s...", name, (char *)NULL);
  427. X    if (abort_transfer) {
  428. X        return EINTR;
  429. X    }
  430. X    xv_set(base_window.abort,
  431. X        PANEL_INACTIVE, FALSE,
  432. X        NULL);
  433. X
  434. X    restart_point = 0;
  435. X    settype((int)xv_get(host_window.advanced.transfer_mode, PANEL_VALUE));
  436. X    /* if unique, then use STOU */
  437. X    if (unique_remote_names)
  438. X        rval = sendrequest("STOU", name, remote_name, size);
  439. X    else
  440. X        rval = sendrequest("STOR", name, remote_name, size);
  441. X    restart_point = 0;
  442. X    switch (rval) {
  443. X    case 1:
  444. X        /* non_fatal error */
  445. X        ftperr = index(response_line, ':');
  446. X        if (ftperr != NULL) {
  447. X            ftperr++;
  448. X            if (!strncmp(ftperr, "Permission", 10))
  449. X                rval = EPERM;
  450. X            else
  451. X                rval = 0;
  452. X        } else
  453. X            rval = 0;
  454. X        break;
  455. X    case 2:
  456. X        rval = EIO;
  457. X        break;
  458. X    default:
  459. X        break;
  460. X    }
  461. X
  462. X    return rval;
  463. }
  464. X
  465. #ifdef USE_PROTOTYPES
  466. int get_dir(char *parent_remote_dir, char *parent_local_dir, 
  467. X    char *name, char *localname)
  468. #else
  469. int get_dir(parent_remote_dir, parent_local_dir, name, localname)
  470. char    *parent_remote_dir;
  471. char    *parent_local_dir;
  472. char    *name;
  473. char    *localname;
  474. #endif
  475. {
  476. X    int        rval = 0;
  477. X    extern int errno;
  478. X    struct dirlist *head = NULL;
  479. X    struct dirlist *tmp;
  480. X    char    *ftperr;
  481. X    char    *rdir = NULL;
  482. X    char    *ldir = NULL;
  483. X
  484. X    /* transfer a remote subdirectory and its contents to the local machine */
  485. X
  486. X    /* First, make a directory */
  487. X    if (rval = make_dirs(localname, 1)) {
  488. X        if (rval != EEXIST) {
  489. X            /* XXX - this message is clobbered by 'done reading' message */
  490. X            return errno;
  491. X        }
  492. X    }
  493. X
  494. X    /* cd to that dir */
  495. X    if (command("CWD %s", name) == ERROR && code == 250) {
  496. X        sprintf(scratch, "Remote cd to %s failed.", name);
  497. X        ftperr = ftp_error(' ', scratch);
  498. X        footer_message(ftperr, (char *)NULL);
  499. X        return 1;
  500. X    }
  501. X    /* local cd */
  502. X    if (chdir(localname) == -1) {
  503. X        /* go back up */
  504. X        footer_message("Local cd to %s failed.", localname, (char *)NULL);
  505. X
  506. X        (void)command("CWD %s", parent_remote_dir);
  507. X        return errno;
  508. X    }
  509. X
  510. X    head = read_remote_dir((char *)NULL);
  511. X    if (head == NULL)
  512. X        goto out;
  513. X
  514. X    /* do files first */
  515. X    for (tmp=head->next; tmp != NULL; tmp = tmp->next) {
  516. X        if (S_ISREG(tmp->mode)) {
  517. X            if (rval = get_file(tmp->name, tmp->name, tmp->size))
  518. X                goto out;
  519. X        } 
  520. X    }
  521. X
  522. X    rdir = make_path(parent_remote_dir, name);
  523. X    if (rdir == NULL)
  524. X        goto out;
  525. X
  526. X    ldir = make_path(parent_local_dir, localname);
  527. X    if (ldir == NULL)
  528. X        goto out;
  529. X
  530. X    /* recursively do directories */
  531. X    for (tmp=head->next; tmp != NULL; tmp = tmp->next) {
  532. X        if (!S_ISDIR(tmp->mode)) 
  533. X            continue;
  534. X        if (rval = get_dir(rdir, ldir, tmp->name, tmp->name))
  535. X            goto out;
  536. X    }
  537. X
  538. out:
  539. X    if (head)
  540. X        free_dirlist(head);
  541. X    if (rdir)
  542. X        free(rdir);
  543. X    if (ldir)
  544. X        free(ldir);
  545. X    /* go back up */
  546. X
  547. X    (void)command("CWD %s", parent_remote_dir);
  548. X    chdir(parent_local_dir);
  549. X
  550. X    return rval;
  551. }
  552. X
  553. #ifdef USE_PROTOTYPES
  554. int put_dir(char *parent_remote_dir, char *parent_local_dir, 
  555. X    char *name, char *localname)
  556. #else
  557. int put_dir(parent_remote_dir, parent_local_dir, name, localname)
  558. char    *parent_remote_dir;
  559. char    *parent_local_dir;
  560. char    *name;
  561. char    *localname;
  562. #endif
  563. {
  564. X    extern int errno;
  565. X    int    rval = 0;
  566. X    struct dirlist *head = NULL;
  567. X    struct dirlist *tmp;
  568. X    char    *ftperr;
  569. X    char    *rdir = NULL;
  570. X    char    *ldir = NULL;
  571. X
  572. X    /* transfer a local subdirectory and its contents to the remote machine */
  573. X
  574. X    /* First, make a directory */
  575. X    if (make_remote_dirs(name, 1)) {
  576. X    /* XXX - error? */
  577. X    /*
  578. X        goto out;
  579. X    */
  580. X    }
  581. X    /* cd to that dir */
  582. X    if (command("CWD %s", name) == ERROR && code == 250) {
  583. X        sprintf(scratch, "Remote cd to %s failed.", name);
  584. X        ftperr = ftp_error(' ', scratch);
  585. X        local_footer_message(ftperr, (char *)NULL);
  586. X        return 1;
  587. X    }
  588. X    /* local cd */
  589. X    if (chdir(localname) == -1) {
  590. X        local_footer_message("Local cd to %s failed.", localname, (char *)NULL);
  591. X        /* go back up */
  592. X        (void)command("CWD %s", parent_remote_dir);
  593. X        return errno;
  594. X    }
  595. X
  596. X    head = read_local_dir(".");
  597. X
  598. X    if (head == NULL) {
  599. X        rval = ENOMEM;
  600. X        goto out;
  601. X    }
  602. X
  603. X    /* do files first */
  604. X    for (tmp=head->next; tmp != NULL; tmp = tmp->next) {
  605. X        if (!S_ISREG(tmp->mode))
  606. X            continue;
  607. X        if (rval = put_file(tmp->name, tmp->name, tmp->size))
  608. X            goto out;
  609. X    }
  610. X
  611. X    rdir = make_path(parent_remote_dir, name);
  612. X    if (rdir == NULL)
  613. X        goto out;
  614. X
  615. X    ldir = make_path(parent_local_dir, localname);
  616. X    if (ldir == NULL)
  617. X        goto out;
  618. X
  619. X    /* recursively do directories */
  620. X    for (tmp=head->next; tmp != NULL; tmp = tmp->next) {
  621. X        if (!S_ISDIR(tmp->mode)) 
  622. X            continue;
  623. X        if (rval = put_dir(rdir, ldir, tmp->name, tmp->name))
  624. X            goto out;
  625. X    }
  626. X
  627. out:
  628. X    if (head)
  629. X        free_dirlist(head);
  630. X    if (rdir)
  631. X        free(rdir);
  632. X    if (ldir)
  633. X        free(ldir);
  634. X    /* go back up */
  635. X    (void)command("CWD %s", parent_remote_dir);
  636. X    chdir(parent_local_dir);
  637. X
  638. X    return rval;
  639. }
  640. X
  641. #ifdef USE_PROTOTYPES
  642. char *make_path(char *parent, char *curdir)
  643. #else
  644. char *make_path(parent, curdir)
  645. char    *parent;
  646. char    *curdir;
  647. #endif
  648. {
  649. X    char    *tmp;
  650. X
  651. X    if (*curdir == '/') {
  652. X        tmp = (char *)strdup(curdir);
  653. X    } else {
  654. X        tmp = (char *)malloc((unsigned int)(strlen(parent)+1+strlen(curdir)+1));
  655. X        if (tmp == NULL)
  656. X            return NULL;
  657. X        strcpy(tmp, parent);
  658. X        if (strcmp(parent, "/"))
  659. X            strcat(tmp, "/");
  660. X        strcat(tmp, curdir);
  661. X    }
  662. X    return tmp;
  663. }
  664. X
  665. #define FILE_PERCENT    5.0
  666. #define TOTAL_PERCENT    5.0
  667. X
  668. static double last_percent;
  669. static double last_total_percent;
  670. static int total_so_far;
  671. static int total_transfer_size;
  672. static struct timeval start;
  673. X
  674. #ifdef USE_PROTOTYPES
  675. void init_status(int total)
  676. #else
  677. void init_status(total)
  678. int    total;
  679. #endif
  680. {
  681. X    total_so_far = 0;
  682. X    total_transfer_size = total;
  683. X    last_total_percent = 0;
  684. X    xv_set(status_window.total_gauge,
  685. X        PANEL_INACTIVE, FALSE,
  686. X        PANEL_VALUE, 0,
  687. X        NULL);
  688. X    (void)gettimeofday(&start, (struct timezone *)NULL);
  689. X    status_footer_message("Total transfer size: %d bytes.", 
  690. X        total_transfer_size, (char *)NULL);
  691. }
  692. X
  693. #ifdef USE_PROTOTYPES
  694. void end_status(void)
  695. #else
  696. void end_status()
  697. #endif
  698. {
  699. X    struct timeval stop;
  700. X    double    total_time;
  701. X    double    rate;
  702. X    char    *unit;
  703. X
  704. X    (void)gettimeofday(&stop, (struct timezone *)NULL);
  705. #ifdef notdef
  706. X    xv_set(status_window.file_gauge,
  707. X        PANEL_INACTIVE, FALSE,
  708. X        PANEL_VALUE, 0,
  709. X        NULL);
  710. #endif
  711. X    xv_set(status_window.total_gauge,
  712. X        PANEL_INACTIVE, FALSE,
  713. X        PANEL_VALUE, 0,
  714. X        NULL);
  715. X    total_time = (stop.tv_sec + stop.tv_usec/1000000.0)
  716. X        - (start.tv_sec + start.tv_usec/1000000.0);
  717. X    rate = (double)total_so_far/total_time;
  718. X    if (rate >= 1048576.0) {
  719. X        unit = "Mbyte";
  720. X        rate /= 1048576.0;
  721. X    } else if (rate >= 1024.0) {
  722. X        unit = "Kbyte";
  723. X        rate /= 1024.0;
  724. X    } else
  725. X        unit = "byte";
  726. X    status_footer_message("%5.2f seconds, %5.2f %ss/second",
  727. X        total_time, rate, unit, (char *)NULL);
  728. }
  729. X
  730. #ifdef USE_PROTOTYPES
  731. void update_status_label(char *direction, char *name, size_t size)
  732. #else
  733. void update_status_label(direction, name, size)
  734. char    *direction;
  735. char    *name;
  736. size_t    size;
  737. #endif
  738. {
  739. X    static char sizestr[40];
  740. X    static char    string[MAXPATHLEN + 30];
  741. X    Rect    *butrect;
  742. X
  743. X    sprintf(string, "%s %s", direction, name);
  744. X    xv_set(status_window.message, 
  745. X        PANEL_LABEL_STRING, string,
  746. X        NULL);
  747. X    if (size >= 0) {
  748. X        sprintf(sizestr, "%d bytes", size);
  749. X        xv_set(status_window.size, 
  750. X            PANEL_LABEL_STRING, sizestr,
  751. X            NULL);
  752. X        last_percent = 0;
  753. #ifdef notdef
  754. X        xv_set(status_window.file_gauge,
  755. X            PANEL_VALUE, 0,
  756. X            PANEL_INACTIVE, FALSE,
  757. X            NULL);
  758. #endif
  759. X        xv_set(status_window.total_gauge,
  760. X            PANEL_INACTIVE, FALSE,
  761. X            NULL);
  762. X    } else {
  763. X        xv_set(status_window.size,
  764. X            PANEL_LABEL_STRING, "Symbolic links not counted.",
  765. X            NULL);
  766. #ifdef notdef
  767. X        xv_set(status_window.file_gauge,
  768. X            PANEL_INACTIVE, TRUE,
  769. X            PANEL_VALUE, 0,
  770. X            NULL);
  771. #endif
  772. X        xv_set(status_window.total_gauge,
  773. X            PANEL_INACTIVE, TRUE,
  774. X            NULL);
  775. X    }
  776. #ifdef notdef
  777. X    window_fit_width(status_window.panel);
  778. X    window_fit_width(status_window.frame);
  779. #endif
  780. X    butrect = (Rect *)xv_get(status_window.dismiss, XV_RECT);
  781. X    xv_set(status_window.dismiss,
  782. X        XV_X, xv_get(status_window.panel, XV_WIDTH) / 2
  783. X            - butrect->r_width / 2,
  784. X        NULL);
  785. }
  786. X
  787. X
  788. #ifdef USE_PROTOTYPES
  789. void update_status_gauge(long bytes)
  790. #else
  791. void update_status_gauge(bytes)
  792. long    bytes;
  793. #endif
  794. {
  795. X    double    percent;
  796. X
  797. X    if (bytes <= 0) /* shouldn't happen */
  798. X        return;
  799. #ifdef notdef
  800. X    if (bytes >= (int)size) {
  801. X        xv_set(status_window.file_gauge, 
  802. X            PANEL_VALUE, 100,
  803. X            NULL);
  804. X        return;
  805. X    }
  806. X    if (size != 0)
  807. X        percent = (double)bytes / (double)size * 100.0;
  808. X    else
  809. X        percent = 0;
  810. X    if (percent < 0)
  811. X        percent = 0;
  812. X    if (percent > 100)
  813. X        percent = 100;
  814. X    /* file gauge */
  815. X    if (percent >= (last_percent + FILE_PERCENT)) {
  816. X        while ((last_percent + FILE_PERCENT) < percent)
  817. X            last_percent += FILE_PERCENT;
  818. X        xv_set(status_window.file_gauge, 
  819. X            PANEL_VALUE, (int)last_percent,
  820. X            NULL);
  821. X    }
  822. #endif
  823. X
  824. X
  825. X    total_so_far += bytes;
  826. X    if (total_so_far > total_transfer_size)
  827. X        total_so_far = total_transfer_size;
  828. X
  829. X    if (total_transfer_size > 0.0)
  830. X        percent = (double)total_so_far / (double)total_transfer_size * 100.0;
  831. X    else
  832. X        percent = 0.0;
  833. X    if (percent < 0.0)
  834. X        percent = 0.0;
  835. X    if (percent > 100.0)
  836. X        percent = 100.0;
  837. X
  838. X    if (percent >= (last_total_percent + TOTAL_PERCENT)) {
  839. X        while ((last_total_percent + TOTAL_PERCENT) < percent)
  840. X            last_total_percent += TOTAL_PERCENT;
  841. X        xv_set(status_window.total_gauge, 
  842. X            PANEL_VALUE, (int)last_total_percent,
  843. X            NULL);
  844. X    }
  845. }
  846. X
  847. #ifdef USE_PROTOTYPES
  848. int sum_local_dir(char *parent, char *dir)
  849. #else
  850. int sum_local_dir(parent, dir)
  851. char    *parent, *dir;
  852. #endif
  853. {
  854. X    int total=0;
  855. X    char *ldir=NULL;
  856. X    struct dirlist *head=NULL;
  857. X    struct dirlist *tmp;
  858. X
  859. X    ldir = make_path(parent, dir);
  860. X    if (ldir == NULL)
  861. X        return 0;
  862. X
  863. X    if (chdir(ldir) == -1) {
  864. X        status_footer_message("Could not change to directory: %s",
  865. X                sys_errlist[errno], (char *)NULL);
  866. X        goto out;
  867. X    }
  868. X
  869. X    head = read_local_dir(".");
  870. X
  871. X    if (head == NULL) {
  872. X        goto out;
  873. X    }
  874. X
  875. X    /* do files first */
  876. X    for (tmp=head->next; tmp != NULL; tmp = tmp->next) {
  877. X        switch(tmp->mode & S_IFMT) {
  878. X        case S_IFREG:
  879. X            total += tmp->size;
  880. X            break;
  881. X        case S_IFDIR:
  882. X            total += sum_local_dir(ldir, tmp->name);
  883. X            break;
  884. X        default:
  885. X            break;
  886. X        }
  887. X    }
  888. X    if (chdir(parent) == -1) {
  889. X        status_footer_message("Could not change to parent: %s",
  890. X                sys_errlist[errno], (char *)NULL);
  891. X    }
  892. X
  893. out:
  894. X    if (ldir)
  895. X        free(ldir);
  896. X    if (head)
  897. X        free_dirlist(head);
  898. X    return total;
  899. }
  900. X
  901. /*
  902. X Called to sum all the sizes from the currently selected local items.
  903. X */
  904. #ifdef USE_PROTOTYPES
  905. int sum_local_size(void)
  906. #else
  907. int sum_local_size()
  908. #endif
  909. {
  910. X    int        nitems;
  911. X    int        row;
  912. X    int        total=0;
  913. X    struct dirlist *tmp;
  914. X
  915. X    status_footer_message("Determining send total...", (char *)NULL);
  916. X    /* loop over each selected element, and do a get, then unselect */
  917. X    nitems = xv_get(local_window.list, PANEL_LIST_NROWS);
  918. X    for (row = 0; row < nitems; row++)
  919. X        if (xv_get(local_window.list, PANEL_LIST_SELECTED, row)) {
  920. X            tmp = (struct dirlist *)xv_get(local_window.list, 
  921. X                PANEL_LIST_CLIENT_DATA, row);
  922. X            switch(tmp->mode & S_IFMT) {
  923. X            case S_IFDIR:
  924. X                total += sum_local_dir(local_dircache.first->name, tmp->name);
  925. X                break;
  926. X            case S_IFREG:
  927. X                total += tmp->size;
  928. X                break;
  929. X            case S_IFLNK:
  930. X                status_footer_message("Ignoring symlink %s...", 
  931. X                    tmp->name, (char *)NULL);
  932. X                log_message("Can only sum sizes of files and directories.\n");
  933. X                break;
  934. X            default:
  935. X                status_footer_message("Ignoring non-file/directory %s.", 
  936. X                    tmp->name, (char *)NULL);
  937. X                log_message("Can only transfer files and directories.\n");
  938. X                break;
  939. X            }
  940. X        }
  941. X    return total;
  942. }
  943. X
  944. #ifdef USE_PROTOTYPES
  945. int sum_remote_dir(char *parent, char *dir)
  946. #else
  947. int sum_remote_dir(parent, dir)
  948. char    *parent, *dir;
  949. #endif
  950. {
  951. X    int total=0;
  952. X    char *rdir=NULL;
  953. X    struct dirlist *head=NULL;
  954. X    struct dirlist *tmp;
  955. X
  956. X    if (!strcmp(dir, ".."))
  957. X        return 0;
  958. X
  959. X    rdir = make_path(parent, dir);
  960. X    if (rdir == NULL)
  961. X        return 0;
  962. X
  963. X    code = -1;
  964. X    command("CWD %s", rdir);
  965. X    if (code == 550) {
  966. X        goto out;
  967. X    }
  968. X    head = read_remote_dir((char *)NULL);
  969. X
  970. X    if (head == NULL) {
  971. X        goto out;
  972. X    }
  973. X
  974. X    for (tmp=head->next; tmp != NULL; tmp = tmp->next) {
  975. X        switch(tmp->mode & S_IFMT) {
  976. X        case S_IFREG:
  977. X            if (tmp->size != -1)
  978. X                total += tmp->size;
  979. X            else
  980. X                status_footer_message("Size of %s not available", 
  981. X                    tmp->name, (char *)NULL);
  982. X            break;
  983. X        case S_IFDIR:
  984. X            total += sum_remote_dir(rdir, tmp->name);
  985. X            break;
  986. X        default:
  987. X            break;
  988. X        }
  989. X    }
  990. X    (void)command("CWD %s", parent);
  991. X
  992. out:
  993. X    if (rdir)
  994. X        free(rdir);
  995. X    if (head)
  996. X        free_dirlist(head);
  997. X    return total;
  998. }
  999. X
  1000. /*
  1001. X Called to sum all the sizes from the currently selected local items.
  1002. X */
  1003. #ifdef USE_PROTOTYPES
  1004. int sum_remote_size(void)
  1005. #else
  1006. int sum_remote_size()
  1007. #endif
  1008. {
  1009. X    int        nitems;
  1010. X    int        row;
  1011. X    int        total=0;
  1012. X    struct dirlist *tmp;
  1013. X    int        mode;
  1014. X
  1015. X    status_footer_message("Determining receive total...", (char *)NULL);
  1016. X    /* loop over each selected element, and do a get, then unselect */
  1017. X    nitems = xv_get(base_window.list, PANEL_LIST_NROWS);
  1018. X    for (row = 0; row < nitems; row++)
  1019. X        if (xv_get(base_window.list, PANEL_LIST_SELECTED, row)) {
  1020. X            tmp = (struct dirlist *)xv_get(base_window.list, 
  1021. X                PANEL_LIST_CLIENT_DATA, row);
  1022. X            mode = tmp->mode & S_IFMT;
  1023. X            if (non_unix)
  1024. X                mode = S_IFREG;
  1025. X            switch(mode) {
  1026. X            case S_IFDIR:
  1027. X                total += sum_remote_dir(remote_dircache.first->name, tmp->name);
  1028. X                break;
  1029. X            case S_IFREG:
  1030. X                if (tmp->size != -1)
  1031. X                    total += tmp->size;
  1032. X                else
  1033. X                    status_footer_message("Size of %s not available", 
  1034. X                        tmp->name, (char *)NULL);
  1035. X                break;
  1036. X            case S_IFLNK:
  1037. X                status_footer_message("Ignoring symlink %s...", 
  1038. X                    tmp->name, (char *)NULL);
  1039. X                log_message("Can only sum sizes of files and directories.\n");
  1040. X                break;
  1041. X            default:
  1042. X                status_footer_message("Ignoring non-file/directory %s.", 
  1043. X                    tmp->name, (char *)NULL);
  1044. X                log_message("Can only transfer files and directories.\n");
  1045. X                break;
  1046. X            }
  1047. X        }
  1048. X    return total;
  1049. }
  1050. X
  1051. #ifdef USE_PROTOTYPES
  1052. int sum_remote_batch_size(void)
  1053. #else
  1054. int sum_remote_batch_size()
  1055. #endif
  1056. {
  1057. X    int        nitems;
  1058. X    int        row;
  1059. X    int        total=0;
  1060. X    struct batchlist *tmp;
  1061. X    int        mode;
  1062. X
  1063. X    status_footer_message("Determining receive total...", (char *)NULL);
  1064. X    /* loop over each selected element, and do a get, then unselect */
  1065. X    nitems = xv_get(schedule_window.receive_list, PANEL_LIST_NROWS);
  1066. X    for (row = 0; row < nitems; row++) {
  1067. X        tmp = (struct batchlist *)xv_get(schedule_window.receive_list, 
  1068. X            PANEL_LIST_CLIENT_DATA, row);
  1069. X        mode = tmp->mode & S_IFMT;
  1070. X        if (non_unix)
  1071. X            mode = S_IFREG;
  1072. X        switch(mode) {
  1073. X        case S_IFDIR:
  1074. X            total += sum_remote_dir(remote_dircache.first->name, tmp->name);
  1075. X            break;
  1076. X        case S_IFREG:
  1077. X            if (tmp->size != -1)
  1078. X                total += tmp->size;
  1079. X            else
  1080. X                status_footer_message("Size of %s not available", 
  1081. X                    tmp->name, (char *)NULL);
  1082. X            break;
  1083. X        case S_IFLNK:
  1084. X            status_footer_message("Ignoring symlink %s...", 
  1085. X                tmp->name, (char *)NULL);
  1086. X            log_message("Can only sum sizes of files and directories.\n");
  1087. X            break;
  1088. X        default:
  1089. X            status_footer_message("Ignoring non-file/directory %s.", 
  1090. X                tmp->name, (char *)NULL);
  1091. X            log_message("Can only transfer files and directories.\n");
  1092. X            break;
  1093. X        }
  1094. X    }
  1095. X    return total;
  1096. }
  1097. X
  1098. #ifdef USE_PROTOTYPES
  1099. int sum_local_batch_size(void)
  1100. #else
  1101. int sum_local_batch_size()
  1102. #endif
  1103. {
  1104. X    int        nitems;
  1105. X    int        row;
  1106. X    int        total=0;
  1107. X    struct batchlist *tmp;
  1108. X
  1109. X    status_footer_message("Determining send total...", (char *)NULL);
  1110. X    /* loop over each selected element, and do a get, then unselect */
  1111. X    nitems = xv_get(schedule_window.send_list, PANEL_LIST_NROWS);
  1112. X    for (row = 0; row < nitems; row++) {
  1113. X        tmp = (struct batchlist *)xv_get(schedule_window.send_list, 
  1114. X            PANEL_LIST_CLIENT_DATA, row);
  1115. X        switch(tmp->mode & S_IFMT) {
  1116. X        case S_IFDIR:
  1117. X            total += sum_local_dir(local_dircache.first->name, tmp->name);
  1118. X            break;
  1119. X        case S_IFREG:
  1120. X            total += tmp->size;
  1121. X            break;
  1122. X        case S_IFLNK:
  1123. X            status_footer_message("Ignoring symlink %s...", 
  1124. X                tmp->name, (char *)NULL);
  1125. X            log_message("Can only sum sizes of files and directories.\n");
  1126. X            break;
  1127. X        default:
  1128. X            status_footer_message("Ignoring non-file/directory %s.", 
  1129. X                tmp->name, (char *)NULL);
  1130. X            log_message("Can only transfer files and directories.\n");
  1131. X            break;
  1132. X        }
  1133. X    
  1134. X    }
  1135. X    return total;
  1136. }
  1137. SHAR_EOF
  1138. chmod 0644 transfer.c ||
  1139. echo 'restore of transfer.c failed'
  1140. Wc_c="`wc -c < 'transfer.c'`"
  1141. test 16747 -eq "$Wc_c" ||
  1142.     echo 'transfer.c: original size 16747, current size' "$Wc_c"
  1143. rm -f _shar_wnt_.tmp
  1144. fi
  1145. # ============= dofuncs.c ==============
  1146. if test -f 'dofuncs.c' -a X"$1" != X"-c"; then
  1147.     echo 'x - skipping dofuncs.c (File already exists)'
  1148.     rm -f _shar_wnt_.tmp
  1149. else
  1150. > _shar_wnt_.tmp
  1151. echo 'x - extracting dofuncs.c (Text)'
  1152. sed 's/^X//' << 'SHAR_EOF' > 'dofuncs.c' &&
  1153. #include "ftptool.h"
  1154. X
  1155. #ifdef USE_PROTOTYPES
  1156. int    doconnect(void)
  1157. #else
  1158. int    doconnect()
  1159. #endif
  1160. {
  1161. X    char    *ftphost;
  1162. X    char    *proxyhost;
  1163. X    char    *login;
  1164. X    char    *password;
  1165. X    char    crap[50];
  1166. X    int        rval;
  1167. X
  1168. #ifdef notdef
  1169. X    if (!openlook_mode || (xv_get(host_window.frame, FRAME_CMD_PIN_STATE)
  1170. X        == FRAME_CMD_PIN_OUT)) {
  1171. X        xv_set(host_window.frame,
  1172. X            XV_SHOW, FALSE,
  1173. X            FRAME_CMD_PIN_STATE, FRAME_CMD_PIN_OUT,
  1174. X            NULL);
  1175. X    }
  1176. #endif
  1177. X    /* used to make sure we are connected */
  1178. X    /* with PANEL_INACTIVE, don't need to anymore */
  1179. X    footer_message("", (char *)NULL);
  1180. X    local_footer_message("", (char *)NULL);
  1181. X    password = (char *)xv_get(host_window.basic.password, PANEL_VALUE);
  1182. X    if (*password == '\0') 
  1183. X        password = anonftp_password;
  1184. X
  1185. X    login = (char *)xv_get(host_window.basic.login, PANEL_VALUE);
  1186. X    if (*login == '\0') {
  1187. X        login = "anonymous";
  1188. X    }
  1189. X
  1190. X    ftphost = (char *)xv_get(host_window.basic.host, PANEL_VALUE);
  1191. X    rval = openhost(ftphost, login, password, ftp_port);
  1192. X    if (rval != 1)
  1193. X        return rval;
  1194. X    if (!try_proxy)
  1195. X        return 1;
  1196. X    proxyhost = (char *)xv_get(host_window.advanced.proxy, PANEL_VALUE);
  1197. X    /* crap for Iftp */
  1198. X    /* login must be 'user@ftphost' */
  1199. X    sprintf(crap, "%s@%s", login, ftphost);
  1200. X    return openhost(proxyhost, crap, password, ftp_passthru_port);
  1201. }
  1202. X
  1203. #ifdef USE_PROTOTYPES
  1204. int openhost(char *ftphost, char *login, char *password, int port)
  1205. #else
  1206. int openhost(ftphost, login, password, port)
  1207. char    *ftphost;
  1208. char    *login;
  1209. char    *password;
  1210. int        port;
  1211. #endif
  1212. {
  1213. X    char    *atsign;
  1214. X    char    *auto_cd;
  1215. X    int        rval = 0;
  1216. X
  1217. X    timedout = 0;
  1218. X    cursor_busy();
  1219. X    xv_set(host_window.basic.connect, 
  1220. X        PANEL_INACTIVE, TRUE, 
  1221. X        NULL);
  1222. X    xv_set(base_window.connect, 
  1223. X        PANEL_INACTIVE, TRUE, 
  1224. X        NULL);
  1225. X
  1226. X    xv_set(host_window.basic.host, 
  1227. X        PANEL_READ_ONLY, TRUE, 
  1228. X        NULL);
  1229. X    xv_set(host_window.advanced.proxy, 
  1230. X        PANEL_READ_ONLY, TRUE, 
  1231. X        NULL);
  1232. X    xv_set(host_window.basic.login, 
  1233. X        PANEL_READ_ONLY, TRUE, 
  1234. X        NULL);
  1235. X    xv_set(host_window.basic.password, 
  1236. X        PANEL_READ_ONLY, TRUE, 
  1237. X        NULL);
  1238. X    xv_set(host_window.advanced.remote_auto_cd, 
  1239. X        PANEL_READ_ONLY, TRUE, 
  1240. X        NULL);
  1241. X    xv_set(host_window.advanced.local_auto_cd, 
  1242. X        PANEL_READ_ONLY, TRUE, 
  1243. X        NULL);
  1244. X
  1245. X    xv_set(local_window.list, 
  1246. X        PANEL_INACTIVE, TRUE, 
  1247. X        NULL);
  1248. X    xv_set(local_window.directory, 
  1249. X        PANEL_READ_ONLY, TRUE, 
  1250. X        NULL);
  1251. X
  1252. X    xv_set(base_window.list, 
  1253. X        PANEL_INACTIVE, TRUE, 
  1254. X        NULL);
  1255. X    xv_set(base_window.directory, 
  1256. X        PANEL_READ_ONLY, TRUE, 
  1257. X        NULL);
  1258. X    xv_set(tool_property_window.apply, 
  1259. X        PANEL_INACTIVE, TRUE, 
  1260. X        NULL);
  1261. X    xv_set(tool_property_window.category, 
  1262. X        PANEL_INACTIVE, TRUE, 
  1263. X        NULL);
  1264. X
  1265. X    start_busy_cycle();
  1266. X    footer_message("Connecting...", (char *)NULL);
  1267. X    rval = ftp_hookup(ftphost, port);
  1268. X    switch (rval) {
  1269. X    case 0:    /* error */
  1270. X        rval = 2;
  1271. X        goto out;
  1272. X        break;
  1273. X    case 1:
  1274. X        /* couldn't resolve hostname: try proxy*/
  1275. X        goto out;
  1276. X        break;
  1277. X    default:
  1278. X        rval = 0;
  1279. X        break;
  1280. X    }
  1281. X    if ((rval = ftp_login(login, password)) == 0) {
  1282. X        rval = 2;
  1283. X        goto out;
  1284. X    }
  1285. X    footer_message("Initializing...", (char *)NULL);
  1286. X
  1287. X    connected = 1;
  1288. X
  1289. X    xv_set(schedule_window.process,
  1290. X        PANEL_INACTIVE, TRUE,
  1291. X        NULL);
  1292. X
  1293. X    update_timestamp();
  1294. X
  1295. X    (void)strncpy(icon_label, (char *)xv_get(host_window.basic.host, 
  1296. X        PANEL_VALUE), 8);
  1297. X    icon_label[8] = '\0';
  1298. X
  1299. X    xv_set(frame_icon,
  1300. X        ICON_LABEL, icon_label,
  1301. X        NULL);
  1302. X
  1303. X    xv_set(base_window.directory,
  1304. X        PANEL_INACTIVE, FALSE,
  1305. X        NULL);
  1306. X
  1307. X    /* ftphost is not the name of outside machines. Need to extract outside */
  1308. X    /* name from login */
  1309. X    if (atsign = index(login, '@'))
  1310. X        sprintf(scratch, "%s - %s", header_name, atsign + 1);
  1311. X    else
  1312. X        sprintf(scratch, "%s - %s", header_name, ftphost);
  1313. X    xv_set(base_window.frame, 
  1314. X        XV_LABEL, scratch, 
  1315. X        NULL);
  1316. X
  1317. X    dir_pattern = (char *)xv_get(host_window.advanced.dir_parse, PANEL_VALUE);
  1318. X    if (dir_pattern=='\0') {
  1319. X        footer_message("No DIR template specified. Defaulting to UNIX-style.",
  1320. X            (char *)NULL);
  1321. X        dir_pattern = dir_parse_to_pattern(DEFAULT_PARSE);
  1322. X    } else if ((dir_pattern = dir_parse_to_pattern(dir_pattern)) == NULL) {
  1323. X        footer_message("Defaulting to UNIX.", (char *)NULL);
  1324. X        dir_pattern = dir_parse_to_pattern(DEFAULT_PARSE);
  1325. X    }
  1326. X
  1327. X    if (dir_pattern[0] == (char)NONUNIX) {
  1328. X        non_unix = 1;
  1329. X        remote_sort_mode = SORTBYNAME;
  1330. X        xv_set(tool_property_window.directory_lists.remote_sort,
  1331. X            PANEL_VALUE, remote_sort_mode,
  1332. X            PANEL_INACTIVE, TRUE,
  1333. X            NULL);
  1334. X        set_remote_sort_order(SORTBYNAME);
  1335. X    }
  1336. X
  1337. X    auto_cd = (char *)xv_get(host_window.advanced.remote_auto_cd, PANEL_VALUE);
  1338. X    if (*auto_cd == '\0' || change_remote_dir(auto_cd, 0))
  1339. X        change_remote_dir(".", 0);
  1340. X    footer_message("", (char *)NULL);
  1341. X    auto_cd = (char *)xv_get(host_window.advanced.local_auto_cd, PANEL_VALUE);
  1342. X    if (*auto_cd != '\0' && strcmp(auto_cd, ".") != 0)
  1343. X        change_local_dir(auto_cd, 0);
  1344. X    local_footer_message("", (char *)NULL);
  1345. X    change_local_list_menu();
  1346. X
  1347. X    end_busy_cycle();
  1348. X    cursor_normal();
  1349. X    idle_timer_on();
  1350. X
  1351. X    /* activate buttons */
  1352. X
  1353. X    /* connect already inactive */
  1354. X    xv_set(host_window.basic.connect, 
  1355. X        PANEL_INACTIVE, FALSE, 
  1356. X        PANEL_LABEL_STRING, "Disconnect",
  1357. X        XV_HELP_DATA, "ftptool:DisconnectButton",
  1358. X        NULL);
  1359. X
  1360. X    xv_set(base_window.connect, 
  1361. X        PANEL_INACTIVE, FALSE, 
  1362. X        PANEL_LABEL_STRING, "Disconnect",
  1363. X        XV_HELP_DATA, "ftptool:DisconnectButton",
  1364. X        NULL);
  1365. X
  1366. X    xv_set(host_window.basic.host, 
  1367. X        PANEL_READ_ONLY, FALSE, 
  1368. X        NULL);
  1369. X    xv_set(host_window.basic.login, 
  1370. X        PANEL_READ_ONLY, FALSE, 
  1371. X        NULL);
  1372. X    xv_set(host_window.basic.password, 
  1373. X        PANEL_READ_ONLY, FALSE, 
  1374. X        NULL);
  1375. X    xv_set(host_window.advanced.proxy, 
  1376. X        PANEL_READ_ONLY, FALSE, 
  1377. X        NULL);
  1378. X    xv_set(host_window.advanced.remote_auto_cd, 
  1379. X        PANEL_READ_ONLY, FALSE, 
  1380. X        NULL);
  1381. X    xv_set(host_window.advanced.local_auto_cd, 
  1382. X        PANEL_READ_ONLY, FALSE, 
  1383. X        NULL);
  1384. X
  1385. X    xv_set(local_window.list, 
  1386. X        PANEL_INACTIVE, FALSE, 
  1387. X        NULL);
  1388. X    xv_set(base_window.list, 
  1389. X        PANEL_INACTIVE, FALSE, 
  1390. X        NULL);
  1391. X    xv_set(local_window.directory, 
  1392. X        PANEL_READ_ONLY, FALSE, 
  1393. X        NULL);
  1394. X    xv_set(base_window.directory, 
  1395. X        PANEL_READ_ONLY, FALSE, 
  1396. X        NULL);
  1397. X    xv_set(tool_property_window.apply, 
  1398. X        PANEL_INACTIVE, FALSE, 
  1399. X        NULL);
  1400. X    xv_set(tool_property_window.category, 
  1401. X        PANEL_INACTIVE, FALSE, 
  1402. X        NULL);
  1403. X
  1404. X    return 0;
  1405. out:
  1406. X    end_busy_cycle();
  1407. X    cursor_normal();
  1408. X    xv_set(host_window.basic.connect, 
  1409. X        PANEL_INACTIVE, FALSE, 
  1410. X        NULL);
  1411. X    xv_set(base_window.connect, 
  1412. X        PANEL_INACTIVE, FALSE, 
  1413. X        NULL);
  1414. X    xv_set(host_window.basic.host, 
  1415. X        PANEL_READ_ONLY, FALSE, 
  1416. X        NULL);
  1417. X    xv_set(host_window.basic.login, 
  1418. X        PANEL_READ_ONLY, FALSE, 
  1419. X        NULL);
  1420. X    xv_set(host_window.basic.password, 
  1421. X        PANEL_READ_ONLY, FALSE, 
  1422. X        NULL);
  1423. X    xv_set(host_window.advanced.proxy, 
  1424. X        PANEL_READ_ONLY, FALSE, 
  1425. X        NULL);
  1426. X    xv_set(host_window.advanced.remote_auto_cd, 
  1427. X        PANEL_READ_ONLY, FALSE, 
  1428. X        NULL);
  1429. X    xv_set(host_window.advanced.local_auto_cd, 
  1430. X        PANEL_READ_ONLY, FALSE, 
  1431. X        NULL);
  1432. X    xv_set(base_window.list, 
  1433. X        PANEL_INACTIVE, FALSE, 
  1434. X        NULL);
  1435. X    xv_set(local_window.list, 
  1436. X        PANEL_INACTIVE, FALSE, 
  1437. X        NULL);
  1438. X    xv_set(local_window.directory, 
  1439. X        PANEL_READ_ONLY, FALSE, 
  1440. X        NULL);
  1441. X    xv_set(base_window.directory, 
  1442. X        PANEL_READ_ONLY, FALSE, 
  1443. X        NULL);
  1444. X    xv_set(tool_property_window.apply, 
  1445. X        PANEL_INACTIVE, FALSE, 
  1446. X        NULL);
  1447. X    xv_set(tool_property_window.category, 
  1448. X        PANEL_INACTIVE, FALSE, 
  1449. X        NULL);
  1450. X    return rval;
  1451. }
  1452. X
  1453. #ifdef USE_PROTOTYPES
  1454. void    doget(void)
  1455. #else
  1456. void    doget()
  1457. #endif
  1458. {
  1459. X    int     nitems, row;
  1460. X    struct dirlist *tmp;
  1461. X    int        rval;
  1462. X    int        mode;
  1463. X    char    *name = NULL;
  1464. X    int        dirchanged = 0;
  1465. X
  1466. X    xfer_buttons_inactive();
  1467. X    abort_transfer = 0;
  1468. X    if (dirwasmodified()) {
  1469. X    /*
  1470. X        goto out;
  1471. X    */
  1472. X    }
  1473. X    if (ping_server())
  1474. X        goto out;
  1475. X    if (show_status)
  1476. X        xv_set(status_window.frame,
  1477. X            XV_SHOW, TRUE,
  1478. X            NULL);
  1479. X    init_status(sum_remote_size());
  1480. X    /* loop over each selected element, and do a get, then unselect */
  1481. X    nitems = xv_get(base_window.list, PANEL_LIST_NROWS);
  1482. X    for (row = 0; row < nitems; row++)
  1483. X        if (xv_get(base_window.list, PANEL_LIST_SELECTED, row)) {
  1484. X            tmp = (struct dirlist *)xv_get(base_window.list, 
  1485. X                PANEL_LIST_CLIENT_DATA, row);
  1486. X            mode = tmp->mode & S_IFMT;
  1487. X            if (non_unix) {
  1488. X                /* we can't transfer whole dirs on non-unix machines */
  1489. X                mode = S_IFREG;
  1490. X            }
  1491. X            switch(mode) {
  1492. X            case S_IFDIR:
  1493. X                dirchanged++;
  1494. X                if (rval = get_dir(remote_dircache.first->name, 
  1495. X                    local_dircache.first->name, tmp->name, tmp->name)) {
  1496. X                    if (rval == EEXIST) {
  1497. X                        footer_message("%s already exists.", 
  1498. X                            tmp->name, (char *)NULL);
  1499. X                    }
  1500. X                    goto out;
  1501. X                }
  1502. X                remote_list_ndirs--;
  1503. X                break;
  1504. X            case S_IFREG:
  1505. X                dirchanged++;
  1506. X                if (get_file(tmp->name, tmp->name, tmp->size))
  1507. X                    goto out;
  1508. X                remote_list_nfiles--;
  1509. X                break;
  1510. X            case S_IFLNK:
  1511. X                name = linkname(tmp->name);
  1512. X                if (name == NULL)
  1513. X                    goto out;
  1514. X                /* try as a file */
  1515. X                dirchanged++;
  1516. X                rval = get_file(name, name, (size_t)-1);
  1517. X                if (rval == EISDIR) {
  1518. X                    /* try as a directory */
  1519. X                    if (rval = get_dir(remote_dircache.first->name, 
  1520. X                        local_dircache.first->name, name, name) > 1) {
  1521. X                        /*
  1522. X                        if (rval == EEXIST) {
  1523. X                            footer_message("%s already exists.", 
  1524. X                                name, (char *)NULL);
  1525. X                        }
  1526. X                         */
  1527. X                        goto out;
  1528. X                    }
  1529. X                } else if (rval != 0) {
  1530. X                    goto out;
  1531. X                }
  1532. X                free(name);
  1533. X                name = NULL;
  1534. X                remote_list_nfiles--;
  1535. X                break;
  1536. X            default:
  1537. X                remote_list_nothers--;
  1538. X                footer_message("Ignoring non-file/directory %s.", 
  1539. X                    tmp->name, (char *)NULL);
  1540. X                log_message("Can only transfer files.\n");
  1541. X                break;
  1542. X            }
  1543. X            xv_set(base_window.list, 
  1544. X                PANEL_LIST_SELECT, row, FALSE, 
  1545. X                NULL);
  1546. X            remote_show_items();
  1547. X        }
  1548. X
  1549. out:
  1550. X    if (dirchanged)
  1551. X        change_local_dir(".", 1);
  1552. X    if (show_status)
  1553. X        xv_set(status_window.frame,
  1554. X            XV_SHOW, FALSE,
  1555. X            NULL);
  1556. X    update_status_label("Not", "transferring", (size_t)0);
  1557. X    end_status();
  1558. X    if (name)
  1559. X        free(name);
  1560. X    change_remote_list_menu();
  1561. X    xfer_buttons_active();
  1562. X    if (timedout)
  1563. X        timeout_disconnect();
  1564. X    return;
  1565. }
  1566. X
  1567. #ifdef USE_PROTOTYPES
  1568. void    doput(void)
  1569. #else
  1570. void    doput()
  1571. #endif
  1572. {
  1573. X    int     nitems, row;
  1574. X    struct dirlist *tmp;
  1575. X    int        rval = 0;
  1576. X    int        mode;
  1577. X    char    *name = NULL;
  1578. X    int        dirchanged = 0;
  1579. X
  1580. X    xfer_buttons_inactive();
  1581. X    abort_transfer = 0;
  1582. X    if (dirwasmodified()) {
  1583. X        goto out;
  1584. X    }
  1585. X    if (ping_server())
  1586. X        goto out;
  1587. X    if (show_status)
  1588. X        xv_set(status_window.frame,
  1589. X            XV_SHOW, TRUE,
  1590. X            NULL);
  1591. X    init_status(sum_local_size());
  1592. X    /* loop over each selected element, and do a get, then unselect */
  1593. X    nitems = xv_get(local_window.list, PANEL_LIST_NROWS);
  1594. X    for (row = 0; row < nitems; row++)
  1595. X        if (xv_get(local_window.list, PANEL_LIST_SELECTED, row)) {
  1596. X            tmp = (struct dirlist *)xv_get(local_window.list, 
  1597. X                PANEL_LIST_CLIENT_DATA, row);
  1598. X            mode = tmp->mode & S_IFMT;
  1599. X            if (non_unix) {
  1600. X                /* we can't transfer whole dirs on non-unix machines */
  1601. X                mode = S_IFREG;
  1602. X            }
  1603. X            switch(mode) {
  1604. X            case S_IFDIR:
  1605. X                dirchanged++;
  1606. X                if (rval = put_dir(remote_dircache.first->name, 
  1607. X                    local_dircache.first->name, tmp->name, tmp->name)) {
  1608. X                    goto out;
  1609. X                }
  1610. X                local_list_ndirs--;
  1611. X                break;
  1612. X            case S_IFREG:
  1613. X                dirchanged++;
  1614. X                if (rval = put_file(tmp->name, tmp->name, tmp->size))
  1615. X                    goto out;
  1616. X                local_list_nfiles--;
  1617. X                break;
  1618. X            case S_IFLNK:
  1619. X                name = linkname(tmp->name);
  1620. X                if (name == NULL)
  1621. X                    goto out;
  1622. X                /* try as a file */
  1623. X                dirchanged++;
  1624. X                rval = put_file(name, name, (size_t)-1);
  1625. X                if (rval == EPERM) {
  1626. X                    if (rval = put_dir(remote_dircache.first->name, 
  1627. X                        local_dircache.first->name, name, name)) {
  1628. X                        goto out;
  1629. X                    }
  1630. X                } else if (rval != 0) {
  1631. X                    goto out;
  1632. X                }
  1633. X                local_list_nfiles--;
  1634. X                free(name);
  1635. X                name = NULL;
  1636. X                break;
  1637. X            default:
  1638. X                local_list_nothers--;
  1639. X                local_footer_message("Ignoring non-file/directory %s.", 
  1640. X                    tmp->name, (char *)NULL);
  1641. X                log_message("Can only transfer files.\n");
  1642. X                break;
  1643. X            }
  1644. X            xv_set(local_window.list, 
  1645. X                PANEL_LIST_SELECT, row, FALSE, 
  1646. X                NULL);
  1647. X            local_show_items();
  1648. X        }
  1649. X
  1650. out:
  1651. X    if (dirchanged)
  1652. X        change_remote_dir(".", 1);
  1653. X    if (show_status)
  1654. X        xv_set(status_window.frame,
  1655. X            XV_SHOW, FALSE,
  1656. X            NULL);
  1657. X    update_status_label("Not", "transferring", (size_t)0);
  1658. X    end_status();
  1659. X    if (name)
  1660. X        free(name);
  1661. X    change_local_list_menu();
  1662. X    xfer_buttons_active();
  1663. X    if (rval == ENOSPC) {
  1664. X        disconnect();
  1665. X    }
  1666. X    if (timedout)
  1667. X        timeout_disconnect();
  1668. X    return;
  1669. }
  1670. X
  1671. #ifdef USE_PROTOTYPES
  1672. void    dofileop(int which)
  1673. #else
  1674. void    dofileop(which)
  1675. int        which; /* uncompress or extract */
  1676. #endif
  1677. {
  1678. X    int     nitems, row;
  1679. X    struct dirlist *tmp;
  1680. X    int        mode;
  1681. X    int        dirchanged = 0;
  1682. X    char    *name = NULL;
  1683. X    struct stat buf;
  1684. X    extern char    *sys_errlist[];
  1685. X
  1686. X    xfer_buttons_inactive();
  1687. X    abort_transfer = 0;
  1688. X    if (dirwasmodified()) {
  1689. X    /*
  1690. X        goto out;
  1691. X    */
  1692. X    }
  1693. X    if (which == DOGETTARFILENAME) {
  1694. X        xv_set(tar_frame, 
  1695. X            XV_SHOW, TRUE, 
  1696. X            NULL);
  1697. X        goto out;
  1698. X    } else if (which == DOTAR) {
  1699. X        create_tar_file();
  1700. X        goto out;
  1701. X    }
  1702. X    nitems = xv_get(local_window.list, PANEL_LIST_NROWS);
  1703. X    /* loop over each selected element, and do a get, then unselect */
  1704. X    for (row = 0; row < nitems; row++)
  1705. X        if (xv_get(local_window.list, PANEL_LIST_SELECTED, row)) {
  1706. X            /* perhaps should recursively get directories? */
  1707. X            tmp = (struct dirlist *)xv_get(local_window.list, 
  1708. X                PANEL_LIST_CLIENT_DATA, row);
  1709. X            mode = tmp->mode & S_IFMT;
  1710. X            if (non_unix) {
  1711. X                /* we can't do anything to whole dirs on non-unix machines */
  1712. X                mode = S_IFREG;
  1713. X            }
  1714. X            switch(mode) {
  1715. X            case S_IFDIR:
  1716. X                local_footer_message("Ignoring directory.", (char *)NULL);
  1717. X                local_list_ndirs--;
  1718. X                break;
  1719. X            case S_IFLNK:
  1720. X            case S_IFREG:
  1721. X                if (S_ISLNK(mode))
  1722. X                    name = linkname(tmp->name);
  1723. X                else
  1724. X                    name = strdup(tmp->name);
  1725. X                if (name == NULL) {
  1726. X                    fprintf(stderr, "Out of memory.\n");
  1727. X                    goto out;
  1728. X                }
  1729. X                if (stat(name, &buf) == -1) {
  1730. X                    local_footer_message("%s: %s.", name, sys_errlist[errno]);
  1731. X                    goto out;
  1732. X                }
  1733. X                if (!S_ISREG(buf.st_mode)) {
  1734. X                    local_footer_message("%s is not a regular file.", name);
  1735. X                    goto out;
  1736. X                }
  1737. X                switch(which) {
  1738. X                case DOUNCOMPRESS:
  1739. X                    if (file_type(name) == COMPRESSED) {
  1740. X                        local_footer_message("Uncompressing %s\n", 
  1741. X                            name, (char *)NULL);
  1742. X                        uncompress_file(name, "-vf");
  1743. X                    } else
  1744. X                        local_footer_message("%s not compressed.\n", 
  1745. X                            name, (char *)NULL);
  1746. X                    break;
  1747. X                case DOEXTRACT:
  1748. X                    if (file_type(name) == COMPRESSED) {
  1749. X                        char *dot;
  1750. X
  1751. X                        local_footer_message("Uncompressing %s\n", 
  1752. X                            name, (char *)NULL);
  1753. X                        uncompress_file(name, "-vf");
  1754. X                        dot = rindex(name, '.');
  1755. X                        if (dot) {
  1756. X                            *dot = '\0';
  1757. X                        }
  1758. X                    }
  1759. X                    if (file_type(name) == TARFILE) {
  1760. X                        start_viewer(name, 0); /* will do tar viewer */
  1761. X                    } else {
  1762. X                        local_footer_message("%s is not a tar file\n", 
  1763. X                            name, (char *)NULL);
  1764. X                    }
  1765. X                    break;
  1766. X                case DOCOMPRESS:
  1767. X                    if (file_type(name) != COMPRESSED) {
  1768. X                        local_footer_message("Compressing %s\n", 
  1769. X                            name, (char *)NULL);
  1770. X                        compress_file(name, "-vf");
  1771. X                    } else {
  1772. X                        local_footer_message("%s already compressed\n", 
  1773. X                            name, (char *)NULL);
  1774. X                    }
  1775. X                    break;
  1776. X                }
  1777. X                free(name);
  1778. X                name = NULL;
  1779. X                local_list_nfiles--;
  1780. X                dirchanged++;
  1781. X                break;
  1782. X            default:
  1783. X                local_list_nothers--;
  1784. X                local_footer_message("Ignoring non-file/directory %s.",
  1785. X                    tmp->name, (char *)NULL);
  1786. X                log_message("Ignoring non-file.\n");
  1787. X                break;
  1788. X            }
  1789. X            xv_set(local_window.list, 
  1790. X                PANEL_LIST_SELECT, row, FALSE, 
  1791. X                NULL);
  1792. X            local_show_items();
  1793. X        }
  1794. X
  1795. out:
  1796. X    if (name)
  1797. X        free(name);
  1798. X    change_local_list_menu();
  1799. X    if (dirchanged)
  1800. X        change_local_dir(".", 1);
  1801. X    xfer_buttons_active();
  1802. X    if (timedout)
  1803. X        timeout_disconnect();
  1804. X    return;
  1805. X
  1806. }
  1807. X
  1808. #ifdef USE_PROTOTYPES
  1809. void    doview(int which)
  1810. #else
  1811. void    doview(which)
  1812. int        which; /* local or remote */
  1813. #endif
  1814. {
  1815. X    int     nitems, row;
  1816. X    struct dirlist *tmp;
  1817. X    Panel    list_panel;
  1818. X    int        mode;
  1819. X    int        dirchanged=0;
  1820. X    char    *name = NULL;
  1821. X
  1822. X    xfer_buttons_inactive();
  1823. X    abort_transfer = 0;
  1824. X    if (dirwasmodified()) {
  1825. X    /*
  1826. X        goto out;
  1827. X    */
  1828. X    }
  1829. X    if (which == DOREMOTEVIEW) {
  1830. X        list_panel = base_window.list;
  1831. X        if (ping_server())
  1832. X            goto out;
  1833. X        if (show_status)
  1834. X            xv_set(status_window.frame,
  1835. X                XV_SHOW, TRUE,
  1836. X                NULL);
  1837. X        init_status(sum_remote_size());
  1838. X    } else
  1839. X        list_panel = local_window.list;
  1840. X    /* loop over each selected element, and do a get, then unselect */
  1841. X    nitems = xv_get(list_panel, PANEL_LIST_NROWS);
  1842. X    for (row = 0; row < nitems; row++)
  1843. X        if (xv_get(list_panel, PANEL_LIST_SELECTED, row)) {
  1844. X            /* perhaps should recursively get directories? */
  1845. X            tmp = (struct dirlist *)xv_get(list_panel, 
  1846. X                PANEL_LIST_CLIENT_DATA, row);
  1847. X            mode = tmp->mode & S_IFMT;
  1848. X            if (non_unix) {
  1849. X                /* we can't do anything to whole dirs on non-unix machines */
  1850. X                mode = S_IFREG;
  1851. X            }
  1852. X            switch(mode) {
  1853. X            case S_IFDIR:
  1854. X                if (which == DOREMOTEVIEW) {
  1855. X                    footer_message("Can't View a directory.", (char *)NULL);
  1856. X                    remote_list_ndirs--;
  1857. X                } else {
  1858. X                    local_footer_message("Can't View a directory.", 
  1859. X                        (char *)NULL);
  1860. X                    local_list_ndirs--;
  1861. X                }
  1862. X                break;
  1863. X            case S_IFLNK:
  1864. X            case S_IFREG:
  1865. X                if (S_ISLNK(mode))
  1866. X                    name = linkname(tmp->name);
  1867. X                else
  1868. X                    name = strdup(tmp->name);
  1869. X                if (name == NULL) {
  1870. X                    fprintf(stderr, "Out of memory.\n");
  1871. X                    goto out;
  1872. X                }
  1873. X                if (which == DOREMOTEVIEW) {
  1874. X                    if (view_remote_file(name, tmp->size))
  1875. X                        goto out;
  1876. X                    remote_list_nfiles--;
  1877. X                } else {
  1878. X                    if (view_local_file(name, which, &dirchanged))
  1879. X                        goto out;
  1880. X                    local_list_nfiles--;
  1881. X                }
  1882. X                free(name);
  1883. X                name = NULL;
  1884. X                break;
  1885. X            default:
  1886. X                log_message("Can only transfer files.\n");
  1887. X                if (which == DOREMOTEVIEW) {
  1888. X                    footer_message("Ignoring non-file/directory %s.", 
  1889. X                        tmp->name, (char *)NULL);
  1890. X                    remote_list_nothers--;
  1891. X                } else {
  1892. X                    local_footer_message("Ignoring non-file/directory %s.",
  1893. X                        tmp->name, (char *)NULL);
  1894. X                    local_list_nothers--;
  1895. X                }
  1896. X                break;
  1897. X            }
  1898. X            xv_set(list_panel, 
  1899. X                PANEL_LIST_SELECT, row, FALSE, 
  1900. X                NULL);
  1901. X            local_show_items();
  1902. X            remote_show_items();
  1903. X        }
  1904. X
  1905. out:
  1906. X    if (name)
  1907. X        free(name);
  1908. X    if (which == DOREMOTEVIEW) {
  1909. X        change_remote_list_menu();
  1910. X        if (show_status)
  1911. X            xv_set(status_window.frame,
  1912. X                XV_SHOW, FALSE,
  1913. X                NULL);
  1914. X    } else
  1915. X        change_local_list_menu();
  1916. X    update_status_label("Not", "transferring", (size_t)0);
  1917. X    end_status();
  1918. X    if (dirchanged)
  1919. X        change_local_dir(".", 1);
  1920. X    xfer_buttons_active();
  1921. X    if (timedout)
  1922. X        timeout_disconnect();
  1923. X    return;
  1924. }
  1925. X
  1926. #ifdef USE_PROTOTYPES
  1927. void create_tar_file(void)
  1928. #else
  1929. void create_tar_file()
  1930. #endif
  1931. {
  1932. X    int     nitems, row;
  1933. X    char    *filename = 0;
  1934. X    struct dirlist *tmp;
  1935. X    char    **argv;
  1936. X    char    *slash;
  1937. X    int        ix;
  1938. X
  1939. X
  1940. X    xfer_buttons_inactive();
  1941. X
  1942. X    if (dirwasmodified()) {
  1943. X    /*
  1944. X        goto out;
  1945. X    */
  1946. X    }
  1947. X
  1948. X    filename = (char *)xv_get(tar_text, PANEL_VALUE);
  1949. X    if (*filename == '\0') {
  1950. X        local_footer_message("Type in a name for the tar file", (char *)NULL);
  1951. X        goto out;
  1952. X    }
  1953. X
  1954. X    local_footer_message("Creating tar file %s", filename, (char *)NULL);
  1955. X    nitems = xv_get(local_window.list, PANEL_LIST_NROWS);
  1956. X    /* slightly different - take ALL seletctions and put them in a */
  1957. X    /* tar file */
  1958. X    if ((argv = (char **)malloc((unsigned int)((3+nitems+1)*sizeof(char *)))) 
  1959. X        == NULL) {
  1960. X        fprintf(stderr, "Out of memory.\n");
  1961. X        goto out;
  1962. X    }
  1963. X    ix = 3;
  1964. X    for (row = 0; row < nitems; row++)
  1965. X        if (xv_get(local_window.list, PANEL_LIST_SELECTED, row)) {
  1966. X            tmp = (struct dirlist *)xv_get(local_window.list, 
  1967. X                PANEL_LIST_CLIENT_DATA, row);
  1968. X            if (!S_ISDIR(tmp->mode) && !S_ISREG(tmp->mode) 
  1969. X                && !S_ISLNK(tmp->mode))
  1970. X                continue;
  1971. X            argv[ix] = strdup(tmp->name);
  1972. X            if (argv[ix] == NULL) {
  1973. X                fprintf(stderr, "Out of memory.\n");
  1974. X                for (ix--; ix > 2; ix--)
  1975. X                    free(argv[ix]);
  1976. X                free((char *)argv);
  1977. X                goto out;
  1978. X            }
  1979. X            slash = index(argv[ix], '/');
  1980. X            if (slash)
  1981. X                *slash = '\0';
  1982. X            ix++;
  1983. X            if (S_ISDIR(tmp->mode))
  1984. X                local_list_ndirs--;
  1985. X            else
  1986. X                local_list_nfiles--;
  1987. X            xv_set(local_window.list, 
  1988. X                PANEL_LIST_SELECT, row, FALSE, 
  1989. X                NULL);
  1990. X            local_show_items();
  1991. X        }
  1992. X    argv[0] = "tar";
  1993. X    argv[1] = "cvf";
  1994. X    argv[2] = filename;
  1995. X    argv[ix] = NULL;
  1996. X    if (ix == 2)
  1997. X        goto out;
  1998. X    pipe_program(argv);
  1999. X    xv_set(local_window.list, 
  2000. X        XV_SHOW, TRUE, 
  2001. X        NULL);
  2002. X    for (ix--; ix > 2; ix--)
  2003. X        free(argv[ix]);
  2004. X    free((char *)argv);
  2005. X    change_local_dir(".", 1);
  2006. out:
  2007. X    xfer_buttons_active();
  2008. X    if (timedout)
  2009. X        timeout_disconnect();
  2010. X    return;
  2011. }
  2012. X
  2013. #ifdef USE_PROTOTYPES
  2014. void    doremotecd(int force)
  2015. #else
  2016. void    doremotecd(force)
  2017. int        force;
  2018. #endif
  2019. {
  2020. X    if (which_remote_file == NULL)
  2021. X        return;
  2022. X    xfer_buttons_inactive();
  2023. X    change_remote_dir(which_remote_file, force);
  2024. X    free(which_remote_file);
  2025. X    which_remote_file = NULL;
  2026. X    xfer_buttons_active();
  2027. X    if (timedout)
  2028. X        timeout_disconnect();
  2029. }
  2030. X
  2031. SHAR_EOF
  2032. chmod 0644 dofuncs.c ||
  2033. echo 'restore of dofuncs.c failed'
  2034. Wc_c="`wc -c < 'dofuncs.c'`"
  2035. test 20039 -eq "$Wc_c" ||
  2036.     echo 'dofuncs.c: original size 20039, current size' "$Wc_c"
  2037. rm -f _shar_wnt_.tmp
  2038. fi
  2039. # ============= main.c ==============
  2040. if test -f 'main.c' -a X"$1" != X"-c"; then
  2041.     echo 'x - skipping main.c (File already exists)'
  2042.     rm -f _shar_wnt_.tmp
  2043. else
  2044. > _shar_wnt_.tmp
  2045. echo 'x - extracting main.c (Text)'
  2046. sed 's/^X//' << 'SHAR_EOF' > 'main.c' &&
  2047. #define EXTERN
  2048. X
  2049. #include "ftptool.h"
  2050. X
  2051. unsigned short icon_array[] = {
  2052. #include "./ftptool.icon"
  2053. };
  2054. X
  2055. static unsigned short busy1_icon_array[] = {
  2056. #include "./busy1.ftptool.icon"
  2057. };
  2058. X
  2059. static unsigned short busy2_icon_array[] = {
  2060. #include "./busy2.ftptool.icon"
  2061. };
  2062. X
  2063. static unsigned short busy3_icon_array[] = {
  2064. #include "./busy3.ftptool.icon"
  2065. };
  2066. X
  2067. static unsigned short busy4_icon_array[] = {
  2068. #include "./busy4.ftptool.icon"
  2069. };
  2070. X
  2071. static unsigned short directory_pr_array[] = {
  2072. #include "./directory.pr"
  2073. };
  2074. X
  2075. static unsigned short file_pr_array[] = {
  2076. #include "./file.pr"
  2077. };
  2078. X
  2079. static unsigned short dotdot_pr_array[] = {
  2080. #include "./dotdot.pr"
  2081. };
  2082. X
  2083. static unsigned short unknown_pr_array[] = {
  2084. #include "./unknown.pr"
  2085. };
  2086. X
  2087. int nbusyicons = 4;
  2088. Server_image busy_glyphs[4];
  2089. X
  2090. Server_image ftptool_glyph;
  2091. X
  2092. static struct itimerval date_timer = {
  2093. X    {300, 0},
  2094. X    {300, 0},
  2095. };
  2096. X
  2097. #ifdef USE_PROTOTYPES
  2098. int main(int argc, char **argv)
  2099. #else
  2100. int main(argc, argv)
  2101. int        argc;
  2102. char    **argv;
  2103. #endif
  2104. {
  2105. X    char    *helppath;
  2106. X    int    closed=0;
  2107. X    struct servent *servent;
  2108. X
  2109. X    /* FTP inits */
  2110. X    data = -1;
  2111. X    abrtflag = 0;
  2112. X    ptflag = 0;
  2113. X    verbose = 1;
  2114. X    debug = 0;
  2115. X    code = -1;
  2116. X    cpend = 0;
  2117. X    curtype = 0;
  2118. X    crflag = 1;
  2119. X    runique = 0;
  2120. X    sendport = -1;
  2121. X    restart_point = 0;
  2122. X
  2123. X    bzero((char *)&local_dircache, sizeof(local_dircache));
  2124. X    bzero((char *)&remote_dircache, sizeof(remote_dircache));
  2125. X
  2126. X    bzero((char *)&schedule_list, sizeof(schedule_list));
  2127. X
  2128. X    program_name = argv[0];
  2129. X
  2130. X    /*
  2131. X     * Determine port numbers to use
  2132. X     */
  2133. X    servent = getservbyname("ftp", "tcp");
  2134. X    if (servent != NULL) {
  2135. X        ftp_port = servent->s_port;
  2136. X    } else {
  2137. X        fprintf(stderr, "Couldn't find 'ftp' service. Using %d.\n", 
  2138. X            FTP_PORT);
  2139. X        ftp_port = htons(FTP_PORT);
  2140. X    }
  2141. X    servent = getservbyname("ftp-passthru", "tcp");
  2142. X    if (servent != NULL) {
  2143. X        ftp_passthru_port = servent->s_port;
  2144. X    } else {
  2145. X        fprintf(stderr, "Couldn't find 'ftp-passthru' service. Using %d.\n", 
  2146. X            FTP_PASSTHRU_PORT);
  2147. X        ftp_passthru_port = htons(FTP_PASSTHRU_PORT);
  2148. X    }
  2149. X
  2150. X    try_proxy = 1;
  2151. X
  2152. X    sprintf(scratch, "Ftptool Version %d.%d", VERSION, PATCHLEVEL);
  2153. X    /*
  2154. X    sprintf(scratch, "Ftptool Version %d.%d (Beta9)", VERSION, PATCHLEVEL);
  2155. X     */
  2156. X    header_name = strdup(scratch);
  2157. X    if (header_name == NULL) {
  2158. X        perror("malloc");
  2159. X        exit(1);
  2160. X    }
  2161. X
  2162. X    /*
  2163. X     * Initialize XView.
  2164. X     */
  2165. X    xv_init(XV_INIT_ARGC_PTR_ARGV, &argc, argv, NULL);
  2166. X    
  2167. X    if ((helppath = getenv("HELPPATH")) == NULL) {
  2168. X        putenv("HELPPATH=/usr/local/lib/help:.");
  2169. X    } else {
  2170. X        sprintf(scratch, "HELPPATH=%s:/usr/local/lib/help:.", helppath);
  2171. X        putenv(strdup(scratch));
  2172. X    }
  2173. X
  2174. X    load_xdefaults();
  2175. X
  2176. X    netrc_filename = find_dotfile(".netrc");
  2177. X
  2178. X    if (argc > 1) {
  2179. X        handle_tarfile(argv[1]);
  2180. X    }
  2181. X
  2182. X    ftptool_glyph = (Server_image )xv_create(XV_NULL,SERVER_IMAGE,
  2183. X        XV_WIDTH, 64,
  2184. X        XV_HEIGHT,64,
  2185. X        SERVER_IMAGE_DEPTH, 1,
  2186. X        SERVER_IMAGE_BITS,icon_array,
  2187. X        NULL);
  2188. X
  2189. X    directory_glyph = (Server_image )xv_create(XV_NULL,SERVER_IMAGE,
  2190. X        XV_WIDTH, 16,
  2191. X        XV_HEIGHT,16,
  2192. X        SERVER_IMAGE_DEPTH, 1,
  2193. X        SERVER_IMAGE_BITS,directory_pr_array,
  2194. X        NULL);
  2195. X
  2196. X    file_glyph = (Server_image )xv_create(XV_NULL,SERVER_IMAGE,
  2197. SHAR_EOF
  2198. true || echo 'restore of main.c failed'
  2199. fi
  2200. echo 'End of  part 6'
  2201. echo 'File main.c is continued in part 7'
  2202. echo 7 > _shar_seq_.tmp
  2203. exit 0
  2204. -- 
  2205. Senior Systems Scientist        mail: dcmartin@msi.com
  2206. Molecular Simulations, Inc.        uucp: uunet!dcmartin
  2207. 796 North Pastoria Avenue        at&t: 408/522-9236
  2208. Sunnyvale, California 94086        fax: 408/732-0831
  2209.