home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / x / volume20 / xarchie / part08 < prev    next >
Encoding:
Text File  |  1993-06-14  |  50.4 KB  |  1,827 lines
  1. Newsgroups: comp.sources.x
  2. From: ferguson@cs.rochester.edu (George Ferguson)
  3. Subject: v20i036:  xarchie - An X browser interface to Archie, v2.0.6, Part08/24
  4. Message-ID: <1993Jun15.223253.370@sparky.imd.sterling.com>
  5. X-Md4-Signature: 4fed3aca02668e4d0f071088ca1a8b2a
  6. Sender: chris@sparky.imd.sterling.com (Chris Olson)
  7. Organization: Sterling Software
  8. Date: Tue, 15 Jun 1993 22:32:53 GMT
  9. Approved: chris@sparky.imd.sterling.com
  10.  
  11. Submitted-by: ferguson@cs.rochester.edu (George Ferguson)
  12. Posting-number: Volume 20, Issue 36
  13. Archive-name: xarchie/part08
  14. Environment: X11
  15. Supersedes: xarchie: Volume 14, Issue 82-90
  16.  
  17. Submitted-by: ferguson@cs.rochester.edu
  18. Archive-name: xarchie-2.0.6/part08
  19.  
  20. #!/bin/sh
  21. # this is Part.08 (part 8 of xarchie-2.0.6)
  22. # do not concatenate these parts, unpack them in order with /bin/sh
  23. # file xarchie-2.0.6/file-panel.c continued
  24. #
  25. if test ! -r _shar_seq_.tmp; then
  26.     echo 'Please unpack part 1 first!'
  27.     exit 1
  28. fi
  29. (read Scheck
  30.  if test "$Scheck" != 8; then
  31.     echo Please unpack part "$Scheck" next!
  32.     exit 1
  33.  else
  34.     exit 0
  35.  fi
  36. ) < _shar_seq_.tmp || exit 1
  37. if test ! -f _shar_wnt_.tmp; then
  38.     echo 'x - still skipping xarchie-2.0.6/file-panel.c'
  39. else
  40. echo 'x - continuing file xarchie-2.0.6/file-panel.c'
  41. sed 's/^X//' << 'SHAR_EOF' >> 'xarchie-2.0.6/file-panel.c' &&
  42. #include "db.h"
  43. #include "browser.h"
  44. #include "appres.h"
  45. #include "saveload.h"
  46. #include "file-panel.h"
  47. #include "fchooser.h"
  48. #include "status.h"
  49. #include "xutil.h"
  50. extern DbEntry *db;
  51. X
  52. /*
  53. X * Functions defined here
  54. X */
  55. void initFilePanelActions();
  56. void updateFileWriteMode();
  57. void setFileShellState();
  58. X
  59. static void fileSaveAction(),fileLoadAction(),fileWriteAction();
  60. static void popupFilePanel(),initFileWidgets();
  61. static void filePanelOk(),filePanelCancel();
  62. /*
  63. static FileChooserOkProc filePanelOk;
  64. static FileChooserCancelProc filePanelCancel;
  65. */
  66. static void writeModeWidgetsShown();
  67. X
  68. /*
  69. X * Data defined here
  70. X */
  71. static FileChooserInfo *fcinfo;
  72. static Widget fileShell,filePanelLabel;
  73. static Widget filePanelWriteModeButton,filePanelWriteModeLabel;
  74. static Boolean fileGoing,isPoppedUp;
  75. static int fileOp;
  76. X
  77. static XtActionsRec actionTable[] = {
  78. X    { "file-save",        fileSaveAction },
  79. X    { "file-load",        fileLoadAction },
  80. X    { "file-write",        fileWriteAction },
  81. };
  82. X
  83. void
  84. initFilePanelActions()
  85. {
  86. X    XtAppAddActions(appContext,actionTable,XtNumber(actionTable));
  87. }
  88. X
  89. /*    -    -    -    -    -    -    -    -    */
  90. /* Action Procedures */
  91. X
  92. #define ACTION_PROC(NAME)    void NAME(w,event,params,num_params) \
  93. X                    Widget w; \
  94. X                    XEvent *event; \
  95. X                    String *params; \
  96. X                    Cardinal *num_params;
  97. X
  98. /*ARGSUSED*/
  99. static
  100. ACTION_PROC(fileSaveAction)
  101. {
  102. X    popupFilePanel(FILE_SAVE);
  103. }
  104. X
  105. /*ARGSUSED*/
  106. static
  107. ACTION_PROC(fileLoadAction)
  108. {
  109. X    popupFilePanel(FILE_LOAD);
  110. }
  111. X
  112. /*ARGSUSED*/
  113. static
  114. ACTION_PROC(fileWriteAction)
  115. {
  116. X    popupFilePanel(FILE_WRITE);
  117. }
  118. X
  119. static void
  120. popupFilePanel(op)
  121. int op;
  122. {
  123. X    /* Ignore if the browser is being changed */
  124. X    if (getBrowserState() != BROWSER_READY) {
  125. X    XBell(display,0);
  126. X    return;
  127. X    }
  128. X    /* Create if this is the first time */
  129. X    if (fileShell == NULL) {
  130. X    setBusyStatus(True);
  131. X    initFileWidgets();
  132. X    setBusyStatus(False);
  133. X    }
  134. #ifdef FILECHOOSER
  135. X      else {
  136. X      status0("Re-initializing File Selector...");
  137. X      XfwfFileChooserRefresh((XfwfFileChooserWidget)(fcinfo->fcw));
  138. X    }
  139. #endif
  140. X    switch (op) {
  141. X    case FILE_SAVE:
  142. X        setWidgetLabel(filePanelLabel,"Save to file:");
  143. X        writeModeWidgetsShown(False);
  144. X        break;
  145. X    case FILE_LOAD:
  146. X        setWidgetLabel(filePanelLabel,"Load from file:");
  147. X        writeModeWidgetsShown(False);
  148. X        break;
  149. X    case FILE_WRITE:
  150. X        setWidgetLabel(filePanelLabel,"Write to file:");
  151. X        writeModeWidgetsShown(True);
  152. X        break;
  153. X    }
  154. X    fileOp = op;
  155. X    if (isPoppedUp) {
  156. X    XRaiseWindow(display,XtWindow(fileShell));
  157. X    } else {
  158. X    isPoppedUp = True;
  159. X    XtPopup(fileShell,XtGrabNone);
  160. X    }
  161. }
  162. X
  163. static void
  164. initFileWidgets()
  165. {
  166. X    Widget form;
  167. X    Arg args[1];
  168. X
  169. X    fileShell = XtCreatePopupShell("filePanelShell",topLevelShellWidgetClass,
  170. X                   toplevel,NULL,0);
  171. X    form = XtCreateManagedWidget("filePanelForm",formWidgetClass,
  172. X                 fileShell,NULL,0);
  173. X    filePanelLabel = XtCreateManagedWidget("filePanelLabel",labelWidgetClass,
  174. X                       form,NULL,0);
  175. X    filePanelWriteModeButton =
  176. X    XtCreateManagedWidget("filePanelWriteModeButton",menuButtonWidgetClass,
  177. X                  form,NULL,0);
  178. X    filePanelWriteModeLabel =
  179. X    XtCreateManagedWidget("filePanelWriteModeLabel",labelWidgetClass,
  180. X                  form,NULL,0);
  181. X    fcinfo = createFileChooser(fileShell,form,"filePanel",filePanelOk,
  182. X                   filePanelCancel,(XtPointer)fileShell);
  183. X    /* Adjust vertical layout */
  184. X    XtSetArg(args[0],XtNfromVert,filePanelWriteModeButton);
  185. #ifdef FILECHOOSER
  186. X    XtSetValues(fcinfo->fcw,args,1);
  187. #else
  188. X    XtSetValues(fcinfo->text,args,1);
  189. #endif
  190. X    /* Realize them all */
  191. X    XtRealizeWidget(fileShell);
  192. X    /* Register window for WM */
  193. X    (void)XSetWMProtocols(XtDisplay(fileShell),XtWindow(fileShell),
  194. X              &WM_DELETE_WINDOW,1);
  195. X    updateFileWriteMode(appResources.fileWriteOnePerLine);
  196. }
  197. X
  198. static void
  199. writeModeWidgetsShown(state)
  200. Boolean state;
  201. {
  202. X    if (state) {
  203. X    XtMapWidget(filePanelWriteModeButton);
  204. X    XtMapWidget(filePanelWriteModeLabel);
  205. X    } else {
  206. X    XtUnmapWidget(filePanelWriteModeButton);
  207. X    XtUnmapWidget(filePanelWriteModeLabel);
  208. X    }
  209. }
  210. X
  211. void
  212. setFileShellState(state)
  213. int state;
  214. {
  215. X    if (!isPoppedUp)
  216. X    return;
  217. X    switch (state) {
  218. X    case NormalState:
  219. X        XtMapWidget(fileShell);
  220. X        break;
  221. X    case IconicState:
  222. X        XtUnmapWidget(fileShell);
  223. X        break;
  224. X    }
  225. }
  226. X
  227. /*    -    -    -    -    -    -    -    -    */
  228. /* Callbacks from the FileChooser */
  229. X
  230. /*ARGSUSED*/
  231. static void
  232. filePanelOk(fcinfo,filename,client_data)
  233. FileChooserInfo *fcinfo;
  234. char *filename;
  235. XXtPointer client_data;        /* shell Widget */
  236. {
  237. X    Widget shell = (Widget)client_data;
  238. X    int status;
  239. X
  240. X    if (fileGoing) {
  241. X    XBell(display,0);
  242. X    return;
  243. X    }
  244. X    fileGoing = True;
  245. X    switch (fileOp) {
  246. X    case FILE_SAVE:
  247. X        status = save(db,filename);
  248. X        break;
  249. X    case FILE_LOAD:
  250. X        status = load(db,filename);
  251. X        break;
  252. X    case FILE_WRITE:
  253. X        status = writeToFile(db,filename,appResources.fileWriteOnePerLine);
  254. X        break;
  255. X    }
  256. X    fileGoing = False;
  257. X    if (status) {
  258. X    XtPopdown(shell);
  259. X    isPoppedUp = False;
  260. X    }
  261. }
  262. X
  263. /*ARGSUSED*/
  264. static void
  265. filePanelCancel(fcinfo,client_data)
  266. FileChooserInfo *fcinfo;
  267. XXtPointer client_data;        /* shell Widget */
  268. {
  269. X    Widget shell = (Widget)client_data;
  270. X
  271. X    if (fileGoing) {
  272. X    XBell(display,0);
  273. X    return;
  274. X    }
  275. X    XtPopdown(shell);
  276. X    isPoppedUp = False;
  277. }
  278. X
  279. /*    -    -    -    -    -    -    -    -    */
  280. /* Used by the menus */
  281. X
  282. void
  283. updateFileWriteMode(flag)
  284. Boolean flag;
  285. {
  286. X    if (flag)
  287. X    setWidgetLabel(filePanelWriteModeLabel,"One entry per line");
  288. X    else
  289. X    setWidgetLabel(filePanelWriteModeLabel,"Pretty-printed");
  290. }
  291. SHAR_EOF
  292. echo 'File xarchie-2.0.6/file-panel.c is complete' &&
  293. chmod 0644 xarchie-2.0.6/file-panel.c ||
  294. echo 'restore of xarchie-2.0.6/file-panel.c failed'
  295. Wc_c="`wc -c < 'xarchie-2.0.6/file-panel.c'`"
  296. test 5892 -eq "$Wc_c" ||
  297.     echo 'xarchie-2.0.6/file-panel.c: original size 5892, current size' "$Wc_c"
  298. rm -f _shar_wnt_.tmp
  299. fi
  300. # ============= xarchie-2.0.6/file-panel.h ==============
  301. if test -f 'xarchie-2.0.6/file-panel.h' -a X"$1" != X"-c"; then
  302.     echo 'x - skipping xarchie-2.0.6/file-panel.h (File already exists)'
  303.     rm -f _shar_wnt_.tmp
  304. else
  305. > _shar_wnt_.tmp
  306. echo 'x - extracting xarchie-2.0.6/file-panel.h (Text)'
  307. sed 's/^X//' << 'SHAR_EOF' > 'xarchie-2.0.6/file-panel.h' &&
  308. /*
  309. X * file-panel.h : Defs for the save-load-write panel
  310. X *
  311. X * George Ferguson, ferguson@cs.rochester.edu, 23 Apr 1993.
  312. X */
  313. X
  314. #ifndef FILE_PANEL_H
  315. #define FILE_PANEL_H
  316. X
  317. #define FILE_SAVE  1
  318. #define FILE_LOAD  2
  319. #define FILE_WRITE 3
  320. X
  321. extern void initFilePanelActions();
  322. extern void updateFileWriteMode();
  323. extern void setFileShellState();
  324. X
  325. #endif
  326. SHAR_EOF
  327. chmod 0644 xarchie-2.0.6/file-panel.h ||
  328. echo 'restore of xarchie-2.0.6/file-panel.h failed'
  329. Wc_c="`wc -c < 'xarchie-2.0.6/file-panel.h'`"
  330. test 343 -eq "$Wc_c" ||
  331.     echo 'xarchie-2.0.6/file-panel.h: original size 343, current size' "$Wc_c"
  332. rm -f _shar_wnt_.tmp
  333. fi
  334. # ============= xarchie-2.0.6/ftp-actions.c ==============
  335. if test -f 'xarchie-2.0.6/ftp-actions.c' -a X"$1" != X"-c"; then
  336.     echo 'x - skipping xarchie-2.0.6/ftp-actions.c (File already exists)'
  337.     rm -f _shar_wnt_.tmp
  338. else
  339. > _shar_wnt_.tmp
  340. echo 'x - extracting xarchie-2.0.6/ftp-actions.c (Text)'
  341. sed 's/^X//' << 'SHAR_EOF' > 'xarchie-2.0.6/ftp-actions.c' &&
  342. /*
  343. X * ftp-actions.c : X/FTP interface routines for xarchie
  344. X *
  345. X * George Ferguson, ferguson@cs.rochester.edu, 23 Apr 1993.
  346. X * 13 May 1993: Check for NULL return from ftpNewContext().
  347. X */
  348. X
  349. #include <stdio.h>
  350. #include <fcntl.h>            /* O_RDONLY, etc. */
  351. #include <X11/Intrinsic.h>
  352. #include <X11/Shell.h>
  353. #include <X11/StringDefs.h>
  354. #include <X11/Xaw/Form.h>
  355. #include <X11/Xaw/Command.h>
  356. #include <X11/Xaw/AsciiText.h>
  357. #include <X11/Xaw/Dialog.h>
  358. #include "config.h"
  359. #ifdef HAVE_SYS_PARAM_H
  360. #include <sys/param.h>
  361. #endif
  362. #include "db.h"
  363. #include "appres.h"
  364. #include "xarchie.h"
  365. #include "selection.h"
  366. #include "browser.h"
  367. #include "ftp.h"
  368. #include "view-file.h"
  369. #include "status.h"
  370. #include "popups.h"
  371. #include "xutil.h"
  372. #include "alert.h"
  373. #include "syserr.h"
  374. #include "debug.h"
  375. X
  376. /*
  377. X * Functions defined here
  378. X */
  379. void initFtpActions();
  380. void ftpGetSelectedItems(),ftpOpenSelectedItems();
  381. void RegisterFtpFd(),UnregisterFtpFd();
  382. int ftpPrompt();
  383. X
  384. static void ftpSelectedItems(),countFileToGet(),countFileToOpen(),addFile();
  385. static void ftpGetFinished(),ftpOpenOneFinished();
  386. static void initFtpTraceWidgets();
  387. static void ftpTraceDoneAction();
  388. static void ftpTraceReset(),ftpTraceFunc();
  389. static void inputCallback();
  390. static void ftpPromptCallback();
  391. X
  392. /*
  393. X * Data defined here
  394. X */
  395. static char **ftpFilenames;
  396. static int numFtpFiles;
  397. static FtpContext *ftpCurrentContext;
  398. X
  399. static Widget ftpTraceShell,ftpTraceText;
  400. static Boolean isPoppedUp;
  401. X
  402. static XtActionsRec actionTable[] = {
  403. X    { "ftp-trace-done",    ftpTraceDoneAction },
  404. };
  405. X
  406. /*    -    -    -    -    -    -    -    -    */
  407. /* Interface functions */
  408. X
  409. void
  410. initFtpActions()
  411. {
  412. X    XtAppAddActions(appContext,actionTable,XtNumber(actionTable));
  413. }
  414. X
  415. void
  416. ftpGetSelectedItems()        /* Called from getAction() */
  417. {
  418. X    ftpSelectedItems(appResources.ftpLocalDir,appResources.ftpType,
  419. X             appResources.ftpPrompt,appResources.ftpStrip,
  420. X             countFileToGet,NULL,ftpGetFinished);
  421. }
  422. X
  423. void
  424. ftpOpenSelectedItems()        /* Called from openBrowser() */
  425. {
  426. X    ftpSelectedItems(tmpDirectory,"ascii",False,True,
  427. X             countFileToOpen,ftpOpenOneFinished,ftpGetFinished);
  428. }
  429. X
  430. void
  431. ftpAbortTransfer()
  432. {
  433. X    DEBUG1("ftpAbortTransfer: ftpCurrentContext=0x%x\n",ftpCurrentContext);
  434. X    ftpAbort(ftpCurrentContext);
  435. X    DEBUG0("ftpAbortTransfer: done\n");
  436. }
  437. X
  438. /*    -    -    -    -    -    -    -    -    */
  439. /*
  440. X * This function starts ftp retrieval of the items selected in the
  441. X * browser into the local directory.
  442. X */
  443. static void
  444. ftpSelectedItems(local_dir,typestr,prompt,strip,
  445. X         countProc,doneOneProc,doneAllProc)
  446. char *local_dir,*typestr;
  447. Boolean prompt,strip;
  448. void (*countProc)();
  449. FtpCallbackProc doneOneProc,doneAllProc;
  450. {
  451. X    char *host,*cwd;
  452. X    int type;
  453. #ifdef DEBUG
  454. X    int i;
  455. #endif
  456. X
  457. X    DEBUG0("ftpSelectedItems: setting files to transfer\n");
  458. X    numFtpFiles = 0;
  459. X    forEachSelectedItem(countProc);
  460. X    if (numFtpFiles == 0) {
  461. X    return;
  462. X    }
  463. X    ftpFilenames = (char **)XtCalloc(numFtpFiles,sizeof(char *));
  464. X    numFtpFiles = 0;
  465. X    forEachSelectedItem(addFile);
  466. #ifdef DEBUG
  467. X    for (i=0; i < numFtpFiles; i++)
  468. X    fprintf(stderr,"ftpSelectedItems: ftpFilenames[%d] = \"%s\"\n",
  469. X        i,ftpFilenames[i]);
  470. #endif
  471. X    /* Is there a host? */
  472. X    if ((host=getWidgetString(hostText)) == NULL || *host == '\0') {
  473. X    alert0("No host specified for transfer!");
  474. X    return;
  475. X    }
  476. X    DEBUG1("ftpSelectedItems: host = \"%s\"\n",host);
  477. X    /* Optional remote directory */
  478. X    cwd = getWidgetString(locationText); /* Can be "" */
  479. X    DEBUG1("ftpSelectedItems: remote dir = \"%s\"\n",cwd);
  480. X    if (cwd && *cwd == '\0')
  481. X    cwd = NULL;
  482. X    /* Convert type to ARPA code */
  483. X    if (typestr == NULL || *typestr == 'a' || *typestr == 'A')
  484. X    type = TYPE_A;
  485. X    else if (*typestr == 'b' || *typestr == 'B')
  486. X    type = TYPE_I;
  487. X    else if (*typestr == 'e' || *typestr == 'E')
  488. X    type = TYPE_E;
  489. X    else
  490. X    type = atoi(typestr);
  491. X    /* Put up the tracing window if needed */
  492. X    if (appResources.ftpTrace) {
  493. X    if (ftpTraceShell == NULL)
  494. X        initFtpTraceWidgets();
  495. X    ftpTraceReset();
  496. X    isPoppedUp = True;
  497. X    XtPopup(ftpTraceShell,XtGrabNone);
  498. X    }
  499. X    /* Get the FTP context */
  500. X    ftpCurrentContext =
  501. X    ftpNewContext(host,"anonymous",appResources.ftpMailAddress,
  502. X              cwd,local_dir,type,strip,(numFtpFiles>1 && prompt),
  503. X              FTP_GET,ftpFilenames,numFtpFiles,
  504. X              (appResources.ftpTrace ? ftpTraceFunc : NULL),
  505. X              doneOneProc,doneAllProc);
  506. X    XtFree((char *)ftpFilenames);
  507. X    /* Hostname lookup might have failed */
  508. X    if (ftpCurrentContext == NULL)
  509. X    return;
  510. X    /* Here we go... */
  511. X    setBrowserState(BROWSER_FTP);
  512. X    ftpStart(ftpCurrentContext);
  513. X    DEBUG0("ftpSelectedItems: done\n");
  514. }
  515. X
  516. /*    -    -    -    -    -    -    -    -    */
  517. /* Functions called by ftpGetSelectedItems */
  518. X
  519. /*ARGSUSED*/
  520. static void
  521. countFileToGet(dbp,list_index)        /* complains about non-files */
  522. DbEntry *dbp;
  523. int list_index;
  524. {
  525. X    if (dbp->type == DB_FILE) {
  526. X    numFtpFiles += 1;
  527. X    } else {
  528. X    alert1("Can't retrieve non-file \"%s\".",dbp->name);
  529. X    }
  530. }
  531. X
  532. /*ARGSUSED*/
  533. static void
  534. countFileToOpen(dbp,list_index)        /* doesn't complain about non-files */
  535. DbEntry *dbp;
  536. int list_index;
  537. {
  538. X    if (dbp->type == DB_FILE) {
  539. X    numFtpFiles += 1;
  540. X    }
  541. }
  542. X
  543. /*ARGSUSED*/
  544. static void
  545. addFile(dbp,list_index)            /* adds filename to array */
  546. DbEntry *dbp;
  547. int list_index;
  548. {
  549. X    if (dbp->type == DB_FILE) {
  550. X    ftpFilenames[numFtpFiles++] = XtNewString(dbp->name);
  551. X    }
  552. }
  553. X
  554. /*    -    -    -    -    -    -    -    -    */
  555. /* FTP callbacks */
  556. X
  557. /*
  558. X * This function is called back when the ftp transfer is complete (for
  559. X * whatever reason).
  560. X */
  561. /*ARGUSED*/
  562. static void
  563. ftpGetFinished(ftpc)
  564. FtpContext *ftpc;
  565. {
  566. X    DEBUG1("ftpGetFinished(0x%x)...\n",ftpc);
  567. X    setBrowserState(BROWSER_READY);
  568. X    ftpFreeContext(ftpc);
  569. X    status0("Ready");
  570. X    DEBUG0("ftpGetFinished: done\n");
  571. }
  572. X
  573. /*
  574. X * This function is called back when a single file has been successfully
  575. X * retrieved for Open.
  576. X */
  577. /*ARGSUSED*/
  578. static void
  579. ftpOpenOneFinished(ftpc)
  580. FtpContext *ftpc;
  581. {
  582. X    char filename[MAXPATHLEN];
  583. X
  584. X    DEBUG1("ftpOpenOneFinished(0x%x)...\n",ftpc);
  585. X    if (ftpc->local_dir && *(ftpc->local_dir))
  586. X    sprintf(filename,"%s/%s",ftpc->local_dir,ftpc->files[ftpc->this_file]);
  587. X    else
  588. X    strcpy(filename,ftpc->files[ftpc->this_file]);
  589. X    viewFile(filename);
  590. X    DEBUG0("ftpOpenOneFinished: done\n");
  591. }
  592. X
  593. /*    -    -    -    -    -    -    -    -    */
  594. /* Routines for tracing the ftp connection in a window */
  595. X
  596. static void
  597. initFtpTraceWidgets()
  598. {
  599. X    Widget form;
  600. X
  601. X    ftpTraceShell = XtCreatePopupShell("ftpTraceShell",
  602. X                       topLevelShellWidgetClass,
  603. X                       toplevel,NULL,0);
  604. X    form = XtCreateManagedWidget("ftpTraceForm",formWidgetClass,
  605. X                 ftpTraceShell,NULL,0);
  606. X    (void)XtCreateManagedWidget("ftpTraceDismissButton",commandWidgetClass,
  607. X                form,NULL,0);
  608. X    ftpTraceText = XtCreateManagedWidget("ftpTraceText",asciiTextWidgetClass,
  609. X                     form,NULL,0);
  610. X    XtRealizeWidget(ftpTraceShell);
  611. X    (void)XSetWMProtocols(XtDisplay(ftpTraceShell),XtWindow(ftpTraceShell),
  612. X              &WM_DELETE_WINDOW,1);
  613. }
  614. X
  615. void
  616. setFtpTraceShellState(state)
  617. int state;
  618. {
  619. X    if (!isPoppedUp)
  620. X    return;
  621. X    switch (state) {
  622. X    case NormalState:
  623. X        XtMapWidget(ftpTraceShell);
  624. X        break;
  625. X    case IconicState:
  626. X        XtUnmapWidget(ftpTraceShell);
  627. X        break;
  628. X    }
  629. }
  630. X
  631. /*ARGSUSED*/
  632. static void
  633. ftpTraceDoneAction(w,event,params,num_params)
  634. Widget w;
  635. XXEvent *event;
  636. String *params;
  637. Cardinal *num_params;
  638. {
  639. X    isPoppedUp = False;
  640. X    XtPopdown(ftpTraceShell);
  641. }
  642. X
  643. static void
  644. ftpTraceReset()
  645. {
  646. X    Arg args[1];
  647. X
  648. X    XtSetArg(args[0],XtNstring,"");
  649. X    XtSetValues(ftpTraceText,args,1);
  650. }
  651. X
  652. /*
  653. X * This function is called back from within the ftp routines to monitor
  654. X * the exchange of messages.
  655. X */
  656. /*ARGSUSED*/
  657. static void
  658. ftpTraceFunc(ftpc,who,text)
  659. FtpContext *ftpc;
  660. int who;        /* 0 => recvd, non-0 => sent */
  661. char *text;        /* text of this message */
  662. {
  663. X    if (who)
  664. X    appendWidgetText(ftpTraceText,"ftp> ");
  665. X    appendWidgetText(ftpTraceText,text);
  666. X    if (*(text+strlen(text)-1) != '\n')
  667. X    appendWidgetText(ftpTraceText,"\n");
  668. }
  669. X
  670. /*    -    -    -    -    -    -    -    -    */
  671. /* File descriptor registration routines: */
  672. X
  673. /*
  674. X * We need as many of these as there are file descriptors. It's
  675. X * easier to guess big than to figure out where such a magic number lives.
  676. X */
  677. #define NUMFDS 64
  678. FtpCallbackProc ftpRegisteredProcs[NUMFDS];
  679. FtpContext *ftpRegisteredContexts[NUMFDS];
  680. XXtInputId ftpRegisteredIds[NUMFDS];
  681. X
  682. /*
  683. X * This function is exported and used by the FTP routines to register
  684. X * a file descriptor for notification. We register it by recording the
  685. X * callback information (proc and ftpc) and telling X to register the
  686. X * fd as an external input source. When X calls back to inputCallback(),
  687. X * we use the stored information to call back to the FTP routine.
  688. X * Got that?
  689. X */
  690. void
  691. RegisterFtpFd(ftpc,fd,flags,proc)
  692. FtpContext *ftpc;
  693. int fd,flags;
  694. FtpCallbackProc proc;
  695. {
  696. X    XtInputMask condition;
  697. X
  698. X    DEBUG3("RegisterFtpFd: ftpc=0x%x, fd=%d, flags=%d\n",ftpc,fd,flags);
  699. X    if (fd < 0 || fd >= NUMFDS) {
  700. X    fprintf(stderr,"YOW! Attempt to register fd %d!\n",fd);
  701. #ifdef DEBUG
  702. X    abort();
  703. #endif
  704. X    return;
  705. X    }
  706. X    switch (flags) {
  707. X      case O_RDONLY:
  708. X    condition = XtInputReadMask;
  709. X    break;
  710. X      case O_WRONLY:
  711. X    condition = XtInputWriteMask;
  712. X    break;
  713. X      case O_RDWR:
  714. X    condition = XtInputReadMask | XtInputWriteMask;
  715. X    break;
  716. X    }
  717. X    ftpRegisteredProcs[fd] = proc;
  718. X    ftpRegisteredContexts[fd] = ftpc;
  719. X    ftpRegisteredIds[fd] =
  720. X    XtAppAddInput(appContext,fd,(XtPointer)condition,inputCallback,NULL);
  721. X    DEBUG1("RegisterFtpFd: done: id=0x%x\n",ftpRegisteredIds[fd]);
  722. }
  723. X
  724. /*
  725. X * Called back when X says source is ready. We call the function registered
  726. X * by the FTP routines, passing the context.
  727. X */
  728. /*ARGSUSED*/
  729. static void
  730. inputCallback(client_data,source,id)
  731. XXtPointer client_data;
  732. int *source;
  733. XXtInputId *id;
  734. {
  735. X    if (ftpRegisteredProcs[*source] != NULL) {
  736. X    (*(ftpRegisteredProcs[*source]))(ftpRegisteredContexts[*source]);
  737. X    } else {
  738. X    fprintf(stderr,"YOW! Callback for fd=%d not registered!\n",*source);
  739. #ifdef DEBUG
  740. X    abort();
  741. #endif
  742. X    }
  743. }
  744. X
  745. /*
  746. X * This function is exported and used by the FTP routines to undo
  747. X * a previous registration.
  748. X */
  749. /*ARGSUSED*/
  750. void
  751. UnregisterFtpFd(ftpc,fd)
  752. FtpContext *ftpc;
  753. int fd;
  754. {
  755. X    DEBUG3("UnregisterFtpFd: ftpc=0x%x, fd=%d, id=0x%x\n",
  756. X       ftpc,fd,ftpRegisteredIds[fd]);
  757. X    if (fd < 0 || fd >= NUMFDS) {
  758. X    fprintf(stderr,"YOW! Attempt to unregister fd %d!\n",fd);
  759. #ifdef DEBUG
  760. X    abort();
  761. #endif
  762. X    return;
  763. X    }
  764. X    if (ftpRegisteredIds[fd] != (XtInputId)NULL)
  765. X    XtRemoveInput(ftpRegisteredIds[fd]);
  766. X    ftpRegisteredIds[fd] = (XtInputId)NULL;
  767. X    ftpRegisteredProcs[fd] = NULL;
  768. X    ftpRegisteredContexts[fd] = NULL;
  769. X    DEBUG0("UnregisterFtpFd: done\n");
  770. }
  771. X
  772. /*    -    -    -    -    -    -    -    -    */
  773. /* Routines for prompting during FTP transfers: */
  774. X
  775. static Widget ftpPromptShell;
  776. static int ftpPromptResult;
  777. X
  778. int
  779. ftpPrompt(ftpc)
  780. FtpContext *ftpc;
  781. {
  782. X    char str[256];
  783. X
  784. X    if (ftpPromptShell == NULL)
  785. X    ftpPromptShell = createPopup("ftpPrompt",4,ftpPromptCallback);
  786. X    sprintf(str,"%s %s?",
  787. X        (ftpc->filecmd==FTP_GET?"GET":"PUT"),ftpc->files[ftpc->this_file]);
  788. X    setPopupLabel(ftpPromptShell,"ftpPrompt",str);
  789. X    popupMainLoop(ftpPromptShell);
  790. X    return(ftpPromptResult);
  791. }
  792. X 
  793. /*ARGSUSED*/
  794. static void
  795. ftpPromptCallback(w,client_data,call_data)
  796. Widget w;
  797. XXtPointer client_data;        /* button number */
  798. XXtPointer call_data;
  799. {
  800. X    switch ((int)client_data) {
  801. X      case 0:            /* Yes */
  802. X    ftpPromptResult = 1;
  803. X    break;
  804. X      case 1:            /* No */
  805. X    ftpPromptResult = 0;
  806. X    break;
  807. X      case 2:            /* All */
  808. X    ftpCurrentContext->prompt = 0;
  809. X    ftpPromptResult = 1;
  810. X    break;
  811. X      case 3:            /* Abort */
  812. X    ftpCurrentContext->this_file = ftpCurrentContext->num_files;
  813. X    ftpPromptResult = 0;
  814. X    break;
  815. X    }
  816. X    popupDone();
  817. }
  818. SHAR_EOF
  819. chmod 0644 xarchie-2.0.6/ftp-actions.c ||
  820. echo 'restore of xarchie-2.0.6/ftp-actions.c failed'
  821. Wc_c="`wc -c < 'xarchie-2.0.6/ftp-actions.c'`"
  822. test 11489 -eq "$Wc_c" ||
  823.     echo 'xarchie-2.0.6/ftp-actions.c: original size 11489, current size' "$Wc_c"
  824. rm -f _shar_wnt_.tmp
  825. fi
  826. # ============= xarchie-2.0.6/ftp-actions.h ==============
  827. if test -f 'xarchie-2.0.6/ftp-actions.h' -a X"$1" != X"-c"; then
  828.     echo 'x - skipping xarchie-2.0.6/ftp-actions.h (File already exists)'
  829.     rm -f _shar_wnt_.tmp
  830. else
  831. > _shar_wnt_.tmp
  832. echo 'x - extracting xarchie-2.0.6/ftp-actions.h (Text)'
  833. sed 's/^X//' << 'SHAR_EOF' > 'xarchie-2.0.6/ftp-actions.h' &&
  834. /*
  835. X * ftp-actions.h : Defs for yet another layer of the ftp routines
  836. X *
  837. X * George Ferguson, ferguson@cs.rochester.edu, 23 Apr 1993.
  838. X */
  839. X
  840. extern void initFtpActions();
  841. extern void ftpGetSelectedItems(),ftpOpenSelectedItems();
  842. extern void setFtpTraceShellState();
  843. SHAR_EOF
  844. chmod 0644 xarchie-2.0.6/ftp-actions.h ||
  845. echo 'restore of xarchie-2.0.6/ftp-actions.h failed'
  846. Wc_c="`wc -c < 'xarchie-2.0.6/ftp-actions.h'`"
  847. test 262 -eq "$Wc_c" ||
  848.     echo 'xarchie-2.0.6/ftp-actions.h: original size 262, current size' "$Wc_c"
  849. rm -f _shar_wnt_.tmp
  850. fi
  851. # ============= xarchie-2.0.6/ftp.c ==============
  852. if test -f 'xarchie-2.0.6/ftp.c' -a X"$1" != X"-c"; then
  853.     echo 'x - skipping xarchie-2.0.6/ftp.c (File already exists)'
  854.     rm -f _shar_wnt_.tmp
  855. else
  856. > _shar_wnt_.tmp
  857. echo 'x - extracting xarchie-2.0.6/ftp.c (Text)'
  858. sed 's/^X//' << 'SHAR_EOF' > 'xarchie-2.0.6/ftp.c' &&
  859. /*
  860. X * ftp.c : This code implements an asynchronous ftp client.
  861. X *
  862. X * George Ferguson, ferguson@cs.rochester.edu, 23 Apr 1993.
  863. X *
  864. X * The client is represented by an instance of the FtpContext structure,
  865. X * which includes the state of the client with respect to a finite-state
  866. X * model of the FTP process. All aspects of the connection are contained
  867. X * in the structure, so a process can have multiple outstanding FTP
  868. X * sessions (subject to filesystem limitations, of course).
  869. X *
  870. X * Refer to RFC959 for details of the state model.
  871. X *
  872. X * Two external functions must be provided:
  873. X *   void RegisterFtpFd( ftpc, fd, flags, func )
  874. X *      Should arrange to call FUNC passing FTPC whenever FD is ready
  875. X *      as indicated by FLAGS (from <fcntl.h>).
  876. X *   void UnregisterFtpFd( ftpc, fd )
  877. X *      Cancels a previous registration of FD for FTPC.
  878. X * Samples of these using select(2) are given below in the STANDALONE
  879. X * section. Xarchie uses the XtAppAddInput() mechanism. The code also
  880. X * uses alert0() and status0() for messages, sysError() for error
  881. X * messages from system calls, and ftpPrompt() if prompting is enabled.
  882. X *
  883. X * To use these routines:
  884. X *   ftpc = ftpNewContext(...);
  885. X *   ftpStart(ftpc);
  886. X * The function you registered as the "done" parameter in ftpNewContext
  887. X * will be called back when the process finishes (for any reason). You
  888. X * should call ftpFreeContext() in this callback (or register it as the
  889. X * callback, or register NULL).
  890. X *
  891. X * This code is decidely *not* a general-purpose FTP library. It is
  892. X * designed to support the batch transfers required by xarchie. I suppose
  893. X * that it could be modified to be more general without too much effort.
  894. X * In particular, many of the routines called by ftpProcessReply could
  895. X * be made into external interface functions. Volunteers?
  896. X *
  897. X * 28 Apr 1993: Status mesage for bytes transferred was backwards.
  898. X *  1 Jun 1993: Fixes for ISC. Are these needed for other SYS5?
  899. X */
  900. #include <stdio.h>
  901. #include <errno.h>
  902. #include "config.h"
  903. #ifdef HAVE_SYS_PARAM_H
  904. #include <sys/param.h>
  905. #endif
  906. #include "ftp.h"    /* includes <sys/types.h> and <netinet/in.h> */
  907. #include "sysdefs.h"    /* char *malloc() */
  908. #include "stringdefs.h" /* char *strcpy(), *index(); */
  909. #include "debug.h"    /* MSG[0-3]() macros */
  910. X
  911. /* These functions have to be provided: */
  912. extern void RegisterFtpFd(/* ftpc, fd, O_RDWR | O_RDONLY, func */);
  913. extern void UnregisterFtpFd(/* ftpc, fd */);
  914. extern int ftpPrompt(/* ftpc */);
  915. extern void status0(/* str */);
  916. extern void alert0(/* str */);
  917. extern void sysError(/* str */);
  918. X
  919. /*
  920. X * Portable non-blocking I/O macros, I hope.
  921. X *   hp300 : From Andy.Linton@comp.vuw.ac.nz
  922. X *   sgi   : From amoss@cs.huji.ac.il
  923. X */
  924. #if defined(hp300)
  925. X  /* Here's for BSD, maybe, but Sys5 can't tell this from EOF. */
  926. # include <fcntl.h>
  927. # define MAKE_NONBLOCKING(fd) fcntl(fd,F_SETFL,O_NDELAY)
  928. # define ITWOULDBLOCK EWOULDBLOCK
  929. #else
  930. #if defined(sgi)
  931. # include <fcntl.h>
  932. # define MAKE_NONBLOCKING(fd) fcntl(fd,F_SETFL,O_NONBLOCK)
  933. # define ITWOULDBLOCK EWOULDBLOCK
  934. #else
  935. X  /* This is POSIX, the default, which uses EAGAIN. */
  936. # include <fcntl.h>
  937. # define MAKE_NONBLOCKING(fd) fcntl(fd,F_SETFL,O_NONBLOCK)
  938. # define ITWOULDBLOCK EAGAIN
  939. #endif
  940. #endif
  941. /*
  942. X * Networking includes from Brendan Kehoe (dirsend.c)
  943. X */
  944. #include <netdb.h>
  945. #include <sys/socket.h>
  946. #ifndef hpux
  947. # include <arpa/inet.h>
  948. #endif
  949. /* Interactive UNIX keeps some of the socket definitions in funny places.  */
  950. #ifdef ISC
  951. # include <net/errno.h>        /* I wonder about this... */
  952. #endif /* ISC */
  953. X
  954. #ifndef IPPORT_FTP
  955. #define IPPORT_FTP 21        /* From <netinet/in.h> */
  956. #endif
  957. X
  958. #define NewString(S)        strcpy(malloc(strlen(S)+1),S)
  959. #define ftpfilecmdstr(X)    ((X)==FTP_GET ? "GET" : "PUT")
  960. X
  961. /*
  962. X * Functions defined here:
  963. X */
  964. FtpContext *ftpNewContext();
  965. void ftpStart(),ftpAbort();
  966. void ftpFreeContext();
  967. X
  968. /* Initialization */
  969. static int ftpGetHostAndPort();
  970. /* Connection establishment */
  971. static void ftpConnectCallback();
  972. static int ftpGetSocket(),ftpConnect();
  973. /* Reading server replies */
  974. static void ftpInitReply(),ftpReplyCallback();
  975. /* Main FTP client state-machine */
  976. static void ftpProcessReply();
  977. static void ftpAlert(),ftpHandleErrorThenQuit(),ftpDone();
  978. static void ftpSendType(),ftpSendNextCwd();
  979. static int ftpSendPort();
  980. static void ftpSendGetPut();
  981. static int ftpAcceptDataConn(),ftpSetupLocalData();
  982. /* Data connection processing */
  983. static void ftpDataCallback();
  984. static void ftpReadData(),ftpWriteData(),ftpCleanupDataConn();
  985. /* Sending commands to the server */
  986. static void ftpStartSendingCmd(),ftpWriteCallback();
  987. static void ftpSendCmd(),ftpSendAbort();
  988. #ifdef DEBUG
  989. char *ftpstatestr();
  990. #endif
  991. X
  992. /*    -    -    -    -    -    -    -    -    */
  993. /* Exported functions: */
  994. X
  995. /*
  996. X * Returns a pointer to a new FtpContext for which the connection is
  997. X * started. The external function RegisterFtpFd() is used to register
  998. X * the control socket for subsequent processing by ftpProcess().
  999. X */
  1000. FtpContext *
  1001. ftpNewContext(hostname,user,pass,cwd,local_dir,type,stripcr,prompt,
  1002. X          filecmd,files,num_files,trace,done1,done)
  1003. char *hostname,*user,*pass,*cwd,*local_dir;
  1004. int type,stripcr,prompt,filecmd;
  1005. char **files;
  1006. int num_files;
  1007. FtpTraceProc trace;
  1008. FtpCallbackProc done1,done;
  1009. {
  1010. X    FtpContext *ftpc;
  1011. X    int i;
  1012. X
  1013. X    /* Initialize the data structure */
  1014. X    if ((ftpc=(FtpContext *)malloc(sizeof(FtpContext))) == NULL) {
  1015. X    fprintf(stderr,"ftpNewContext: malloc failed\n");
  1016. X    return(NULL);
  1017. X    }
  1018. X    /* User-specified stuff */
  1019. X    ftpc->hostname = NewString(hostname);
  1020. X    ftpc->user = NewString(user);
  1021. X    ftpc->pass = NewString(pass);
  1022. X    ftpc->cwd = NewString(cwd);
  1023. X    ftpc->wd = ftpc->cwd;
  1024. X    ftpc->local_dir = NewString(local_dir);
  1025. X    ftpc->type = type;
  1026. X    ftpc->stripcr = stripcr;
  1027. X    ftpc->prompt = prompt;
  1028. X    ftpc->filecmd = filecmd;
  1029. X    ftpc->num_files = num_files;
  1030. X    ftpc->files = (char **)calloc(num_files,sizeof(char *));
  1031. X    for (i=0; i < num_files; i++)
  1032. X    ftpc->files[i] = NewString(files[i]);
  1033. X    ftpc->this_file = -1;    /* preincrement later */
  1034. X    ftpc->this_size = 0;
  1035. X    ftpc->trace = trace;
  1036. X    ftpc->done1 = done1;
  1037. X    ftpc->done = done;
  1038. X    /* Default stuff */
  1039. X    ftpc->reply[0] = '\0';
  1040. X    ftpc->stripcr = 1;
  1041. X    /* Undefined stuff */
  1042. X    ftpc->ctrl = ftpc->data = ftpc->port = ftpc->local_fd = -1;
  1043. X    ftpc->state = ftpc->iostate = ftpc->reply_state = ftpc->saved_state = 0;
  1044. X    ftpc->retcode = ftpc->tmpcode = 0;
  1045. X    ftpc->cmd = NULL;
  1046. X    /* Go start the connection */
  1047. X    if (ftpGetHostAndPort(ftpc) < 0) {
  1048. X    ftpFreeContext(ftpc);
  1049. X    return(NULL);
  1050. X    }
  1051. X    ftpc->state = 0;
  1052. X    return(ftpc);
  1053. }
  1054. X
  1055. void
  1056. ftpFreeContext(ftpc)
  1057. FtpContext *ftpc;
  1058. {
  1059. X    int i;
  1060. X
  1061. X    DEBUG1("ftpFreeContext: ftpc=0x%x\n",ftpc);
  1062. X    if (ftpc->ctrl != -1) {
  1063. X    UnregisterFtpFd(ftpc,ftpc->ctrl);
  1064. X    DEBUG1("ftpFreeContext: closing ctrl %d\n",ftpc->ctrl);
  1065. X    close(ftpc->ctrl);
  1066. X    }
  1067. X    if (ftpc->data != -1) {
  1068. X    UnregisterFtpFd(ftpc,ftpc->data);
  1069. X    DEBUG1("ftpFreeContext: closing data %d\n",ftpc->data);
  1070. X    close(ftpc->data);
  1071. X    }
  1072. X    if (ftpc->port != -1) {
  1073. X    DEBUG1("ftpFreeContext: closing port %d\n",ftpc->port);
  1074. X    close(ftpc->port);
  1075. X    }
  1076. X    if (ftpc->local_fd != -1) {
  1077. X    DEBUG1("ftpFreeContext: closing local_fd %d\n",ftpc->local_fd);
  1078. X    close(ftpc->local_fd);
  1079. X    }
  1080. X    if (ftpc->hostname)
  1081. X    free(ftpc->hostname);
  1082. X    if (ftpc->user)
  1083. X    free(ftpc->user);
  1084. X    if (ftpc->pass)
  1085. X    free(ftpc->pass);
  1086. X    if (ftpc->cwd)
  1087. X    free(ftpc->cwd);
  1088. X    if (ftpc->local_dir)
  1089. X    free(ftpc->local_dir);
  1090. X    if (ftpc->files) {
  1091. X    for (i=0; i < ftpc->num_files; i++)
  1092. X        if (ftpc->files[i]) free(ftpc->files[i]);
  1093. X    free((char *)(ftpc->files));
  1094. X    }
  1095. X    if (ftpc->h_addr_list)
  1096. X    free((char *)(ftpc->h_addr_list));
  1097. X    DEBUG0("ftpFreeContext: done\n");
  1098. }
  1099. X
  1100. void
  1101. ftpStart(ftpc)
  1102. FtpContext *ftpc;
  1103. {
  1104. X    DEBUG1("ftpStart: ftpc=0x%x\n",ftpc);
  1105. X    ftpc->state = FTPS_OPEN;
  1106. X    ftpConnectCallback(ftpc);        /* get things started */
  1107. X    DEBUG0("ftpStart: done\n");
  1108. }
  1109. X
  1110. void
  1111. ftpAbort(ftpc)
  1112. FtpContext *ftpc;
  1113. {
  1114. X    DEBUG1("ftpAbort: ftpc=0x%x\n",ftpc);
  1115. X    /*
  1116. X     * If we're aborting before any files transferred or after an
  1117. X     * abort or quit, just close down the whole connection.
  1118. X     */
  1119. X    if (ftpc->state < FTPS_READY || ftpc->state > FTPS_EOF) {
  1120. X    ftpDone(ftpc);
  1121. X    return;
  1122. X    }
  1123. X    /*
  1124. X     * Close the dataconn so we don't get swamped in select() while
  1125. X     * waiting for the response to the abort on the ctrlconn.
  1126. X     */
  1127. X    if (ftpc->data != -1) {
  1128. X    UnregisterFtpFd(ftpc,ftpc->data);
  1129. X    }
  1130. X    /* Then send the abort sequence */
  1131. X    ftpSendAbort(ftpc);
  1132. X    DEBUG0("ftpAbort: done\n");
  1133. }
  1134. X
  1135. /*    -    -    -    -    -    -    -    -    */
  1136. /* Initialization: */
  1137. /*
  1138. X * This function is called from ftpNewContext() to initialize the host
  1139. X * address information in the FTPC.
  1140. X */
  1141. static int
  1142. ftpGetHostAndPort(ftpc)
  1143. FtpContext *ftpc;
  1144. {
  1145. X    struct servent *serv;
  1146. X    struct hostent *host;
  1147. X    unsigned long hostaddr;
  1148. X    char msg[256];
  1149. X    int i;
  1150. X
  1151. X    DEBUG2("ftpGetHostAndPort: ftpc=0x%x: \"%s\"\n",ftpc,ftpc->hostname);
  1152. X    /*
  1153. X     * Get ftp port
  1154. X     */
  1155. X    DEBUG0("ftpGetHostAndPort: getting ftp service port\n");
  1156. X    serv = getservbyname("ftp","tcp");
  1157. X    /* UCX needs 0 or -1 */
  1158. X    if (serv == (struct servent *)0 || serv == (struct servent *)-1) {
  1159. X    alert0("Can't find service 'ftp/tcp' in list of services -- using default port");
  1160. X    ftpc->servport = htons((unsigned short)IPPORT_FTP);
  1161. X    } else {
  1162. X    ftpc->servport = (unsigned short)serv->s_port;
  1163. X    }
  1164. X    DEBUG1("ftpGetHostAndPort: ftp service port is %d\n",ftpc->servport);
  1165. X    /*
  1166. X     * Get host address
  1167. X     */
  1168. X    sprintf(msg,"Getting address for host \"%.200s\"",ftpc->hostname);
  1169. X    status0(msg);
  1170. X    if ((host=gethostbyname(ftpc->hostname)) == NULL) {
  1171. X    DEBUG0("ftpGetHostAndPort: gethostbyname failed, trying inet_addr()\n");
  1172. X    /*
  1173. X     * If gethostbyname fails, then maybe we've been given an IP
  1174. X     * address directly. Let's see.
  1175. X     */
  1176. X    hostaddr = inet_addr(ftpc->hostname);
  1177. X    if (hostaddr == (unsigned long)-1) {
  1178. X        /*
  1179. X         * Nope - complete failure.
  1180. X         */
  1181. X        sprintf(msg,"Can't find address of host \"%.200s\"",
  1182. X            ftpc->hostname);
  1183. X        alert0(msg);
  1184. X        return(-1);
  1185. X    } else {
  1186. X        /*
  1187. X         * inet_addr succeeded, so we make a dummy array of hostaddrs.
  1188. X         */
  1189. X        ftpc->h_addr_list = (char **)calloc(2,sizeof(char *));
  1190. X        bcopy((char *)&hostaddr,ftpc->h_addr_list[0],sizeof(char *));
  1191. X        hostaddr = (unsigned long)0;
  1192. X        bcopy((char *)&hostaddr,ftpc->h_addr_list[1],sizeof(char *));
  1193. X        ftpc->this_addr = ftpc->h_addr_list-1; /* preincrement later */
  1194. X        DEBUG1("ftpGetHostAndPort: inet_addr returned %s\n",
  1195. X           inet_ntoa(*(struct in_addr*)(ftpc->h_addr_list[0])));
  1196. X        return(0);
  1197. X    }
  1198. X    } else {
  1199. X    /*
  1200. X     * If gethostbyname succeeeds, it fills in a list of addresses.
  1201. X     * We'll copy them into the ftpc.
  1202. X     */
  1203. X    for (i=0; host->h_addr_list[i]; i++)
  1204. X        /*EMPTY*/;
  1205. X    DEBUG1("ftpGetHostAndPort: gethostbynname returned %d addr(s)\n",i);
  1206. X    ftpc->h_addr_list = (char **)calloc(i+1,sizeof(char *));
  1207. X    for (i=0; host->h_addr_list[i]; i++) {
  1208. X        bcopy(host->h_addr_list[i],
  1209. X          (char *)(ftpc->h_addr_list+i),sizeof(char *));
  1210. X        DEBUG2("ftpGetHostAndPort: h_addr_list[%d] = %s\n",i,
  1211. X           inet_ntoa(*(struct in_addr*)(ftpc->h_addr_list+i)));
  1212. X    }
  1213. X    bzero((char *)(ftpc->h_addr_list+i),sizeof(char *));
  1214. X    ftpc->this_addr = ftpc->h_addr_list-1;    /* preincrement later */
  1215. X    return(0);
  1216. X    }
  1217. }
  1218. X
  1219. /*    -    -    -    -    -    -    -    -    */
  1220. /* Connection establishment: */
  1221. /*
  1222. X * This function goes through the list of addresses trying to connect to
  1223. X * the server. It is initially called from ftpNewContext(), and subsequently
  1224. X * whenever the ctrl socket it ready for writing (indicating connect()
  1225. X * completed, possibly with an error).
  1226. X */
  1227. static void
  1228. ftpConnectCallback(ftpc)
  1229. FtpContext *ftpc;
  1230. {
  1231. X    int retcode;
  1232. X    char msg[256];
  1233. X
  1234. X    DEBUG2("ftpConnectCallback: ftpc=0x%x, state=%s\n",
  1235. X       ftpc,ftpstatestr(ftpc->state));
  1236. X  redo:
  1237. X    switch (ftpc->state) {
  1238. X      case FTPS_OPEN:
  1239. X    ftpc->this_addr += 1;            /* preincrement */
  1240. X    DEBUG1("ftpConnectCallback: OPEN: %s\n",
  1241. X           inet_ntoa(*(struct in_addr*)(ftpc->this_addr)));
  1242. X    if (*(ftpc->this_addr)) {        /* Not at last host */
  1243. X        if (ftpGetSocket(ftpc) < 0) {
  1244. X        ftpDone(ftpc);
  1245. X        } else {
  1246. X        /* Arrange to get called back if connect() would block */
  1247. X        RegisterFtpFd(ftpc,ftpc->ctrl,O_RDWR,ftpConnectCallback);
  1248. X        ftpc->state = FTPS_CONNECT;
  1249. X        goto redo;
  1250. X        }
  1251. X    } else {                /* All hosts failed */
  1252. X        sprintf(msg,"Couldn't connect to host \"%s\"",ftpc->hostname);
  1253. X        alert0(msg);
  1254. X        ftpDone(ftpc);
  1255. X    }
  1256. X    break;
  1257. X      case FTPS_CONNECT:
  1258. X    /* We previously registered either above or below */
  1259. X    UnregisterFtpFd(ftpc,ftpc->ctrl);
  1260. X    retcode = ftpConnect(ftpc);
  1261. X    if (retcode < 0) {
  1262. X        DEBUG1("ftpConnectCallback: ftpConnect failed, closing ctrl %d\n",
  1263. X           ftpc->ctrl);
  1264. X        close(ftpc->ctrl);
  1265. X        ftpc->ctrl = -1;
  1266. X        ftpc->state = FTPS_OPEN;        /* try next one */
  1267. X        goto redo;
  1268. X    } else if (retcode == 0) {
  1269. X        DEBUG0("ftpConnectCallback: ftpConnect would block\n");
  1270. X        /* Arrange to get called back when connect() won't block */
  1271. X        RegisterFtpFd(ftpc,ftpc->ctrl,O_RDWR,ftpConnectCallback);
  1272. X        ftpc->state = FTPS_CONNECT;        /* try again when ready */
  1273. X    } else {
  1274. X        DEBUG0("ftpConnectCallback: ftpConnect ok\n");
  1275. X        ftpInitReply(ftpc);            /* ok... */
  1276. X        ftpc->state = FTPS_CONNECTED;    /* move on */
  1277. X    }
  1278. X    break;
  1279. X      default:
  1280. X    fprintf(stderr,"ftpConnectCallback: unknown state %d\n",ftpc->state);
  1281. X    abort();
  1282. X    }
  1283. X    DEBUG0("ftpConnectCallback: done\n");
  1284. }
  1285. X        
  1286. /*    -    -    -    -    -    -    -    -    */
  1287. /* Functions called by ftpConnectCallback(): */
  1288. /*
  1289. X * This function opens a new socket for the ctrl connection, and sets
  1290. X * it up for non-blocking IO. Everything is setup for later connect().
  1291. X */
  1292. static int
  1293. ftpGetSocket(ftpc)
  1294. FtpContext *ftpc;
  1295. {
  1296. X    DEBUG1("ftpGetSocket: addr=%s\n",
  1297. X       inet_ntoa(*(struct in_addr*)(ftpc->this_addr)));
  1298. X    /* Get a socket */
  1299. X    if ((ftpc->ctrl=socket(AF_INET,SOCK_STREAM,0)) < 0) {
  1300. X    sysError("socket(ftpGetSocket)");
  1301. X    return(-1);
  1302. X    }
  1303. X    DEBUG1("ftpGetSocket: socket() returned %d\n",ftpc->ctrl);
  1304. X    /*
  1305. X     * According to jbh@moses.aii.COM, we can't do this until we connect
  1306. X     * on (at least) ISC variants of SYS5. I have not had problems with
  1307. X     * other SYS5 systems, including HPUX. When ISC is defined, we do it
  1308. X     * in ftpConnect(), although we may then block in connect().
  1309. X     */
  1310. #ifndef ISC
  1311. X    /* Setup socket for async i/o */
  1312. X    MAKE_NONBLOCKING(ftpc->ctrl);
  1313. #endif
  1314. X    /* Set up the address spec. */
  1315. X    bzero((char *)&(ftpc->saddr),sizeof(struct sockaddr_in));
  1316. X    ftpc->saddr.sin_family = AF_INET;
  1317. X    ftpc->saddr.sin_port = ftpc->servport;
  1318. X    ftpc->saddr.sin_addr = *((struct in_addr *)(ftpc->this_addr));
  1319. X    /* Ready to connect() */
  1320. X    DEBUG0("ftpGetSocket: done\n");
  1321. X    return(0);
  1322. }
  1323. X
  1324. /*
  1325. X * Calls connect(). Returns -1 if this host is botched, 0 if connect()
  1326. X * would have blocked, or 1 if we should proceed. 
  1327. X */
  1328. static int
  1329. ftpConnect(ftpc)
  1330. FtpContext *ftpc;
  1331. {
  1332. X    int retcode,addrlen;
  1333. X    char msg[256];
  1334. X
  1335. X    sprintf(msg,"Connecting to %.200s (%s)",
  1336. X        ftpc->hostname,inet_ntoa(*(struct in_addr*)(ftpc->this_addr)));
  1337. X    status0(msg);
  1338. X    DEBUG0("ftpConnect: calling connect()...\n");
  1339. X    retcode = connect(ftpc->ctrl,(struct sockaddr *)&(ftpc->saddr),
  1340. X              sizeof(struct sockaddr_in));
  1341. X    if (retcode < 0 && errno == EINPROGRESS) {
  1342. X    DEBUG0("ftpConnect: connect() EINPROGRESS\n");
  1343. X    return(0);
  1344. X    } else if (retcode < 0 && errno != EISCONN) {
  1345. #ifdef DEBUG
  1346. X    perror("ftpConnect: connect()");
  1347. #endif
  1348. X    return(-1);
  1349. X    }
  1350. #ifdef DEBUG
  1351. X      else if (retcode < 0 && errno == EISCONN)
  1352. X      fprintf(stderr,"ftpConnect: connect() EISCONN\n");
  1353. X      else
  1354. X      fprintf(stderr,"ftpConnect: connect() returned ok\n");
  1355. #endif
  1356. X     /* According to jbh@moses.aii.COM, see comments in ftpGetSocket(). */
  1357. #ifdef ISC
  1358. X    MAKE_NONBLOCKING(ftpc->ctrl); /* Setup socket for async i/o */
  1359. #endif
  1360. X    /* Get name (address) of socket */
  1361. X    addrlen = sizeof(struct sockaddr_in);
  1362. X    retcode =
  1363. X    getsockname(ftpc->ctrl,(struct sockaddr *)&(ftpc->saddr),&addrlen);
  1364. X    if (retcode < 0) {
  1365. X    sysError("getsockname(ftpConnect)");
  1366. X    return(-1);
  1367. X    }
  1368. X    DEBUG1("ftpConnect: getsockname() returned %s\n",
  1369. X       inet_ntoa(ftpc->saddr.sin_addr));
  1370. X    return(1);
  1371. }
  1372. X
  1373. /*    -    -    -    -    -    -    -    -    */
  1374. /* Reading server replies: */
  1375. /*
  1376. X * This function must be called to initialize the reply in the FTPC and
  1377. X * to ensure that the appropriate callback is registered to read it.
  1378. X */
  1379. static void
  1380. ftpInitReply(ftpc)
  1381. FtpContext *ftpc;
  1382. {
  1383. X    DEBUG1("ftpInitReply: ftpc=0x%lx\n",ftpc);
  1384. X    ftpc->retcode = 0;
  1385. X    ftpc->reply_len = 0;
  1386. X    *(ftpc->reply) = '\0';
  1387. X    ftpc->reply_state = FTPS_REPLY_CODE;
  1388. X    /* We're expecting a reply, so register ctrl for reading only */
  1389. X    RegisterFtpFd(ftpc,ftpc->ctrl,O_RDONLY,ftpReplyCallback);
  1390. X    DEBUG0("ftpInitReply: done\n");
  1391. }
  1392. X
  1393. /*
  1394. X * This function is the low-level reply parser. It reads and
  1395. X * parses reply messages from the server, handles TELNET commands,
  1396. X * and translate codes in the reply prefix into integers. It stores the
  1397. X * reply code in ftpc->retcode and puts the text of the reply in ftpc->reply.
  1398. X * It is called whenever the ctrlconn is ready for reading and we are
  1399. X * expecting a reply (ie., after ftpInitReply()). Once the reply is
  1400. X * complete, we call ftpProcessReply().
  1401. X */
  1402. static void
  1403. ftpReplyCallback(ftpc)
  1404. FtpContext *ftpc;
  1405. {
  1406. X    int n;
  1407. X    unsigned char c,cc;
  1408. X
  1409. X    for (;;) {
  1410. /*
  1411. X    DEBUG2("ftpReplyCallback: ftpc=0x%x, reply_state=%s\n",
  1412. X           ftpc,ftpstatestr(ftpc->reply_state));
  1413. */
  1414. X    n = read(ftpc->ctrl,&c,1);        /* Read a byte */
  1415. X    if (n < 0 && errno != ITWOULDBLOCK) {        /* Error */
  1416. X        sysError("read(ftpReplyCallback)");
  1417. X        DEBUG0("ftpReplyCallback: error reading ctrlconn\n");
  1418. X        ftpDone(ftpc);
  1419. X        return;
  1420. X    } else if (n < 0 && errno == ITWOULDBLOCK) {    /* Would block */
  1421. X        /*DEBUG0("ftpReplyCallback: ctrlconn would block\n");*/
  1422. X        return;
  1423. X    } else if (n == 0) {            /* EOF */
  1424. X        *(ftpc->reply+ftpc->reply_len) = '\0';
  1425. X        /* Could check against current retcode, if any... */
  1426. X        if (ftpc->state == FTPS_QUIT)
  1427. X        ftpc->retcode = FTP_SERVICE_CLOSING;
  1428. X        else
  1429. X        ftpc->retcode = FTP_SERVICE_UNAVAILABLE;
  1430. X        DEBUG1("ftpReplyCallback: EOF: retcode = %d\n",ftpc->retcode);
  1431. X        /* Reply is done, go process it */
  1432. X        break;
  1433. X    }
  1434. X    /*
  1435. X     * Otherwise, we got something, process it.
  1436. X     */
  1437. X    if (c == IAC) {            /* Telnet IAC */
  1438. X        ftpc->saved_state = ftpc->reply_state;
  1439. X        ftpc->reply_state = FTPS_REPLY_IAC1;
  1440. X        DEBUG1("ftpReplyCallback: IAC (saved_state=%d)\n",ftpc->saved_state);
  1441. X        continue;
  1442. X    } else if (c == '\r') {        /* Skip <CR>, is this ok? */
  1443. X        continue;
  1444. X    }
  1445. X    /*
  1446. X     * We got something that's not IAC, process it.
  1447. X     */
  1448. X    /*DEBUG2("ftpReplyCallback: `%c' (%d)\n",c,c);*/
  1449. X    switch (ftpc->reply_state) {
  1450. X      case FTPS_REPLY_IAC1:
  1451. X        DEBUG1("ftpReplyCallback: IAC %c",c);
  1452. X        ftpc->reply_state = FTPS_REPLY_IAC2;
  1453. X        break;
  1454. X      case FTPS_REPLY_IAC2:
  1455. X        switch (c) {
  1456. X          case WILL:
  1457. X          case WONT: c = DONT;
  1458. X             break;
  1459. X          case DO:
  1460. X          case DONT: c = WONT;
  1461. X             break;
  1462. X          default:
  1463. X        DEBUG0(" (ignored)\n");
  1464. X        continue;
  1465. X        }
  1466. X        DEBUG1(", reply %c\n",c);
  1467. X        cc = IAC;
  1468. X        write(ftpc->ctrl,&cc,1);
  1469. X        write(ftpc->ctrl,&c,1);
  1470. X        ftpc->reply_state = FTPS_REPLY_IAC3;
  1471. X        break;
  1472. X      case FTPS_REPLY_IAC3:
  1473. X        write(ftpc->ctrl,&c,1);
  1474. X        ftpc->reply_state = ftpc->saved_state;
  1475. X        DEBUG1("ftpReplyCallback: IAC done, restored state = %d\n",
  1476. X           ftpc->reply_state);
  1477. X        break;
  1478. X      case FTPS_REPLY_CODE:
  1479. X        if (c < '0' || c > '9') {
  1480. X        *(ftpc->reply+ftpc->reply_len) = '\0';
  1481. X        DEBUG1("ftpReplyCallback: CODE: retcode = %d\n",ftpc->retcode);
  1482. X        goto done;
  1483. X        }
  1484. X        *(ftpc->reply+ftpc->reply_len++) = c;
  1485. X        ftpc->retcode = ftpc->retcode * 10 + c - '0';
  1486. X        /*DEBUG1("ftpReplyCallback: retcode now %d\n",ftpc->retcode);*/
  1487. X        if (ftpc->retcode >= 100)
  1488. X        ftpc->reply_state = FTPS_REPLY_CONT;
  1489. X        break;
  1490. X      case FTPS_REPLY_CONT:
  1491. X        /* we reach here after we finished reading the code or when we
  1492. X         * struck a line beginning with at least three digits, check if
  1493. X         * this is the last line of the reply
  1494. X         */
  1495. X        *(ftpc->reply+ftpc->reply_len++) = c;
  1496. X        if (c == '-') {
  1497. /*
  1498. X        DEBUG0("ftpReplyCallback: continuation\n");
  1499. */
  1500. X        ftpc->reply_state = FTPS_REPLY_MORE;
  1501. X        } else {
  1502. /*
  1503. X        DEBUG0("ftpReplyCallback: final line\n");
  1504. */
  1505. X        ftpc->reply_state = FTPS_REPLY_LAST;
  1506. X        }
  1507. X        break;
  1508. X      case FTPS_REPLY_LAST:
  1509. X        if (c == '\n') {
  1510. X        *(ftpc->reply+ftpc->reply_len) = '\0';
  1511. /*
  1512. X        DEBUG1("ftpReplyCallback: LAST: retcode = %d\n",ftpc->retcode);
  1513. */
  1514. X        goto done;
  1515. X        } else {
  1516. X        *(ftpc->reply+ftpc->reply_len++) = c;
  1517. /*
  1518. X        DEBUG3("ftpReplyCallback: LAST: %03d: \"%.*s\"\n",
  1519. X             ftpc->reply_len,ftpc->reply_len,ftpc->reply);
  1520. */
  1521. X        }
  1522. X        break;
  1523. X      case FTPS_REPLY_MORE:
  1524. X        *(ftpc->reply+ftpc->reply_len++) = c;
  1525. /*
  1526. X        DEBUG3("ftpReplyCallback: MORE: %03d: \"%.*s\"\n",
  1527. X           ftpc->reply_len,ftpc->reply_len,ftpc->reply);
  1528. */
  1529. X        if (c == '\n') {
  1530. X        ftpc->tmpcode = 0;
  1531. X        ftpc->reply_state = FTPS_REPLY_CHCK;
  1532. X        }
  1533. X        break;
  1534. X      case FTPS_REPLY_CHCK:
  1535. X        if (c < '0' || c > '9') {
  1536. X        *(ftpc->reply+ftpc->reply_len++) = c;
  1537. /*
  1538. X        DEBUG3("ftpReplyCallback: CHCK: %03d: \"%.*s\"\n",
  1539. X               ftpc->reply_len,ftpc->reply_len,ftpc->reply);
  1540. */
  1541. X        ftpc->reply_state = FTPS_REPLY_MORE;
  1542. X        } else {
  1543. X        ftpc->tmpcode = ftpc->tmpcode * 10 + c - '0';
  1544. X        if (ftpc->tmpcode >= 100) {
  1545. X            if (ftpc->tmpcode != ftpc->retcode)
  1546. X            ftpc->reply_state = FTPS_REPLY_MORE;
  1547. X            else
  1548. X            ftpc->reply_state = FTPS_REPLY_CONT;
  1549. X        }
  1550. X        }
  1551. X        break;
  1552. X      default:
  1553. X        fprintf(stderr,"ftpReplyCallback: unknown reply_state %d\n",
  1554. X            ftpc->reply_state);
  1555. X        abort();
  1556. X    }
  1557. X    }
  1558. X    /* if we get here, the reply is complete */
  1559. X  done:
  1560. X    UnregisterFtpFd(ftpc,ftpc->ctrl);
  1561. X    if (ftpc->trace) {
  1562. X    (*(ftpc->trace))(ftpc,0,ftpc->reply);
  1563. X    }
  1564. X    ftpProcessReply(ftpc);
  1565. }
  1566. X
  1567. /*    -    -    -    -    -    -    -    -    */
  1568. /*
  1569. X * This function implements the high-level FTP protocol using the state
  1570. X * field of the FTPC. It is called from ftpReplyCallback() once we've read
  1571. X * a reply and need to process it.
  1572. X */
  1573. static void
  1574. ftpProcessReply(ftpc)
  1575. FtpContext *ftpc;
  1576. {
  1577. X    char cmd[256];
  1578. X
  1579. X    DEBUG3("ftpProcessReply: ftpc=0x%x, state=%s, retcode=%d\n",
  1580. X       ftpc,ftpstatestr(ftpc->state),ftpc->retcode);
  1581. X  redo:
  1582. X    switch (ftpc->state) {
  1583. X      case FTPS_CONNECTED:
  1584. X    if (ftpc->retcode == FTP_SERVICE_RDY_TIME) {    /* delay NNN minutes */
  1585. X        DEBUG0("ftpProcessReply: server not ready\n");
  1586. X        ftpAlert(ftpc);
  1587. X    } else if (ftpc->retcode == FTP_SERVICE_RDY_USER) {/* ready for USER */
  1588. X        sprintf(cmd,"USER %s",ftpc->user);
  1589. X        status0(cmd);
  1590. X        ftpc->state = FTPS_USER;
  1591. X        ftpSendCmd(ftpc,cmd);
  1592. X    } else {                /* FTP_SERVICE_UNAVAILABLE */
  1593. X        ftpAlert(ftpc);
  1594. X        ftpDone(ftpc);
  1595. X    }
  1596. X    break;
  1597. X      case FTPS_USER:
  1598. X    if (ftpc->retcode == FTP_LOGIN_OK) {    /* USER ok, no PASS needed */
  1599. X        ftpc->retcode = FTP_FILE_ACTION_OK;
  1600. X        ftpc->state = FTPS_CWD;
  1601. X        goto redo;
  1602. X    } else if (ftpc->retcode == FTP_LOGIN_NEED_PASSWD) {    /* USER ok   */
  1603. X        sprintf(cmd,"PASS %s",ftpc->pass);            /* need PASS */
  1604. X        status0(cmd);
  1605. X        ftpc->state = FTPS_PASS;
  1606. X        ftpSendCmd(ftpc,cmd);
  1607. X    } else {                /* ACCT needed or error */
  1608. X        ftpHandleErrorThenQuit(ftpc);
  1609. X    }
  1610. X    break;
  1611. X      case FTPS_PASS:
  1612. X    if (ftpc->retcode == FTP_LOGIN_OK) {    /* PASS ok, ready to go */
  1613. X        ftpc->retcode = FTP_FILE_ACTION_OK;
  1614. X        ftpc->state = FTPS_CWD;
  1615. X        goto redo;
  1616. X    } else {                /* ACCT needed or error */
  1617. X        ftpHandleErrorThenQuit(ftpc);
  1618. X    }
  1619. X    break;
  1620. X      case FTPS_CWD:
  1621. X    /* can come here direct from USER or PASS also... */
  1622. X    if (ftpc->retcode == FTP_FILE_ACTION_OK) {    /* last CWD ok */
  1623. X        if (ftpc->wd == NULL || *(ftpc->wd) == '\0') { /* CWD done */
  1624. X        ftpc->state = FTPS_TYPE;
  1625. X        ftpSendType(ftpc);
  1626. X        } else {                /* send next part of CWD */
  1627. X        ftpc->state = FTPS_CWD;
  1628. X        ftpSendNextCwd(ftpc);
  1629. X        }
  1630. X    } else {                /* last CWD failed */
  1631. X        ftpHandleErrorThenQuit(ftpc);
  1632. X    }
  1633. X    break;
  1634. X      case FTPS_TYPE:
  1635. X    if (ftpc->retcode == FTP_COMMAND_OK) {    /* TYPE ok */
  1636. X        ftpc->retcode = FTP_FILE_ACTION_OK;
  1637. X        ftpc->state = FTPS_READY;
  1638. X        goto redo;
  1639. X    } else {                /* TYPE failed */
  1640. X        ftpHandleErrorThenQuit(ftpc);
  1641. X    }
  1642. X    break;
  1643. X      case FTPS_READY:
  1644. X    /* can get here from TYPE or EOF */
  1645. X    ftpc->this_file += 1;
  1646. X    if (ftpc->this_file < ftpc->num_files) {  /* files left to transfer */
  1647. X        sprintf(cmd,"File %s?",ftpc->files[ftpc->this_file]);
  1648. X        status0(cmd);
  1649. X        if (ftpc->prompt && !ftpPrompt(ftpc)) {
  1650. X        goto redo;
  1651. X        }
  1652. X        if (ftpSendPort(ftpc) == 0) {    /*   PORT ok locally */
  1653. X        ftpc->state = FTPS_PORT;
  1654. X        } else {                /*   PORT failed locally */
  1655. X        ftpc->state = FTPS_QUIT;    /*     bag the whole thing */
  1656. X        ftpSendCmd(ftpc,"QUIT");
  1657. X        }
  1658. X    } else {                /* no files left to transfer */
  1659. X        DEBUG0("ftpProcessReply: no more files\n");
  1660. X        ftpc->state = FTPS_QUIT;
  1661. X        ftpSendCmd(ftpc,"QUIT");
  1662. X    }
  1663. X    break;
  1664. X      case FTPS_PORT:
  1665. X    if (ftpc->retcode == FTP_COMMAND_OK) {    /* PORT command ok */
  1666. X        ftpc->state = FTPS_GETPUT;
  1667. X        ftpSendGetPut(ftpc);
  1668. X    } else {                /* PORT failed */
  1669. X        if (ftpc->port >= 0) {
  1670. X        DEBUG1("ftpProcessReply: closing port %d\n",ftpc->port);
  1671. X        close(ftpc->port);
  1672. X        ftpc->port = -1;
  1673. X        }
  1674. X        ftpHandleErrorThenQuit(ftpc);
  1675. X    }
  1676. X    break;
  1677. X      case FTPS_GETPUT:
  1678. X    if (FTP_REPLY_PRELIM(ftpc->retcode)) { /* dataconn ready */
  1679. X        status0(ftpc->reply+4);
  1680. X        if (sscanf(ftpc->reply,"%*[^(](%d bytes)",&(ftpc->this_size)) != 1)
  1681. X        ftpc->this_size = 0;
  1682. X        if (ftpAcceptDataConn(ftpc) < 0) {        /*  local failure */
  1683. X        if (ftpc->port != -1) {            /*    give up */
  1684. X            DEBUG1("ftpProcessReply: closing port %d\n",ftpc->port);
  1685. X            close(ftpc->port);
  1686. X            ftpc->port = -1;
  1687. X        }
  1688. X        ftpc->state = FTPS_QUIT;
  1689. X        ftpSendCmd(ftpc,"QUIT");
  1690. X        } else if (ftpSetupLocalData(ftpc) < 0) {    /*  local failure */
  1691. X        UnregisterFtpFd(ftpc,ftpc->data);    /*    don't give up */
  1692. X        if (ftpc->data != -1) {
  1693. X            DEBUG1("ftpProcessReply: closing data %d\n",ftpc->data);
  1694. X            close(ftpc->data);
  1695. X            ftpc->data = -1;
  1696. X        }
  1697. X        ftpc->state = FTPS_READY;        /*    do next file */
  1698. X        goto redo;
  1699. X        } else {                /* all ok locally */
  1700. X        ftpc->state = FTPS_TRANSFER;
  1701. X        }
  1702. X    } else if (ftpc->retcode == FTP_FILE_UNAVAILABLE ||    /* datacon */
  1703. X           ftpc->retcode == FTP_ACTION_NOT_TAKEN) {    /* failed  */
  1704. X        if (ftpc->port != -1) {                /*  minor  */
  1705. X        DEBUG1("ftpProcessReply: closing port %d\n",ftpc->port);
  1706. X        close(ftpc->port);                /*  error */
  1707. X        ftpc->port = -1;
  1708. X        }
  1709. X        ftpAlert(ftpc);                /* error msg */
  1710. X        ftpc->state = FTPS_READY;        /* next file */
  1711. X        goto redo;
  1712. X    } else {
  1713. X        ftpHandleErrorThenQuit(ftpc);    /* real error */
  1714. X    }
  1715. X    break;
  1716. X      case FTPS_TRANSFER:
  1717. X    /* Shouldn't get here since dataconn is separately managed */
  1718. X    DEBUG0("ftpProcessReply: called in state TRANSFER!\n");
  1719. X    break;
  1720. X      case FTPS_EOF:
  1721. X    /* Called when the dataconn is closed, for whatever reason */
  1722. X    if (!FTP_REPLY_OK(ftpc->retcode)) {    /* dataconn closed error */
  1723. X        ftpAlert(ftpc);
  1724. X    }
  1725. X    ftpc->state = FTPS_READY;
  1726. X    goto redo;
  1727. X      case FTPS_QUIT:
  1728. X    if (ftpc->retcode != FTP_SERVICE_CLOSING) {    /* error */
  1729. X        ftpAlert(ftpc);
  1730. X    }
  1731. X    ftpDone(ftpc);                /* close, deallocate */
  1732. X    break;
  1733. X      case FTPS_ABORT:
  1734. X    if (ftpc->retcode == 552) {        /* NIC-style abort */
  1735. X        ftpc->state = FTPS_ABORT;        /* get another reply */
  1736. X    } else {
  1737. X        if (ftpc->retcode != FTP_DATA_CLOSE_ABORT) { /* 426      */
  1738. X        ftpAlert(ftpc);                 /* expected */
  1739. X        }
  1740. X        ftpc->state = FTPS_ABORT2;        /* get real reply */
  1741. X        ftpInitReply(ftpc);
  1742. X    }
  1743. X    break;
  1744. X      case FTPS_ABORT2:
  1745. X    if (!FTP_REPLY_OK(ftpc->retcode)) {    /* abort error */
  1746. X        ftpAlert(ftpc);
  1747. X    }
  1748. X    ftpCleanupDataConn(ftpc);
  1749. X    ftpc->state = FTPS_READY;
  1750. X    goto redo;
  1751. X      default:
  1752. X    fprintf(stderr,"ftpProcessReply: unknown state: %d\n",ftpc->state);
  1753. X    abort();
  1754. X    }
  1755. X    DEBUG0("ftpProcessReply: done\n");
  1756. }
  1757. X
  1758. /*
  1759. X * This function just puts up an FTP error message.
  1760. X */
  1761. static void
  1762. ftpAlert(ftpc)
  1763. FtpContext *ftpc;
  1764. {
  1765. X    char buf[256],*msg;
  1766. X    int len;
  1767. X
  1768. X    msg = ftpc->reply+4;        /* skip code */
  1769. X    len = strlen(msg);
  1770. X    if (len < 230) {
  1771. X    sprintf(buf,"FTP Error %d:\n %s",ftpc->retcode,msg);
  1772. X    } else {
  1773. X    sprintf(buf,"FTP Error %d: ...\n %.230s",ftpc->retcode,msg+len-230);
  1774. X    }
  1775. X    alert0(buf);
  1776. }
  1777. X
  1778. /*
  1779. X * This prints an error message, then sends the QUIT command (or
  1780. X * calls ftpDone() if the server shut down).
  1781. X */
  1782. static void
  1783. ftpHandleErrorThenQuit(ftpc)
  1784. FtpContext *ftpc;
  1785. {
  1786. X    ftpAlert(ftpc);
  1787. X    /* Don't bother with QUIT if remote host closing down */
  1788. X    if (ftpc->retcode == FTP_SERVICE_UNAVAILABLE) {
  1789. X    ftpDone(ftpc);
  1790. X    } else {
  1791. X    status0("Quitting...");
  1792. X    ftpc->state = FTPS_QUIT;
  1793. X    ftpSendCmd(ftpc,"QUIT");
  1794. X    }
  1795. }
  1796. X
  1797. /*
  1798. X * This calls the done function (or ftpFreeContext() if none is defined
  1799. X * for FTPC. All connections should pass through here to be cleaned up
  1800. X * regardless of how they got here.
  1801. X */
  1802. static void
  1803. ftpDone(ftpc)
  1804. FtpContext *ftpc;
  1805. {
  1806. X    DEBUG1("ftpDone: ftpc=0x%x\n",ftpc);
  1807. X    if (ftpc->done != NULL) {
  1808. X    (*(ftpc->done))(ftpc);
  1809. X    } else {
  1810. X    ftpFreeContext(ftpc);
  1811. X    }
  1812. X    DEBUG0("ftpDone: done\n");
  1813. SHAR_EOF
  1814. true || echo 'restore of xarchie-2.0.6/ftp.c failed'
  1815. fi
  1816. echo 'End of xarchie-2.0.6 part 8'
  1817. echo 'File xarchie-2.0.6/ftp.c is continued in part 9'
  1818. echo 9 > _shar_seq_.tmp
  1819. exit 0
  1820.  
  1821. exit 0 # Just in case...
  1822. -- 
  1823.   // chris@IMD.Sterling.COM       | Send comp.sources.x submissions to:
  1824. \X/  Amiga - The only way to fly! |    sources-x@imd.sterling.com
  1825.  "It's intuitively obvious to the |
  1826.   most casual observer..."        | GCS d+/-- p+ c++ l+ m+ s++/+ g+ w+ t+ r+ x+
  1827.