home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1992 #18 / NN_1992_18.iso / spool / comp / sources / x / 455 < prev    next >
Encoding:
Text File  |  1992-08-18  |  50.3 KB  |  2,225 lines
  1. Path: sparky!uunet!sun-barr!ames!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: v18i086: Ftptool 4.3 (XVIEW), Part04/12
  5. Message-ID: <1992Aug18.153610.28729@msi.com>
  6. Date: 18 Aug 92 15:36:10 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: 2211
  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 86
  16. Archive-name: ftptool-4.3/part04
  17.  
  18. #!/bin/sh
  19. # this is part.04 (part 4 of a multipart archive)
  20. # do not concatenate these parts, unpack them in order with /bin/sh
  21. # file lex.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" != 4; 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 lex.c'
  37. else
  38. echo 'x - continuing file lex.c'
  39. sed 's/^X//' << 'SHAR_EOF' >> 'lex.c' &&
  40. struct yysvf yysvec[] = {
  41. 0,    0,    0,
  42. yycrank+-1,    0,        0,    
  43. yycrank+-20,    yysvec+1,    0,    
  44. yycrank+0,    0,        yyvstop+1,
  45. yycrank+3,    0,        yyvstop+3,
  46. yycrank+0,    yysvec+4,    yyvstop+6,
  47. yycrank+4,    0,        yyvstop+8,
  48. yycrank+1,    0,        yyvstop+10,
  49. yycrank+1,    0,        yyvstop+12,
  50. yycrank+1,    0,        yyvstop+14,
  51. yycrank+8,    0,        yyvstop+16,
  52. yycrank+10,    0,        yyvstop+18,
  53. yycrank+1,    0,        yyvstop+20,
  54. yycrank+17,    0,        yyvstop+22,
  55. yycrank+3,    0,        yyvstop+24,
  56. yycrank+10,    0,        yyvstop+26,
  57. yycrank+2,    0,        0,    
  58. yycrank+5,    0,        0,    
  59. yycrank+16,    0,        0,    
  60. yycrank+21,    0,        0,    
  61. yycrank+23,    0,        0,    
  62. yycrank+25,    0,        0,    
  63. yycrank+28,    0,        0,    
  64. yycrank+25,    0,        0,    
  65. yycrank+18,    0,        0,    
  66. yycrank+36,    0,        0,    
  67. yycrank+33,    0,        0,    
  68. yycrank+2,    0,        0,    
  69. yycrank+34,    0,        0,    
  70. yycrank+0,    0,        yyvstop+28,
  71. yycrank+27,    0,        0,    
  72. yycrank+38,    0,        0,    
  73. yycrank+30,    0,        0,    
  74. yycrank+4,    0,        0,    
  75. yycrank+30,    0,        0,    
  76. yycrank+39,    0,        0,    
  77. yycrank+48,    0,        0,    
  78. yycrank+38,    0,        0,    
  79. yycrank+50,    0,        0,    
  80. yycrank+38,    0,        0,    
  81. yycrank+52,    0,        0,    
  82. yycrank+42,    0,        0,    
  83. yycrank+40,    0,        0,    
  84. yycrank+52,    0,        0,    
  85. yycrank+0,    0,        yyvstop+30,
  86. yycrank+47,    0,        0,    
  87. yycrank+43,    0,        0,    
  88. yycrank+0,    0,        yyvstop+32,
  89. yycrank+0,    0,        yyvstop+34,
  90. yycrank+0,    0,        yyvstop+36,
  91. yycrank+0,    0,        yyvstop+38,
  92. yycrank+1,    0,        0,    
  93. yycrank+0,    0,        yyvstop+40,
  94. yycrank+0,    0,        yyvstop+42,
  95. yycrank+0,    0,        yyvstop+44,
  96. yycrank+54,    0,        0,    
  97. yycrank+0,    0,        yyvstop+46,
  98. yycrank+0,    0,        yyvstop+48,
  99. yycrank+40,    0,        0,    
  100. yycrank+0,    0,        yyvstop+50,
  101. 0,    0,    0};
  102. struct yywork *yytop = yycrank+128;
  103. struct yysvf *yybgin = yysvec+1;
  104. char yymatch[] = {
  105. 00  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  106. 01  ,011 ,012 ,01  ,01  ,01  ,01  ,01  ,
  107. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  108. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  109. 011 ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  110. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  111. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  112. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  113. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  114. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  115. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  116. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  117. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  118. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  119. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  120. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  121. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  122. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  123. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  124. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  125. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  126. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  127. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  128. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  129. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  130. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  131. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  132. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  133. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  134. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  135. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  136. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  137. 0};
  138. char yyextra[] = {
  139. 0,0,0,0,0,0,0,0,
  140. 0,0,0,0,0,0,0,0,
  141. 0};
  142. /*    Copyright (c) 1989 AT&T    */
  143. /*      All Rights Reserved      */
  144. X
  145. /*    THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T    */
  146. /*    The copyright notice above does not evidence any       */
  147. /*    actual or intended publication of such source code.    */
  148. X
  149. #ident    "@(#)RELEASE VERSION SC2.0 3/27/92"
  150. X
  151. int yylineno =1;
  152. # define YYU(x) x
  153. # define NLSTATE yyprevious=YYNEWLINE
  154. char yytext[YYLMAX];
  155. struct yysvf *yylstate [YYLMAX], **yylsp, **yyolsp;
  156. char yysbuf[YYLMAX];
  157. char *yysptr = yysbuf;
  158. int *yyfnd;
  159. extern struct yysvf *yyestate;
  160. int yyprevious = YYNEWLINE;
  161. #if defined(__cplusplus) || defined(__STDC__)
  162. int yylook(void)
  163. #else
  164. yylook()
  165. #endif
  166. {
  167. X    register struct yysvf *yystate, **lsp;
  168. X    register struct yywork *yyt;
  169. X    struct yysvf *yyz;
  170. X    int yych, yyfirst;
  171. X    struct yywork *yyr;
  172. # ifdef LEXDEBUG
  173. X    int debug;
  174. # endif
  175. X    char *yylastch;
  176. X    /* start off machines */
  177. # ifdef LEXDEBUG
  178. X    debug = 0;
  179. # endif
  180. X    yyfirst=1;
  181. X    if (!yymorfg)
  182. X        yylastch = yytext;
  183. X    else {
  184. X        yymorfg=0;
  185. X        yylastch = yytext+yyleng;
  186. X        }
  187. X    for(;;){
  188. X        lsp = yylstate;
  189. X        yyestate = yystate = yybgin;
  190. X        if (yyprevious==YYNEWLINE) yystate++;
  191. X        for (;;){
  192. # ifdef LEXDEBUG
  193. X            if(debug)fprintf(yyout,"state %d\n",yystate-yysvec-1);
  194. # endif
  195. X            yyt = yystate->yystoff;
  196. X            if(yyt == yycrank && !yyfirst){  /* may not be any transitions */
  197. X                yyz = yystate->yyother;
  198. X                if(yyz == 0)break;
  199. X                if(yyz->yystoff == yycrank)break;
  200. X                }
  201. X            *yylastch++ = yych = input();
  202. X            if(yylastch > &yytext[YYLMAX]) {
  203. X                fprintf(yyout,"Input string too long, limit %d\n",YYLMAX);
  204. X                exit(1);
  205. X            }
  206. X            yyfirst=0;
  207. X        tryagain:
  208. # ifdef LEXDEBUG
  209. X            if(debug){
  210. X                fprintf(yyout,"char ");
  211. X                allprint(yych);
  212. X                putchar('\n');
  213. X                }
  214. # endif
  215. X            yyr = yyt;
  216. X            if ( (int)yyt > (int)yycrank){
  217. X                yyt = yyr + yych;
  218. X                if (yyt <= yytop && yyt->verify+yysvec == yystate){
  219. X                    if(yyt->advance+yysvec == YYLERR)    /* error transitions */
  220. X                        {unput(*--yylastch);break;}
  221. X                    *lsp++ = yystate = yyt->advance+yysvec;
  222. X                    if(lsp > &yylstate[YYLMAX]) {
  223. X                        fprintf(yyout,"Input string too long, limit %d\n",YYLMAX);
  224. X                        exit(1);
  225. X                    }
  226. X                    goto contin;
  227. X                    }
  228. X                }
  229. # ifdef YYOPTIM
  230. X            else if((int)yyt < (int)yycrank) {        /* r < yycrank */
  231. X                yyt = yyr = yycrank+(yycrank-yyt);
  232. # ifdef LEXDEBUG
  233. X                if(debug)fprintf(yyout,"compressed state\n");
  234. # endif
  235. X                yyt = yyt + yych;
  236. X                if(yyt <= yytop && yyt->verify+yysvec == yystate){
  237. X                    if(yyt->advance+yysvec == YYLERR)    /* error transitions */
  238. X                        {unput(*--yylastch);break;}
  239. X                    *lsp++ = yystate = yyt->advance+yysvec;
  240. X                    if(lsp > &yylstate[YYLMAX]) {
  241. X                        fprintf(yyout,"Input string too long, limit %d\n",YYLMAX);
  242. X                        exit(1);
  243. X                    }
  244. X                    goto contin;
  245. X                    }
  246. X                yyt = yyr + YYU(yymatch[yych]);
  247. # ifdef LEXDEBUG
  248. X                if(debug){
  249. X                    fprintf(yyout,"try fall back character ");
  250. X                    allprint(YYU(yymatch[yych]));
  251. X                    putchar('\n');
  252. X                    }
  253. # endif
  254. X                if(yyt <= yytop && yyt->verify+yysvec == yystate){
  255. X                    if(yyt->advance+yysvec == YYLERR)    /* error transition */
  256. X                        {unput(*--yylastch);break;}
  257. X                    *lsp++ = yystate = yyt->advance+yysvec;
  258. X                    if(lsp > &yylstate[YYLMAX]) {
  259. X                        fprintf(yyout,"Input string too long, limit %d\n",YYLMAX);
  260. X                        exit(1);
  261. X                    }
  262. X                    goto contin;
  263. X                    }
  264. X                }
  265. X            if ((yystate = yystate->yyother) && (yyt= yystate->yystoff) != yycrank){
  266. # ifdef LEXDEBUG
  267. X                if(debug)fprintf(yyout,"fall back to state %d\n",yystate-yysvec-1);
  268. # endif
  269. X                goto tryagain;
  270. X                }
  271. # endif
  272. X            else
  273. X                {unput(*--yylastch);break;}
  274. X        contin:
  275. # ifdef LEXDEBUG
  276. X            if(debug){
  277. X                fprintf(yyout,"state %d char ",yystate-yysvec-1);
  278. X                allprint(yych);
  279. X                putchar('\n');
  280. X                }
  281. # endif
  282. X            ;
  283. X            }
  284. # ifdef LEXDEBUG
  285. X        if(debug){
  286. X            fprintf(yyout,"stopped at %d with ",*(lsp-1)-yysvec-1);
  287. X            allprint(yych);
  288. X            putchar('\n');
  289. X            }
  290. # endif
  291. X        while (lsp-- > yylstate){
  292. X            *yylastch-- = 0;
  293. X            if (*lsp != 0 && (yyfnd= (*lsp)->yystops) && *yyfnd > 0){
  294. X                yyolsp = lsp;
  295. X                if(yyextra[*yyfnd]){        /* must backup */
  296. X                    while(yyback((*lsp)->yystops,-*yyfnd) != 1 && lsp > yylstate){
  297. X                        lsp--;
  298. X                        unput(*yylastch--);
  299. X                        }
  300. X                    }
  301. X                yyprevious = YYU(*yylastch);
  302. X                yylsp = lsp;
  303. X                yyleng = yylastch-yytext+1;
  304. X                yytext[yyleng] = 0;
  305. # ifdef LEXDEBUG
  306. X                if(debug){
  307. X                    fprintf(yyout,"\nmatch ");
  308. X                    sprint(yytext);
  309. X                    fprintf(yyout," action %d\n",*yyfnd);
  310. X                    }
  311. # endif
  312. X                return(*yyfnd++);
  313. X                }
  314. X            unput(*yylastch);
  315. X            }
  316. X        if (yytext[0] == 0  /* && feof(yyin) */)
  317. X            {
  318. X            yysptr=yysbuf;
  319. X            return(0);
  320. X            }
  321. X        yyprevious = yytext[0] = input();
  322. X        if (yyprevious>0)
  323. X            output(yyprevious);
  324. X        yylastch=yytext;
  325. # ifdef LEXDEBUG
  326. X        if(debug)putchar('\n');
  327. # endif
  328. X        }
  329. X    }
  330. #if defined(__cplusplus) || defined(__STDC__)
  331. int yyback(int *p, int m)
  332. #else
  333. yyback(p, m)
  334. X    int *p;
  335. #endif
  336. {
  337. X    if (p==0) return(0);
  338. X    while (*p) {
  339. X        if (*p++ == m)
  340. X            return(1);
  341. X    }
  342. X    return(0);
  343. }
  344. X    /* the following are only used in the lex library */
  345. #if defined(__cplusplus) || defined(__STDC__)
  346. int yyinput(void)
  347. #else
  348. yyinput()
  349. #endif
  350. {
  351. X    return(input());
  352. X    }
  353. #if defined(__cplusplus) || defined(__STDC__)
  354. void yyoutput(int c)
  355. #else
  356. yyoutput(c)
  357. X  int c; 
  358. #endif
  359. {
  360. X    output(c);
  361. X    }
  362. #if defined(__cplusplus) || defined(__STDC__)
  363. void yyunput(int c)
  364. #else
  365. yyunput(c)
  366. X   int c; 
  367. #endif
  368. {
  369. X    unput(c);
  370. X    }
  371. SHAR_EOF
  372. echo 'File lex.c is complete' &&
  373. chmod 0644 lex.c ||
  374. echo 'restore of lex.c failed'
  375. Wc_c="`wc -c < 'lex.c'`"
  376. test 11513 -eq "$Wc_c" ||
  377.     echo 'lex.c: original size 11513, current size' "$Wc_c"
  378. rm -f _shar_wnt_.tmp
  379. fi
  380. # ============= readdir.c ==============
  381. if test -f 'readdir.c' -a X"$1" != X"-c"; then
  382.     echo 'x - skipping readdir.c (File already exists)'
  383.     rm -f _shar_wnt_.tmp
  384. else
  385. > _shar_wnt_.tmp
  386. echo 'x - extracting readdir.c (Text)'
  387. sed 's/^X//' << 'SHAR_EOF' > 'readdir.c' &&
  388. #include "ftptool.h"
  389. X
  390. extern int dirlastmtime;
  391. X
  392. #ifdef USE_PROTOTYPES
  393. struct dirlist *read_local_dir(char *dirname)
  394. #else
  395. struct dirlist *read_local_dir(dirname)
  396. char    *dirname;
  397. #endif
  398. {
  399. X    struct dirlist *head;
  400. X    DIR    *dir;
  401. X    struct dirent *dp;
  402. X    struct passwd *psswd;
  403. X    struct group *grp;
  404. X    struct stat buf;
  405. X    time_t    curtime;
  406. X    time_t    time();
  407. X    char    date[DATELEN];
  408. X    struct tm *tm;
  409. X    char    owner[20];
  410. X    char    group[20];
  411. X    
  412. X
  413. X    head = new_dirlist("", "", "", "", 0, (size_t)0);
  414. X    if (head == NULL) {
  415. X        fprintf(stderr, "Out of memory\n");
  416. X        goto out;
  417. X    }
  418. X
  419. X    if (lstat(dirname, &buf) == -1) {
  420. X        local_footer_message("Could not stat directory %s.", 
  421. X            dirname, (char *)NULL);
  422. X        goto out;
  423. X    }
  424. X
  425. X    dirlastmtime = buf.st_mtime;
  426. X
  427. X    if ((dir = opendir(dirname)) == NULL) {
  428. X        local_footer_message("Could not open directory %s.", 
  429. X            dirname, (char *)NULL);
  430. X        goto out;
  431. X    }
  432. X 
  433. X    curtime = time((time_t *)NULL);
  434. X
  435. X
  436. X    while (dp = readdir(dir)) {
  437. X        if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, ".."))
  438. X            continue;
  439. X        bzero((char *)&buf, sizeof(buf));
  440. X        if (lstat(dp->d_name, &buf) == -1) {
  441. X            buf.st_mode = 0;
  442. X            buf.st_uid = 0;
  443. X            buf.st_gid = 0;
  444. X            buf.st_size = 0;
  445. X            buf.st_mtime = 0;
  446. X        }
  447. X        tm = localtime(&buf.st_mtime);
  448. X        if ((curtime - buf.st_mtime) < (6 * 30 * 24 * 60 * 60))
  449. X            strftime(date, sizeof(date), "%h %e %H:%M", tm);
  450. X        else
  451. X            strftime(date, sizeof(date), "%h %e  %Y", tm);
  452. X
  453. X        /* determine user and group ids */
  454. X        psswd = getpwuid(buf.st_uid);
  455. X        if (psswd == NULL) {
  456. X            sprintf(owner, "%d", buf.st_uid);
  457. X        } else
  458. X            strcpy(owner, psswd->pw_name);
  459. X
  460. X        grp = getgrgid(buf.st_gid);
  461. X        if (grp == NULL) {
  462. X            sprintf(group, "%d", buf.st_gid);
  463. X        } else
  464. X            strcpy(group, grp->gr_name);
  465. X
  466. X        /* if a link, format name to 'name -> link' as ftp would */
  467. X        if (S_ISLNK(buf.st_mode)) {
  468. X            char    *linkvalue;
  469. X            int        nbytes;
  470. X
  471. X            linkvalue = (char *)malloc(MAXPATHLEN + 1);
  472. X            if ((nbytes = readlink(dp->d_name,linkvalue,(int)buf.st_size))== -1)
  473. X                strcpy(linkvalue, "unknown");
  474. X            else
  475. X                linkvalue[nbytes] = '\0';
  476. X            sprintf(scratch, "%s -> %s", dp->d_name, linkvalue);
  477. X            free(linkvalue);
  478. X        } else
  479. X            strcpy(scratch, dp->d_name);
  480. X        if (add_dirname(head, scratch, date, owner, group, buf.st_mode, 
  481. X            (size_t)buf.st_size, local_sort_mode, local_sort_direction) == NULL)
  482. X            goto out;
  483. X    }
  484. X    closedir(dir);
  485. X
  486. out:
  487. X    if (head)
  488. X        return (head);
  489. X    return NULL;
  490. }
  491. X
  492. #ifdef USE_PROTOTYPES
  493. struct dirlist *read_remote_dir(char *dname)
  494. #else
  495. struct dirlist *read_remote_dir(dname)
  496. char    *dname;
  497. #endif
  498. {
  499. X    struct dirlist *head = NULL;
  500. X    int    old_unix, temp_non_unix = 0;
  501. X    FILE    *din = NULL, *open_remote_ls();
  502. X    char    *next_remote_line();
  503. X
  504. restart:
  505. X    old_unix = temp_non_unix;
  506. X    head = new_dirlist("", "", "", "", 0, (size_t)0);
  507. X    if (head == NULL) {
  508. X        fprintf(stderr, "Out of memory\n");
  509. X        goto out;
  510. X    }
  511. X    /* read the remote directory, adding files and directories to a list */
  512. X    /* send dir command */
  513. X    if (non_unix || temp_non_unix) {
  514. X        din = open_remote_ls(1);
  515. X    } else {
  516. X        din = open_remote_ls(0);
  517. X    }
  518. X    if (din == NULL) {
  519. X        /* always have .. */
  520. X        return head;
  521. X    }
  522. X
  523. X    for (;;) {
  524. X        if (next_remote_line(din) == NULL)
  525. X            goto out;
  526. X        if (!strncmp(response_line, "226", 3) || !strncmp(response_line,"250", 3)) {
  527. X            /* done */
  528. X            log_message(response_line);
  529. X            break;
  530. X        }
  531. X        /* ignore blank lines */
  532. X        if (*response_line == '\n' || *response_line == '\0')
  533. X            continue;
  534. X        /* VMS also prints the directory name */
  535. X        if (dname && !strncmp(response_line, dname, strlen(dname))
  536. X            && (response_line[strlen(dname)] == '\n')) {
  537. X            continue;
  538. X        }
  539. X        /* VMS goofy total line before 226 */
  540. X        if (!strncmp(response_line, "Total of", 8))
  541. X            continue;
  542. X        if (parse_line(head, response_line, &temp_non_unix)) {
  543. X            goto out;
  544. X        }
  545. X        if (old_unix != temp_non_unix) {
  546. X            /* start over */
  547. X            free_dirlist(head);
  548. X            head = NULL;
  549. X            while (getc(din) != -1)
  550. X                /* NULL */ ;
  551. X            close_remote_ls(din);
  552. X            din = NULL;
  553. X            goto restart;
  554. X        }
  555. X    }
  556. X 
  557. out:
  558. X    if (din)
  559. X        close_remote_ls(din);
  560. X    if (timedout) {
  561. X        if (head)
  562. X            free_dirlist(head);
  563. X        timeout_disconnect();
  564. X        return NULL;
  565. X    }
  566. X    if (head)
  567. X        return (head);
  568. X    return (NULL);
  569. }
  570. X
  571. X
  572. #define NULLCHECK() if (*curr == '\0') {non_unix = 1; goto restart;}
  573. X
  574. #ifdef USE_PROTOTYPES
  575. int    parse_line(struct dirlist *head, char *line, int *temp_non_unix)
  576. #else
  577. int    parse_line(head, line, temp_non_unix)
  578. struct dirlist *head;
  579. char    *line;
  580. int        *temp_non_unix;
  581. #endif
  582. {
  583. X    /* default mode is a symbolic link. This is so if you don't have */
  584. X    /* UNIX PERMS, it can be either a file or a directory. Maybe.  */
  585. X    mode_t    mode = S_IFLNK;
  586. X    int        intmode;
  587. X    char    *curr;
  588. X    static char    date[20];
  589. X    static char    month[10];
  590. X    static char    day[10];
  591. X    static char    timeyear[10];
  592. X    static char    name[MAXPATHLEN + 1];
  593. X    static char owner[25];
  594. X    static char group[25];
  595. X    size_t    size = (size_t)-1;
  596. X    char    *tmp;
  597. X    char    *dirtmp;
  598. X
  599. X    month[0] = '\0';
  600. X    day[0] = '\0';
  601. X    timeyear[0] = '\0';
  602. X    date[0] = '\0';
  603. X    name[0] = '\0';
  604. X    strcpy(owner, "unknown");
  605. X    strcpy(group, "unknown");
  606. restart: /* really only get here if non-unix machine */
  607. X    /* Or, actually, assume that if the first character is upper case, */
  608. X    /* it is non-unix (since ls never puts upper case as the type */
  609. X    /* And it appears that the filename is all the characters at the */
  610. X    /* start of the line up to but not including white space on VMS and */
  611. X    /* tops20. This would make it functional, partially at least */
  612. X    /* Also, may need to turn on temp_non_unix_mode, so that cd is */
  613. X    /* possible on anything, since we can't tell if they're directories. */
  614. X    /* or not */
  615. X    curr=line;
  616. X
  617. X    if (non_unix || *temp_non_unix) {
  618. X    /*
  619. X        if (curr[1] == ':') {
  620. X            ftperr = ftp_error(' ', "Permission denied");
  621. X            footer_message(ftperr, (char *)NULL);
  622. X            return 0;
  623. X        } else if (!strncmp(curr, ". unreadable", 12)) {
  624. X            footer_message(". unreadable", (char *)NULL);
  625. X            return 0;
  626. X        }
  627. X    */
  628. X        while (*curr && isspace(*curr))
  629. X            curr++;
  630. X        tmp = name;
  631. X        while (*curr && !isspace(*curr)) {
  632. X            *tmp = *curr;
  633. X            tmp++;
  634. X            curr++;
  635. X        }
  636. X        *tmp = '\0';
  637. X        curr++;
  638. X        if (add_dirname(head, name, "unknown", "unknown", "unknown", S_IFLNK, 
  639. X            (size_t)-1, remote_sort_mode, remote_sort_direction) == NULL) {
  640. X            fprintf(stderr, "add_dirname failed!\n");
  641. X            return 1;
  642. X        }
  643. X        return 0;
  644. X    }
  645. X    dirtmp = dir_pattern;
  646. X    while (*dirtmp != '\0') {
  647. X        NULLCHECK();
  648. X        switch(*dirtmp) {
  649. X        case ' ':
  650. X            while (isspace(*curr))
  651. X                curr++;
  652. X            break;
  653. X        case SKIP:
  654. X            while (!isspace(*curr))
  655. X                curr++;
  656. X            break;
  657. X        case PERMS:
  658. X            intmode = perms(curr, temp_non_unix);
  659. X            if (intmode == 0)
  660. X                return 0;
  661. X            else if (intmode == -1)
  662. X                goto restart;
  663. X            mode = (mode_t)intmode;
  664. X            while (!isspace(*curr))
  665. X                curr++;
  666. X            break;
  667. X        case LINKS:
  668. X            /* dump link count */
  669. X            while (isdigit(*curr))
  670. X                curr++;
  671. X            break;
  672. X        case USER:
  673. X            /*
  674. X             * this should be the user name, surrounded by white space
  675. X             */
  676. X            tmp = owner;
  677. X            while (!isspace(*curr)) {
  678. X                *tmp = *curr;
  679. X                tmp++;
  680. X                curr++;
  681. X            }
  682. X            *tmp = '\0';
  683. X            break;
  684. X        case GROUP:
  685. X            /*
  686. X             * this should be the group name, surrounded by white space
  687. X             */
  688. X            tmp = group;
  689. X            while (!isspace(*curr)) {
  690. X                *tmp = *curr;
  691. X                tmp++;
  692. X                curr++;
  693. X            }
  694. X            *tmp = '\0';
  695. X            break;
  696. X        case SIZE:
  697. X            /* first test only true for UNIX case, where we have */
  698. X            /* seen the perms */
  699. X            if (S_ISCHR(mode) || S_ISBLK(mode)) {
  700. X                /* size is actually major, minor */
  701. X                while (isdigit(*curr) || *curr == ',')
  702. X                    curr++;
  703. X                NULLCHECK();
  704. X                while (isspace(*curr))
  705. X                    curr++;
  706. X                NULLCHECK();
  707. X                while (isdigit(*curr))
  708. X                    curr++;
  709. X                size = -1;
  710. X            } else {
  711. X                sscanf(curr, "%d", &size);
  712. X                while (isdigit(*curr))
  713. X                    curr++;
  714. X            }
  715. X            break;
  716. X        case MONTH:
  717. X            tmp = month;
  718. X            while (isalpha(*curr)) {
  719. X                *tmp = *curr;
  720. X                tmp++;
  721. X                curr++;
  722. X            }
  723. X            *tmp = '\0';
  724. X            break;
  725. X        case DAY:
  726. X            tmp = day;
  727. X            while (isdigit(*curr)) {
  728. X                *tmp = *curr;
  729. X                tmp++;
  730. X                curr++;
  731. X            }
  732. X            *tmp = '\0';
  733. X            break;
  734. X        case TIME:
  735. X            tmp = timeyear;
  736. X            while (isdigit(*curr) || (*curr == ':')) {
  737. X                *tmp = *curr;
  738. X                tmp++;
  739. X                curr++;
  740. X            }
  741. X            *tmp = '\0';
  742. X            break;
  743. X        case NAME:
  744. X        case LOWERNAME:
  745. X            tmp = name;
  746. X            /* the following test makes sure we have seen the PERMS field */
  747. X            /* if not, the permissions will still be 0. symlinks normally */
  748. X            /* have 777 for permissions */
  749. X            if (mode != S_IFLNK && S_ISLNK(mode)) {
  750. X                while (*curr && *curr != '\n') {
  751. X                    *tmp = *curr;
  752. X                    tmp++;
  753. X                    curr++;
  754. X                }
  755. X            } else {
  756. X                while (!isspace(*curr) && *curr != ';') {
  757. X                    *tmp = *curr;
  758. X                    tmp++;
  759. X                    curr++;
  760. X                }
  761. X                /* VMS */
  762. X                if (*curr == ';') {
  763. X                    while (!isspace(*curr))
  764. X                        curr++;
  765. X                }
  766. X            }
  767. X            *tmp = '\0';
  768. X            if (*dirtmp == LOWERNAME) {
  769. X                for (tmp = name; *tmp != '\0'; tmp++)
  770. X                    if (isupper(*tmp))
  771. X                        *tmp = tolower(*tmp);
  772. X            }
  773. X            break;
  774. X        default:
  775. X            if (*dirtmp == *curr) {
  776. X                curr++;
  777. X            } else {
  778. X                *temp_non_unix=1;
  779. X                goto restart;
  780. X            }
  781. X        }
  782. X        dirtmp++;
  783. X    }
  784. X    sprintf(date, "%s %2s %5s", month, day, timeyear);
  785. X
  786. X    if (add_dirname(head, name, date, owner, group, mode, size, 
  787. X        remote_sort_mode, remote_sort_direction) == NULL) {
  788. X        fprintf(stderr, "add_dirname failed!\n");
  789. X        return 1;
  790. X    }
  791. X    return 0;
  792. }
  793. X
  794. X
  795. /*
  796. X take the dir_parse string, in the form of
  797. X    PERMS LINKS USER GROUP SIZE MONTH DAY TIME NAME
  798. X and return a NULL-terminated array of character values of the above
  799. X
  800. X The values would be control-characters, so they are not in danger
  801. X of being typed (right!). A ' ' represents whitespace, any other character
  802. X must be matched exactly.
  803. X */
  804. X
  805. char    *lex_string;
  806. X
  807. #ifdef USE_PROTOTYPES
  808. char *dir_parse_to_pattern(char *dir_parse)
  809. #else
  810. char *dir_parse_to_pattern(dir_parse)
  811. char    *dir_parse;
  812. #endif
  813. {
  814. X    static char pattern[MAXPATHLEN+1];
  815. X    char    *nextpos = pattern;
  816. X    char    *s;
  817. X    int        token;
  818. X    int        found_bitmask = 0;
  819. X    int        yylex();
  820. X    static char *tokval[] = {
  821. X        "",
  822. X        "PERMS",
  823. X        "LINKS",
  824. X        "USER",
  825. X        "GROUP",
  826. X        "SIZE",
  827. X        "MONTH",
  828. X        "DAY",
  829. X        "TIME",
  830. X        "NAME",
  831. X        "SKIP",
  832. X        "NONUNIX",
  833. X        "LOWERNAME",
  834. X    };
  835. X
  836. X    lex_string = strdup(dir_parse);
  837. X    if (lex_string == NULL) {
  838. X        fprintf(stderr, "Out of memory\n");
  839. X        exit(1);
  840. X    }
  841. X    s = lex_string;
  842. X    while (token = yylex()) {
  843. X        *nextpos = (char)token;
  844. X        nextpos++;
  845. X        if (token <= MAXTOKENS) {
  846. X            if (found_bitmask & (1 << token)) {
  847. X                fprintf(stderr, "Duplicate token %s in DIR template.\n", 
  848. X                    tokval[token]);
  849. X                free(s);
  850. X                return NULL;
  851. X            }
  852. X            if (token != SKIP)
  853. X                found_bitmask |= 1 << token;
  854. X        }
  855. X    }
  856. X    *nextpos = '\0';
  857. X    free(s);
  858. X    if ((found_bitmask & (1 << NONUNIX)) != 0) {
  859. X        pattern[0] = (char)NONUNIX;
  860. X        return pattern;
  861. X    }
  862. X    /* make sure that we have a filename, at least */
  863. X    if ((found_bitmask & (1 << NAME)) == 0  
  864. X        && (found_bitmask & (1 << LOWERNAME)) == 0) {
  865. X        fprintf(stderr,"You must specify a NAME token in your parse field.\n");
  866. X        return NULL;
  867. X    }
  868. X    return pattern;
  869. }
  870. X
  871. #undef NULLCHECK
  872. #define NULLCHECK() if (*s == '\0') {*temp_non_unix = 1; return -1;}
  873. X
  874. #ifdef USE_PROTOTYPES
  875. int perms(char *s, int *temp_non_unix)
  876. #else
  877. int perms(s, temp_non_unix)
  878. char    *s;
  879. int        *temp_non_unix;
  880. #endif
  881. {
  882. X    int mode;
  883. X
  884. X    switch (*s) {
  885. X    case 'd':
  886. X            mode = S_IFDIR;
  887. X            break;
  888. X    case 'F':
  889. X    case 'f':
  890. X    case 'm': /* Cray and convex migrated files */
  891. X    case '-':
  892. X            mode = S_IFREG;
  893. X            break;
  894. X    case 'l':
  895. X            mode = S_IFLNK;
  896. X            break;
  897. X    case 'b':
  898. X            mode = S_IFBLK;
  899. X            break;
  900. X    case 'c':
  901. X            mode = S_IFCHR;
  902. X            break;
  903. X    case 's':
  904. X            mode = S_IFSOCK;
  905. X            break;
  906. X    case 'p':
  907. X            mode = S_IFIFO;
  908. X            break;
  909. X    case 'D':
  910. X            mode = S_IFDIR;
  911. X            break;
  912. X    case 'B':
  913. X            mode = S_IFBLK;
  914. X            break;
  915. X    case 'C':
  916. X            mode = S_IFCHR;
  917. X            break;
  918. X    case 'S':
  919. X            mode = S_IFSOCK;
  920. X            break;
  921. X    case 'P':
  922. X            mode = S_IFIFO;
  923. X            break;
  924. X    case 't':
  925. X            if (!strncmp(s, "total", 5))
  926. X                return 0;
  927. X            /* fall through */
  928. #ifdef notdef
  929. X    case '.':
  930. X        if (s[1] == ':') {
  931. X            ftperr = ftp_error(' ', "Permission denied");
  932. X            footer_message(ftperr, (char *)NULL);
  933. X            return 0;
  934. X        } else if (!strncmp(s, ". unreadable", 12)) {
  935. X            footer_message(". unreadable", (char *)NULL);
  936. X            return 0;
  937. X        }
  938. #endif
  939. X    default:
  940. X            *temp_non_unix = 1;
  941. #ifdef notdef
  942. X            sprintf(scratch, "%s (non-UNIX?)", 
  943. X                (char *)xv_get(base_window.frame, XV_LABEL));
  944. X            xv_set(base_window.frame, XV_LABEL, scratch, NULL);
  945. X            remote_sort_mode = SORTBYNAME;
  946. X            xv_set(tool_property_window.directory_lists.remote_sort, 
  947. X                PANEL_VALUE, remote_sort_mode,
  948. X                PANEL_INACTIVE, TRUE,
  949. X                NULL);
  950. X            set_remote_sort_order(SORTBYNAME);
  951. #endif
  952. X            return -1;
  953. X            break;
  954. X    }
  955. X
  956. X    s++;
  957. X    if (*s == ' ' || *s == '\0' || *s == '\t')
  958. X        return mode; /* OK to not have permissions */
  959. X    NULLCHECK();
  960. X    /*
  961. X     Determine permissions.
  962. X     */
  963. X    if (*s++ == 'r')
  964. X        mode |= S_IRUSR;
  965. X    NULLCHECK();
  966. X    if (*s++ == 'w')
  967. X        mode |= S_IWUSR;
  968. X    NULLCHECK();
  969. X    if (*s == 'x' || *s == 's')
  970. X        mode |= S_IXUSR;
  971. X    s++;
  972. X    NULLCHECK();
  973. X    if (*s++ == 'r')
  974. X        mode |= S_IRGRP;
  975. X    NULLCHECK();
  976. X    if (*s++ == 'w')
  977. X        mode |= S_IWGRP;
  978. X    NULLCHECK();
  979. X    if (*s == 'x' || *s == 's')
  980. X        mode |= S_IXGRP;
  981. X    s++;
  982. X    NULLCHECK();
  983. X    if (*s++ == 'r')
  984. X        mode |= S_IROTH;
  985. X    NULLCHECK();
  986. X    if (*s++ == 'w')
  987. X        mode |= S_IWOTH;
  988. X    NULLCHECK();
  989. X    if (*s == 'x' || *s == 't')
  990. X        mode |= S_IXOTH;
  991. X    s++;
  992. X    NULLCHECK();
  993. X    return mode;
  994. }
  995. SHAR_EOF
  996. chmod 0644 readdir.c ||
  997. echo 'restore of readdir.c failed'
  998. Wc_c="`wc -c < 'readdir.c'`"
  999. test 13063 -eq "$Wc_c" ||
  1000.     echo 'readdir.c: original size 13063, current size' "$Wc_c"
  1001. rm -f _shar_wnt_.tmp
  1002. fi
  1003. # ============= change_dir.c ==============
  1004. if test -f 'change_dir.c' -a X"$1" != X"-c"; then
  1005.     echo 'x - skipping change_dir.c (File already exists)'
  1006.     rm -f _shar_wnt_.tmp
  1007. else
  1008. > _shar_wnt_.tmp
  1009. echo 'x - extracting change_dir.c (Text)'
  1010. sed 's/^X//' << 'SHAR_EOF' > 'change_dir.c' &&
  1011. #include "ftptool.h"
  1012. X
  1013. int dirlastmtime;
  1014. X
  1015. #ifdef USE_PROTOTYPES
  1016. int    checkdir(char *dirname)
  1017. #else
  1018. int    checkdir(dirname)
  1019. char    *dirname;
  1020. #endif
  1021. {
  1022. X    struct stat buf;
  1023. X
  1024. X    if (lstat(dirname, &buf) == -1) {
  1025. X        if (errno == ENOENT) 
  1026. X            return ENOENT;
  1027. X        return 1;
  1028. X    }
  1029. X
  1030. X    if (buf.st_mtime > local_dircache.first->mtime) {
  1031. X        return 1;
  1032. X    }
  1033. X    return 0;
  1034. }
  1035. X
  1036. #ifdef USE_PROTOTYPES
  1037. int dirwasmodified(void)
  1038. #else
  1039. int dirwasmodified()
  1040. #endif
  1041. {
  1042. X    int    error;
  1043. X    char    *dirname = local_dircache.first->name;
  1044. X
  1045. X    if (cache_lookup(&local_dircache, dirname) == NULL)
  1046. X        return 0;
  1047. X    /* first now */
  1048. X
  1049. X    error = checkdir(dirname);
  1050. X    if (error == ENOENT) {
  1051. X        if (xv_get(local_window.frame, XV_SHOW) == FALSE) {
  1052. X            xv_set(local_window.frame, 
  1053. X                XV_SHOW, TRUE, 
  1054. X                NULL);
  1055. X        }
  1056. X        local_footer_message("Current directory was deleted. Changing to /tmp.",
  1057. X            (char *)NULL);
  1058. X        clear_slist(local_window.list);
  1059. X        xv_set(local_window.list, 
  1060. X            XV_SHOW, TRUE, 
  1061. X            NULL);
  1062. X        dircache_delete(&local_dircache, dirname);
  1063. X        change_local_dir("/tmp", 0);
  1064. X        return 1;
  1065. X    } else if (error != 0) {
  1066. X        local_footer_message("Current directory was modified. Rereading.", 
  1067. X            (char *)NULL);
  1068. X        if (xv_get(local_window.frame, XV_SHOW) == FALSE) {
  1069. X            xv_set(local_window.frame, 
  1070. X                XV_SHOW, TRUE, 
  1071. X                NULL);
  1072. X        }
  1073. X        clear_slist(local_window.list);
  1074. X        xv_set(local_window.list, 
  1075. X            XV_SHOW, TRUE, 
  1076. X            NULL);
  1077. X        dircache_delete(&local_dircache, dirname);
  1078. X        change_local_dir(dirname, 0);
  1079. X        return 1;
  1080. X    }
  1081. X    return 0;
  1082. }
  1083. X
  1084. #ifdef USE_PROTOTYPES
  1085. int change_local_dir(char *s, int force)
  1086. #else
  1087. int change_local_dir(s, force)
  1088. char    *s;
  1089. int        force;
  1090. #endif
  1091. {
  1092. X    static char    cld[MAXPATHLEN + 2];
  1093. X    extern char *sys_errlist[];
  1094. X    struct dirlist *head = NULL;
  1095. X    int        wasinactive;
  1096. X    int        rval = 0;
  1097. X    int        error;
  1098. X    char    *dir = NULL;
  1099. #if defined(SYSV) || defined(SYSV386)
  1100. X    struct statvfs fsbuf;
  1101. #else
  1102. X    struct statfs fsbuf;
  1103. #endif
  1104. X
  1105. X    wasinactive = xv_get(local_window.list, PANEL_INACTIVE);
  1106. X    if (wasinactive == FALSE) {
  1107. X        xv_set(local_window.list, 
  1108. X            PANEL_INACTIVE, TRUE, 
  1109. X            NULL);
  1110. X    }
  1111. X    cursor_busy();
  1112. X    local_footer_message("Reading directory...", (char *)NULL);
  1113. X    local_right_footer_message("", (char *)NULL);
  1114. X    dir = expand_dirname(s);
  1115. X    if (dir == NULL) {
  1116. X        fprintf(stderr, "out of memory\n");
  1117. X        goto out;
  1118. X    }
  1119. X    if (chdir(dir) == -1) {
  1120. X        if (errno == ENOENT) {
  1121. X            if (rval = ask_make_dir(dir)) { 
  1122. X                if (rval == -1) {
  1123. X                    local_footer_message("", (char *)NULL);
  1124. X                    /* user canceled. */
  1125. X                    goto out;
  1126. X                }
  1127. X                local_footer_message("Could not make directory: %s",
  1128. X                        sys_errlist[rval], (char *)NULL);
  1129. X                goto out;
  1130. X            }
  1131. X            if (chdir(dir) == -1) {
  1132. X                rval = errno;
  1133. X                local_footer_message("Could not change to directory: %s",
  1134. X                        sys_errlist[rval], (char *)NULL);
  1135. X                goto out;
  1136. X            }
  1137. X        } else {
  1138. X            rval = errno;
  1139. X            local_footer_message("Could not change to directory: %s",
  1140. X                    sys_errlist[rval], (char *)NULL);
  1141. X            goto out;
  1142. X        }
  1143. X    }
  1144. X
  1145. X    clear_slist(local_window.list);
  1146. X
  1147. X    local_list_ndirs = 0;
  1148. X    local_list_nfiles = 0;
  1149. X    local_list_nothers = 0;
  1150. X    change_local_list_menu();
  1151. X
  1152. X    if (getcwd(cld, sizeof(cld)) == NULL) {
  1153. X        /* Failure */
  1154. X        goto out;
  1155. X    }
  1156. X
  1157. X    xv_set(local_window.directory, 
  1158. X        PANEL_VALUE, cld, 
  1159. X        NULL);
  1160. X
  1161. #if defined(SYSV) || defined(SYSV386)
  1162. X    if (statvfs(cld, &fsbuf) == -1) {
  1163. X        sprintf(scratch, "statvfs failed: %s", sys_errlist[errno]);
  1164. X    } 
  1165. #else
  1166. X    if (statfs(cld, &fsbuf) == -1) {
  1167. X        sprintf(scratch, "statfs failed: %s", sys_errlist[errno]);
  1168. X    }
  1169. #endif
  1170. X    else {
  1171. X        sprintf(scratch, "%d Kbytes (%d%% free)", 
  1172. X            (int)(fsbuf.f_bsize / 1024.0 * fsbuf.f_bavail), 
  1173. X            (int)(100.0 * fsbuf.f_bavail / 
  1174. X                (fsbuf.f_blocks - (fsbuf.f_bfree - fsbuf.f_bavail))));
  1175. X    }
  1176. X    xv_set(local_window.space,
  1177. X        PANEL_LABEL_STRING, scratch,
  1178. X        NULL);
  1179. X
  1180. X    if (force)
  1181. X        dircache_delete(&local_dircache, cld);
  1182. X
  1183. X    head = cache_lookup(&local_dircache, cld);
  1184. X    if (head == NULL) {
  1185. X        /* cache miss */
  1186. X        head = read_local_dir(cld);
  1187. X        if (head == NULL) {
  1188. X            fprintf(stderr, "Out of memory\n");
  1189. X            rval = 1;
  1190. X            goto out;
  1191. X        }
  1192. X        /* add to cache */
  1193. X        dircache_add(&local_dircache, cld, head);
  1194. X        local_dircache.first->mtime = dirlastmtime;
  1195. X    } else if (error = checkdir(cld)) {
  1196. X        dircache_delete(&local_dircache, cld);
  1197. X        if (error == ENOENT) {
  1198. X            local_footer_message("%s does not exist.", cld, (char *)NULL);
  1199. X            goto out;
  1200. X        }
  1201. X        /* else reread */
  1202. X        head = read_local_dir(cld);
  1203. X        if (head == NULL) {
  1204. X            fprintf(stderr, "Out of memory\n");
  1205. X            rval = 1;
  1206. X            goto out;
  1207. X        }
  1208. X        /* add to cache */
  1209. X        dircache_add(&local_dircache, cld, head);
  1210. X        local_dircache.first->mtime = dirlastmtime;
  1211. X    }
  1212. X
  1213. X
  1214. X    dirlist_to_slist(local_window.list, head);
  1215. X
  1216. X    local_show_items();
  1217. X    local_footer_message("", (char *)NULL);
  1218. out:
  1219. X    cursor_normal();
  1220. X
  1221. X    if (dir)
  1222. X        free(dir);
  1223. X    if (wasinactive == FALSE) {
  1224. X        xv_set(local_window.list, 
  1225. X            PANEL_INACTIVE, FALSE, 
  1226. X            NULL);
  1227. X    }
  1228. X    XFlush(dpy);
  1229. X    return rval;
  1230. }
  1231. X
  1232. #ifdef USE_PROTOTYPES
  1233. int change_remote_dir(char *s, int force)
  1234. #else
  1235. int change_remote_dir(s, force)
  1236. char    *s;
  1237. int    force;
  1238. #endif
  1239. {
  1240. X    char    *ftperr;
  1241. X    char    crd[MAXPATHLEN + 1];
  1242. X    struct dirlist *head = NULL;
  1243. X    int        wasinactive;
  1244. X    char    *dir=NULL;
  1245. X    int        rval=0;
  1246. X    int        pwdfailed = 0;
  1247. X    char    *quote;
  1248. X
  1249. X    wasinactive = xv_get(base_window.list, PANEL_INACTIVE);
  1250. X    if (wasinactive == FALSE) {
  1251. X        xv_set(base_window.list, 
  1252. X            PANEL_INACTIVE, TRUE, 
  1253. X            NULL);
  1254. X    }
  1255. X    if (ping_server())
  1256. X        goto out;
  1257. X    cursor_busy();
  1258. X    /* send cd command */
  1259. X    footer_message("Reading directory...", (char *)NULL);
  1260. X    right_footer_message("", (char *)NULL);
  1261. X    dir = strdup(s);
  1262. X    if (dir == NULL)
  1263. X        goto out;
  1264. X    if (!strcmp(dir, "..")) {
  1265. X        if (up_one_level())
  1266. X            goto out;
  1267. X    } else if (strcmp(dir, ".")) {
  1268. X        extern int code;
  1269. X
  1270. X        code = -1;
  1271. X        command("CWD %s", dir);
  1272. X        /* success */
  1273. X        /*
  1274. X         250 CWD command successful.
  1275. X         */
  1276. X        /* failure */
  1277. X        /*
  1278. X         550 k: No such file or directory
  1279. X         */
  1280. X         if (code == 550) {
  1281. X            ftperr = index(response_line, ':');
  1282. X            if (ftperr == NULL) {
  1283. X                rval = 1;
  1284. X                goto out;
  1285. X            }
  1286. X            if (!strncmp(ftperr, ": Not a directory.", 18)) {
  1287. X                footer_message("%s is not a directory.", dir, (char *)NULL);
  1288. X                rval = ENOTDIR;
  1289. X                goto out;
  1290. X            }
  1291. X            if (rval = ask_make_remote_dir(dir)) {
  1292. X                if (rval == -1) {
  1293. X                    footer_message("", (char *)NULL);
  1294. X                    /* user cancelled */
  1295. X                    goto out;
  1296. X                }
  1297. X                footer_message("Could not make directory.", (char *)NULL);
  1298. X                goto out;
  1299. X            }
  1300. X            command("CWD %s", dir);
  1301. X            if (code == 550) {
  1302. X                sprintf(scratch, "%s: No such file or directory.", dir);
  1303. X                ftperr = ftp_error(' ', scratch);
  1304. X                footer_message(ftperr, (char *)NULL);
  1305. X                rval = 1;
  1306. X                goto out;
  1307. X            }
  1308. X        } 
  1309. X    }
  1310. X
  1311. X    clear_slist(base_window.list);
  1312. X
  1313. X    remote_list_ndirs = 0;
  1314. X    remote_list_nfiles = 0;
  1315. X    remote_list_nothers = 0;
  1316. X
  1317. X    change_remote_list_menu();
  1318. X
  1319. X    /* set current directory */
  1320. X    if (command("PWD") == ERROR && code == 500) {
  1321. X        /*
  1322. X        footer_message("pwd not recognized.", (char *)NULL);
  1323. X        */
  1324. X        /* try quote xpwd */
  1325. X        if (command("XPWD") == ERROR && code == 500) {
  1326. X            footer_message("pwd and xpwd not recognized.", (char *)NULL);
  1327. X            pwdfailed = 1;
  1328. X        }
  1329. X    }
  1330. X    /* response */
  1331. X    /*
  1332. X     25[17] "/" is current directory.
  1333. X     257 PWD: "/Print_Output" is current directory.
  1334. X     * 
  1335. X     * Skip to first double-quote, since they seem to have that.
  1336. X     */
  1337. X    crd[0] = '\0';
  1338. X    if (pwdfailed) {
  1339. X        force = 1;
  1340. X    } else if (!strncmp(response_line, "257", 3)) {
  1341. X        quote = strchr(response_line, '\"');
  1342. X        if (quote != NULL)
  1343. X            sscanf (quote, "\"%[^\"]\"", crd);
  1344. X    } else if (!strncmp(response_line, "251", 3)) {
  1345. X        quote = strchr(response_line, '\"');
  1346. X        if (quote != NULL)
  1347. X            sscanf (response_line, "\"%[^\"]\"", crd);
  1348. X    } else {
  1349. X        footer_message("pwd or xpwd returned bad response.", (char *)NULL);
  1350. X        force = 1;
  1351. X    }
  1352. X    xv_set(base_window.directory, 
  1353. X        PANEL_VALUE, crd, 
  1354. X        NULL);
  1355. X
  1356. X    if (force)
  1357. X        dircache_delete(&remote_dircache, crd);
  1358. X    head = cache_lookup(&remote_dircache, crd);
  1359. X    if (head == NULL) {
  1360. X        /* cache miss */
  1361. X        head = read_remote_dir(crd);
  1362. X        if (head == NULL) {
  1363. X            rval = ETIMEDOUT;
  1364. X            goto out;
  1365. X        }
  1366. X        dircache_add(&remote_dircache, crd, head);
  1367. X    }
  1368. X
  1369. X
  1370. X    dirlist_to_slist(base_window.list, head);
  1371. X
  1372. X    remote_show_items();
  1373. out:
  1374. X    if (rval == 0)
  1375. X        footer_message("", (char *)NULL);
  1376. X    cursor_normal();
  1377. X    if (dir)
  1378. X        free(dir);
  1379. /*
  1380. X    if (head)
  1381. X        free_dirlist(head);
  1382. */
  1383. X    if (wasinactive == FALSE) {
  1384. X        xv_set(base_window.list, 
  1385. X            PANEL_INACTIVE, FALSE, 
  1386. X            NULL);
  1387. X    }
  1388. X    if (timedout)
  1389. X        timeout_disconnect();
  1390. X    XFlush(dpy);
  1391. X    return rval;
  1392. }
  1393. X
  1394. #ifdef USE_PROTOTYPES
  1395. char *expand_dirname(char *arg)
  1396. #else
  1397. char *expand_dirname(arg)
  1398. char    *arg;
  1399. #endif
  1400. {
  1401. X    char     *slash;
  1402. X    char    *lastpart = "";
  1403. X    char    *path;
  1404. X    struct passwd *pwd;
  1405. X    char    *firstpart="";
  1406. X    char    *s;
  1407. X
  1408. X    if (arg[0] == '/' || (arg[0] != '~' && arg[0] != '$')) {
  1409. X        path = strdup(arg);
  1410. X        return path;
  1411. X    }
  1412. X    s = strdup(arg);
  1413. X    if (s == NULL)
  1414. X        return NULL;
  1415. X    if (slash = index(s, '/')) {
  1416. X        *slash = 0;
  1417. X        lastpart = slash + 1;
  1418. X    }
  1419. X    switch (s[0]) {
  1420. X    case '~': /* ~ or ~user */
  1421. X        if (s[1] == '\0') {
  1422. X            pwd = getpwuid(getuid());
  1423. X            if (pwd == NULL) {
  1424. X                footer_message("You are unknown to the system.", (char *)NULL);
  1425. X                free(s);
  1426. X                return NULL;
  1427. X            }
  1428. X        } else {
  1429. X            pwd = getpwnam(&s[1]);
  1430. X            if (pwd == NULL) {
  1431. X                footer_message("Unknown user %s.", &s[1], (char *)NULL);
  1432. X                free(s);
  1433. X                return NULL;
  1434. X            }
  1435. X        }
  1436. X        firstpart = pwd->pw_dir;
  1437. X        break;
  1438. X    case '$': /* Environment variable */
  1439. X        firstpart = getenv(&s[1]);
  1440. X        if (firstpart == NULL) {
  1441. X            footer_message("Unknown variable %s.", &s[1], (char *)NULL);
  1442. X            free(s);
  1443. X            return NULL;
  1444. X        }
  1445. X        break;
  1446. X    }
  1447. X    path = (char *)malloc((unsigned int)(strlen(firstpart)+1+strlen(lastpart)+1));
  1448. X    if (path == NULL) {
  1449. X        footer_message("Memory allocation failed.", (char *)NULL);
  1450. X        free(s);
  1451. X        return NULL;
  1452. X    }
  1453. X    if (lastpart[0] != '\0')
  1454. X        sprintf(path, "%s/%s", firstpart, lastpart);
  1455. X    else
  1456. X        strcpy(path, firstpart);
  1457. X    free(s);
  1458. X    return (path);
  1459. }
  1460. X
  1461. #ifdef USE_PROTOTYPES
  1462. int    delete_local_dir(char *dir)
  1463. #else
  1464. int    delete_local_dir(dir)
  1465. char    *dir;
  1466. #endif
  1467. {
  1468. X    struct dirlist *head = NULL;
  1469. X    struct dirlist *tmp;
  1470. X    extern char *sys_errlist[];
  1471. X    int    rval = 0;
  1472. X
  1473. X    if (chdir(dir) == -1) {
  1474. X        local_footer_message("Can not change to %s: %s", 
  1475. X            dir, sys_errlist[errno], (char *)NULL);
  1476. X        return errno;
  1477. X    }
  1478. X    head = read_local_dir(".");
  1479. X    if (head == NULL) {
  1480. X        fprintf(stderr, "Out of memory\n");
  1481. X        rval = ENOMEM;
  1482. X        goto out;
  1483. X    }
  1484. X    for (tmp = head->next; tmp != NULL; tmp = tmp->next)
  1485. X        if (S_ISDIR(tmp->mode)) {
  1486. X            if (rval = delete_local_dir(tmp->name))
  1487. X                goto out;
  1488. X        } else if (rval = delete_local_file(tmp->name, unlink))
  1489. X                goto out;
  1490. out:
  1491. X    if (head)
  1492. X        free_dirlist(head);
  1493. X    if (chdir("..") == -1) {
  1494. X        local_footer_message("Can not cd ..: %s", 
  1495. X            sys_errlist[errno], (char *)NULL);
  1496. X        return errno;
  1497. X    }
  1498. X    /* delete parent */
  1499. X    if (rval == 0)
  1500. X        rval = delete_local_file(dir, rmdir);
  1501. X    return rval;
  1502. }
  1503. X
  1504. #ifdef USE_PROTOTYPES
  1505. int delete_local_file(char *filename, int (*deletefunc)(const char *filename))
  1506. #else
  1507. int delete_local_file(filename, deletefunc)
  1508. char    *filename;
  1509. int        (*deletefunc)();
  1510. #endif
  1511. {
  1512. X    int    answer;
  1513. X    extern char *sys_errlist[];
  1514. #ifdef XVIEW3
  1515. X    Xv_notice notice;
  1516. #endif
  1517. X
  1518. X    if (confirmdeletes) {
  1519. X        sprintf(scratch, "Really delete %s?", filename);
  1520. #ifdef XVIEW3
  1521. X        notice = xv_create(base_window.panel, NOTICE,
  1522. X            NOTICE_MESSAGE_STRINGS,
  1523. X                scratch,
  1524. X                NULL,
  1525. X            NOTICE_BUTTON_YES, "Cancel",
  1526. X            NOTICE_BUTTON_NO, "Delete",
  1527. X            NOTICE_STATUS, &answer,
  1528. X            XV_SHOW, TRUE,
  1529. X            NULL);
  1530. X        xv_destroy_safe(notice);
  1531. #else
  1532. X        answer =  notice_prompt(base_window.panel, NULL,
  1533. X            NOTICE_MESSAGE_STRINGS,
  1534. X                scratch,
  1535. X                NULL,
  1536. X            NOTICE_BUTTON_YES, "Cancel",
  1537. X            NOTICE_BUTTON_NO, "Delete",
  1538. X            NULL);
  1539. #endif
  1540. X    } else
  1541. X        answer = NOTICE_NO;
  1542. X
  1543. X    if (answer == NOTICE_NO) {
  1544. X        local_footer_message("Deleting %s", filename, (char *)NULL);
  1545. X        if ((*deletefunc)(filename) == -1) {
  1546. X            local_footer_message("delete %s failed: %s", filename,
  1547. X                sys_errlist[errno], (char *)NULL);
  1548. X            return 1;
  1549. X        }
  1550. X        return 0;
  1551. X    }
  1552. X    return 1; /* deletion aborted */
  1553. }
  1554. X
  1555. #ifdef USE_PROTOTYPES
  1556. int    delete_remote_dir(char *dir)
  1557. #else
  1558. int    delete_remote_dir(dir)
  1559. char    *dir;
  1560. #endif
  1561. {
  1562. X    struct dirlist *head = NULL;
  1563. X    struct dirlist *tmp;
  1564. X    int    rval = 0;
  1565. X    char    *ftperr;
  1566. X
  1567. X    if (command("CWD %s", dir) == ERROR && code == 550) {
  1568. X        sprintf(scratch, "Can not change to %s", dir);
  1569. X        ftperr = ftp_error(' ', scratch);
  1570. X        footer_message(ftperr, (char *)NULL);
  1571. X        return 1;
  1572. X    }
  1573. X    head = read_remote_dir((char *)NULL);
  1574. X    if (head == NULL) {
  1575. X        rval = ENOMEM;
  1576. X        goto out;
  1577. X    }
  1578. X    for (tmp = head->next; tmp != NULL; tmp = tmp->next)
  1579. X        if (S_ISDIR(tmp->mode)) {
  1580. X            if (rval = delete_remote_dir(tmp->name))
  1581. X                goto out;
  1582. X        } else if (rval = delete_remote_file(tmp->name, "DELE"))
  1583. X                goto out;
  1584. out:
  1585. X    if (head)
  1586. X        free_dirlist(head);
  1587. X    if (up_one_level())
  1588. X        footer_message("Can not cd ..", (char *)NULL);
  1589. X        
  1590. X    /* delete parent */
  1591. X    if (rval == 0)
  1592. X        rval = delete_remote_file(dir, "RMD");
  1593. X    return rval;
  1594. }
  1595. X
  1596. #ifdef USE_PROTOTYPES
  1597. int delete_remote_file(char *filename, char *deletecmd)
  1598. #else
  1599. int delete_remote_file(filename, deletecmd)
  1600. char    *filename;
  1601. char    *deletecmd;
  1602. #endif
  1603. {
  1604. X    char    *ftperr;
  1605. X    int    answer;
  1606. #ifdef XVIEW3
  1607. X    Xv_notice notice;
  1608. #endif
  1609. X
  1610. X    if (confirmdeletes) {
  1611. X        sprintf(scratch, "Really delete %s?", filename);
  1612. #ifdef XVIEW3
  1613. X        notice = xv_create(base_window.panel, NOTICE,
  1614. X            NOTICE_MESSAGE_STRINGS,
  1615. X                scratch,
  1616. X                NULL,
  1617. X            NOTICE_BUTTON_YES, "Cancel",
  1618. X            NOTICE_BUTTON_NO, "Delete",
  1619. X            NOTICE_STATUS, &answer,
  1620. X            XV_SHOW, TRUE,
  1621. X            NULL);
  1622. X        xv_destroy_safe(notice);
  1623. #else
  1624. X        answer = notice_prompt(base_window.panel, NULL,
  1625. X            NOTICE_MESSAGE_STRINGS,
  1626. X                scratch,
  1627. X                NULL,
  1628. X            NOTICE_BUTTON_YES, "Cancel",
  1629. X            NOTICE_BUTTON_NO, "Delete",
  1630. X            NULL);
  1631. #endif
  1632. X    } else
  1633. X        answer = NOTICE_NO;
  1634. X
  1635. X    if (answer == NOTICE_NO) {
  1636. X        footer_message("Deleting %s", filename, (char *)NULL);
  1637. X        sprintf(scratch, "%s %s", deletecmd, filename);
  1638. X        if (command(scratch) == ERROR) {
  1639. X            sprintf(scratch, "delete %s failed", filename);
  1640. X            ftperr = ftp_error(' ', scratch);
  1641. X            footer_message(ftperr, (char *)NULL);
  1642. X            return 1;
  1643. X        }
  1644. X        return 0;
  1645. X    }
  1646. X    return 1; /* deletion aborted */
  1647. }
  1648. X
  1649. #ifdef USE_PROTOTYPES
  1650. int up_one_level(void)
  1651. #else
  1652. int up_one_level()
  1653. #endif
  1654. {
  1655. X    if (command("CDUP") == ERROR && code == 500) {
  1656. X        if (!strncmp(response_line, "500", 3)) {
  1657. X            /*
  1658. X            footer_message("cdup not recognized.", (char *)NULL);
  1659. X            */
  1660. X            /* try quote xcup */
  1661. X            if (command("XCUP") == ERROR && code == 500) {
  1662. X                /* try cd .. */
  1663. X                code = -1;
  1664. X                if (command("CWD ..") == ERROR && code == 550) {
  1665. X                    footer_message("cdup, xcup, and 'cd ..' failed. Try manually.", (char *)NULL);
  1666. X                    return 1;
  1667. X                }
  1668. X            }
  1669. X        }
  1670. X    } 
  1671. X    return 0;
  1672. }
  1673. SHAR_EOF
  1674. chmod 0644 change_dir.c ||
  1675. echo 'restore of change_dir.c failed'
  1676. Wc_c="`wc -c < 'change_dir.c'`"
  1677. test 14252 -eq "$Wc_c" ||
  1678.     echo 'change_dir.c: original size 14252, current size' "$Wc_c"
  1679. rm -f _shar_wnt_.tmp
  1680. fi
  1681. # ============= event.c ==============
  1682. if test -f 'event.c' -a X"$1" != X"-c"; then
  1683.     echo 'x - skipping event.c (File already exists)'
  1684.     rm -f _shar_wnt_.tmp
  1685. else
  1686. > _shar_wnt_.tmp
  1687. echo 'x - extracting event.c (Text)'
  1688. sed 's/^X//' << 'SHAR_EOF' > 'event.c' &&
  1689. #include "ftptool.h"
  1690. X
  1691. #ifdef USE_PROTOTYPES
  1692. void    local_cd_select(void)
  1693. #else
  1694. void    local_cd_select()
  1695. #endif
  1696. {
  1697. X    int     nitems, selection, row;
  1698. X    struct dirlist *tmp;
  1699. X
  1700. X    local_footer_message("", (char *)NULL);
  1701. X    /* check to see that only one item is selected, and it is a directory */
  1702. X    nitems = xv_get(local_window.list, PANEL_LIST_NROWS);
  1703. X
  1704. X    selection = 0;
  1705. X    for (row = 0; row < nitems; row++)
  1706. X        if (xv_get(local_window.list, PANEL_LIST_SELECTED, row)) {
  1707. X            tmp = (struct dirlist *)xv_get(local_window.list, 
  1708. X                PANEL_LIST_CLIENT_DATA, row);
  1709. X            if (S_ISDIR(tmp->mode)) {
  1710. X                selection = row;
  1711. X                break;
  1712. X            }
  1713. X        }
  1714. X
  1715. X    tmp = (struct dirlist *)xv_get(local_window.list, 
  1716. X        PANEL_LIST_CLIENT_DATA, selection);
  1717. X
  1718. X    xv_set(local_window.list, 
  1719. X        PANEL_LIST_SELECT, selection, FALSE, 
  1720. X        NULL);
  1721. X    change_local_dir(tmp->name, 0);
  1722. }
  1723. X
  1724. #ifdef USE_PROTOTYPES
  1725. void    local_cd_text(void)
  1726. #else
  1727. void    local_cd_text()
  1728. #endif
  1729. {
  1730. X    char    *dir;
  1731. X
  1732. X    local_footer_message("", (char *)NULL);
  1733. X    dir = (char *)xv_get(local_window.directory, PANEL_VALUE);
  1734. X    if (*dir == '\0') {
  1735. X        local_footer_message("Please type in a pathname first.",(char *)NULL);
  1736. X        return;
  1737. X    }
  1738. X    change_local_dir(dir, 0);
  1739. }
  1740. X
  1741. #ifdef USE_PROTOTYPES
  1742. void    local_cd_dotdot(void)
  1743. #else
  1744. void    local_cd_dotdot()
  1745. #endif
  1746. {
  1747. X    local_footer_message("", (char *)NULL);
  1748. X    change_local_dir("..", 0);
  1749. }
  1750. X
  1751. #ifdef USE_PROTOTYPES
  1752. void    remote_cd_select(void)
  1753. #else
  1754. void    remote_cd_select()
  1755. #endif
  1756. {
  1757. X    int     nitems, selection, row;
  1758. X    struct dirlist *tmp;
  1759. X
  1760. X    footer_message("", (char *)NULL);
  1761. X    /* check to see that only one item is selected, and it is a directory */
  1762. X    nitems = xv_get(base_window.list, PANEL_LIST_NROWS);
  1763. X    selection = 0;
  1764. X    for (row = 0; row < nitems; row++)
  1765. X        if (xv_get(base_window.list, PANEL_LIST_SELECTED, row)) {
  1766. X            tmp = (struct dirlist *)xv_get(base_window.list, 
  1767. X                PANEL_LIST_CLIENT_DATA, row);
  1768. X            if (non_unix || S_ISDIR(tmp->mode)) {
  1769. X                selection = row;
  1770. X                break;
  1771. X            }
  1772. X        }
  1773. X
  1774. X    tmp = (struct dirlist *)xv_get(base_window.list, 
  1775. X        PANEL_LIST_CLIENT_DATA, selection);
  1776. X
  1777. X    xv_set(base_window.list, 
  1778. X        PANEL_LIST_SELECT, selection, FALSE, 
  1779. X        NULL);
  1780. X    which_remote_file = strdup(tmp->name);
  1781. X    if (which_remote_file == NULL) {
  1782. X        fprintf(stderr, "Out of memory.\n");
  1783. X        return;
  1784. X    }
  1785. X    dowhat = DOREMOTECD;
  1786. X    notify_stop();
  1787. }
  1788. X
  1789. #ifdef USE_PROTOTYPES
  1790. void    remote_cd_text(void)
  1791. #else
  1792. void    remote_cd_text()
  1793. #endif
  1794. {
  1795. X    footer_message("", (char *)NULL);
  1796. X    which_remote_file = (char *)xv_get(base_window.directory, PANEL_VALUE);
  1797. X    if (*which_remote_file == '\0') {
  1798. X        footer_message("Please type in a pathname first.",(char *)NULL);
  1799. X        return;
  1800. X    }
  1801. X    if (!non_unix)
  1802. X        which_remote_file = expand_dirname(which_remote_file);
  1803. X    else
  1804. X        which_remote_file = strdup(which_remote_file);
  1805. X    if (which_remote_file == NULL)
  1806. X        return;
  1807. X    dowhat = DOREMOTECD;
  1808. X    notify_stop();
  1809. }
  1810. X
  1811. #ifdef USE_PROTOTYPES
  1812. void    remote_cd_dotdot(void)
  1813. #else
  1814. void    remote_cd_dotdot()
  1815. #endif
  1816. {
  1817. X    footer_message("", (char *)NULL);
  1818. X    which_remote_file = strdup("..");
  1819. X    if (which_remote_file == NULL) {
  1820. X        fprintf(stderr,"Out of memory.\n");
  1821. X        return;
  1822. X    }
  1823. X    dowhat = DOREMOTECD;
  1824. X    notify_stop();
  1825. }
  1826. X
  1827. #ifdef USE_PROTOTYPES
  1828. Notify_value destroy_func(Notify_client client, Destroy_status status)
  1829. #else
  1830. Notify_value destroy_func(client, status)
  1831. Notify_client    client;
  1832. Destroy_status    status;
  1833. #endif
  1834. {
  1835. X    int    answer;
  1836. X    static int triedonce;
  1837. #ifdef XVIEW3
  1838. X    Xv_notice notice;
  1839. #endif
  1840. X
  1841. X    if (status == DESTROY_SAVE_YOURSELF) {
  1842. X        /* save state. Not a death */
  1843. X        return NOTIFY_DONE;
  1844. X    }
  1845. X    if (connected) {
  1846. #ifdef XVIEW3
  1847. X        notice = xv_create(base_window.panel, NOTICE,
  1848. X            NOTICE_MESSAGE_STRINGS,
  1849. X                "You are still connected.",
  1850. X                NULL,
  1851. X            NOTICE_BUTTON_YES,  "Cancel",
  1852. X            NOTICE_BUTTON_NO,    "Quit anyway",
  1853. X            NOTICE_STATUS, &answer,
  1854. X            XV_SHOW, TRUE,
  1855. X            NULL);
  1856. X        xv_destroy_safe(notice);
  1857. #else
  1858. X        answer = notice_prompt(base_window.panel, NULL,
  1859. X            NOTICE_MESSAGE_STRINGS,
  1860. X                "You are still connected.",
  1861. X                NULL,
  1862. X            NOTICE_BUTTON_YES,  "Cancel",
  1863. X            NOTICE_BUTTON_NO,    "Quit anyway",
  1864. X            NULL);
  1865. #endif
  1866. X        if (answer == NOTICE_YES)
  1867. X            return (Notify_value)notify_veto_destroy(client);
  1868. X    }
  1869. X    if (list_changed) {
  1870. X        if (status == DESTROY_CHECKING) {
  1871. #ifdef XVIEW3
  1872. X            notice = xv_create(base_window.panel, NOTICE,
  1873. X                NOTICE_MESSAGE_STRINGS,
  1874. X                    "Your host list has changed. You can",
  1875. X                    NULL,
  1876. X                NOTICE_BUTTON_YES,  "Save changes",
  1877. X                NOTICE_BUTTON,      "Quit anyway", 2,
  1878. X                NOTICE_BUTTON,      "Cancel quit", 3,
  1879. X                NOTICE_STATUS, &answer,
  1880. X                XV_SHOW, TRUE,
  1881. X                NULL);
  1882. X            xv_destroy_safe(notice);
  1883. #else
  1884. X            answer = notice_prompt(base_window.panel, NULL,
  1885. X                NOTICE_MESSAGE_STRINGS,
  1886. X                    "Your host list has changed. You can",
  1887. X                    NULL,
  1888. X                NOTICE_BUTTON_YES,  "Save changes",
  1889. X                NOTICE_BUTTON,      "Quit anyway", 2,
  1890. X                NOTICE_BUTTON,      "Cancel quit", 3,
  1891. X                NULL);
  1892. #endif
  1893. X            triedonce = 1;
  1894. X        } else if (!triedonce) {
  1895. #ifdef XVIEW3
  1896. X            notice = xv_create(base_window.panel, NOTICE,
  1897. X                NOTICE_MESSAGE_STRINGS,
  1898. X                    "Your host list has changed. You can",
  1899. X                    NULL,
  1900. X                NOTICE_BUTTON_YES,  "Save changes",
  1901. X                NOTICE_BUTTON,      "Quit anyway", 2,
  1902. X                NOTICE_STATUS, &answer,
  1903. X                XV_SHOW, TRUE,
  1904. X                NULL);
  1905. X            xv_destroy_safe(notice);
  1906. #else
  1907. X            answer = notice_prompt(base_window.panel, NULL,
  1908. X                NOTICE_MESSAGE_STRINGS,
  1909. X                    "Your host list has changed. You can",
  1910. X                    NULL,
  1911. X                NOTICE_BUTTON_YES,  "Save changes",
  1912. X                NOTICE_BUTTON,      "Quit anyway", 2,
  1913. X                NULL);
  1914. #endif
  1915. X        } else {
  1916. X            /* perhaps something has gone wrong. */
  1917. X            answer = 2;
  1918. X        }
  1919. X
  1920. X        switch (answer) {
  1921. X        case NOTICE_YES:
  1922. X            list_changed=0;
  1923. X            timestamped = 0;
  1924. X            write_ftptoolrc();
  1925. X            break;
  1926. X        case 2:
  1927. X            /* avoid saving timestamps, if they are there */
  1928. X            timestamped = 0;
  1929. X            break;
  1930. X        case 3:
  1931. X            return (Notify_value)notify_veto_destroy(client);
  1932. X            break;
  1933. X        }
  1934. X    }
  1935. X    if (timestamped) {
  1936. X        timestamped = 0;
  1937. X        write_ftptoolrc();
  1938. X    }
  1939. X
  1940. X    quit_ftp();
  1941. X
  1942. X    dowhat = DOQUIT;
  1943. X
  1944. X    switch(status) {
  1945. X    case DESTROY_CHECKING:
  1946. X        break;
  1947. X    case DESTROY_CLEANUP:
  1948. X        return notify_next_destroy_func(client, status);
  1949. X        break;
  1950. X    case DESTROY_PROCESS_DEATH:
  1951. X        exit(1);
  1952. X        break;
  1953. X    case DESTROY_SAVE_YOURSELF:
  1954. X        fprintf(stderr, "Impossible DESTROY_SAVE_YOURSELF event in last switch of destroy_func.\n");
  1955. X        break;
  1956. X    }
  1957. X    return NOTIFY_DONE;
  1958. }
  1959. X
  1960. #ifdef USE_PROTOTYPES
  1961. Notify_value sig_func(void)
  1962. #else
  1963. Notify_value sig_func()
  1964. #endif
  1965. {
  1966. X    if (xv_destroy_safe(base_window.frame) == XV_OK) {
  1967. X        quit_ftp();
  1968. X        exit(1);
  1969. X    }
  1970. X    return NOTIFY_DONE;
  1971. }
  1972. X
  1973. #ifdef USE_PROTOTYPES
  1974. void cycle_busy_icon(void)
  1975. #else
  1976. void cycle_busy_icon()
  1977. #endif
  1978. {
  1979. X    static int i;
  1980. X
  1981. X    xv_set(frame_icon, 
  1982. X        ICON_IMAGE, busy_glyphs[i], 
  1983. X        ICON_TRANSPARENT, TRUE,
  1984. X        NULL);
  1985. X    i++;
  1986. X    if (i == nbusyicons)
  1987. X        i = 0;
  1988. }
  1989. X
  1990. static struct itimerval busy_itimer = {
  1991. X    {0, 200000,},
  1992. X    {0, 200000,}
  1993. };
  1994. X
  1995. #ifdef USE_PROTOTYPES
  1996. void start_busy_cycle(void)
  1997. #else
  1998. void start_busy_cycle()
  1999. #endif
  2000. {
  2001. X    notify_set_itimer_func(base_window.frame, (Notify_func)cycle_busy_icon, 
  2002. X        ITIMER_REAL, &busy_itimer, (struct itimerval *)NULL);
  2003. }
  2004. X
  2005. #ifdef USE_PROTOTYPES
  2006. void end_busy_cycle(void)
  2007. #else
  2008. void end_busy_cycle()
  2009. #endif
  2010. {
  2011. X    notify_set_itimer_func(base_window.frame, NOTIFY_FUNC_NULL, ITIMER_REAL,
  2012. X        &busy_itimer, (struct itimerval *)NULL);
  2013. X    xv_set(frame_icon, 
  2014. X        ICON_IMAGE, ftptool_glyph,
  2015. X        ICON_TRANSPARENT, TRUE,
  2016. X        NULL);
  2017. }
  2018. X
  2019. #ifdef USE_PROTOTYPES
  2020. void props_event_proc(Panel panel, Event *event)
  2021. #else
  2022. void props_event_proc(panel, event)
  2023. Panel    panel;
  2024. Event *event;
  2025. #endif
  2026. {
  2027. X    if (event_action(event) == ACTION_PROPS) {
  2028. X        xv_set(tool_property_window.frame, 
  2029. X            XV_SHOW, TRUE, 
  2030. X            NULL);
  2031. X    }
  2032. }
  2033. X
  2034. #ifdef USE_PROTOTYPES
  2035. void base_event_proc(Xv_Window window, Event *event)
  2036. #else
  2037. void base_event_proc(window, event)
  2038. XXv_Window    window;
  2039. Event *event;
  2040. #endif
  2041. {
  2042. X    int height;
  2043. X    int    y;
  2044. X    int    rows;
  2045. X    int    rowsize;
  2046. X    int    width;
  2047. X
  2048. X    switch(event_id(event)) {
  2049. X    case WIN_RESIZE:
  2050. X        height = xv_get(base_window.panel, XV_HEIGHT);
  2051. X        width = xv_get(base_window.panel, XV_WIDTH);
  2052. X        y = xv_get(base_window.list, PANEL_ITEM_Y);
  2053. X        rowsize = xv_get(base_window.list, PANEL_LIST_ROW_HEIGHT);
  2054. X        rows = (height - y - 45) / rowsize;
  2055. X        if (rows <= 0)
  2056. X            rows = 1;
  2057. X        xv_set(base_window.list, 
  2058. X            PANEL_LIST_DISPLAY_ROWS, rows,
  2059. X            PANEL_LIST_WIDTH, width - 30, 
  2060. X            PANEL_PAINT, PANEL_NONE,
  2061. X            NULL);
  2062. X        panel_paint(base_window.list, PANEL_CLEAR);
  2063. X        break;
  2064. X    default:
  2065. X        break;
  2066. X    }
  2067. }
  2068. X
  2069. #ifdef USE_PROTOTYPES
  2070. void resize_window(Panel panel, Panel_item list, Panel_item dismiss)
  2071. #else
  2072. void resize_window(panel, list, dismiss)
  2073. Panel    panel;
  2074. Panel_item    list;
  2075. Panel_item    dismiss;
  2076. #endif
  2077. {
  2078. X    int height;
  2079. X    int    y;
  2080. X    int    rows;
  2081. X    int    rowsize;
  2082. X    int    width;
  2083. X    Rect    *butrect;
  2084. X
  2085. X    height = xv_get(panel, XV_HEIGHT);
  2086. X    width = xv_get(panel, XV_WIDTH);
  2087. X    y = xv_get(list, PANEL_ITEM_Y);
  2088. X    rowsize = xv_get(list, PANEL_LIST_ROW_HEIGHT);
  2089. X    rows = (height - y - 45) / rowsize;
  2090. X    /* leave room for dismiss button */
  2091. X    if (!openlook_mode)
  2092. X        rows -= 1;
  2093. X    if (rows <= 0)
  2094. X        rows = 1;
  2095. X    xv_set(list, 
  2096. X        PANEL_LIST_DISPLAY_ROWS, rows,
  2097. X        PANEL_LIST_WIDTH, width - 30, 
  2098. X        PANEL_PAINT, PANEL_NONE,
  2099. X        NULL);
  2100. X    panel_paint(list, PANEL_CLEAR);
  2101. X    /* for non-openlook mode */
  2102. X    butrect = (Rect *)xv_get(dismiss, XV_RECT);
  2103. X    xv_set(dismiss,
  2104. X        XV_X, width/2 - butrect->r_width/2,
  2105. X        XV_Y, height - butrect->r_height,
  2106. X        NULL);
  2107. }
  2108. X
  2109. #ifdef USE_PROTOTYPES
  2110. void local_event_proc(Xv_Window window, Event *event)
  2111. #else
  2112. void local_event_proc(window, event)
  2113. XXv_Window    window;
  2114. Event *event;
  2115. #endif
  2116. {
  2117. X    switch(event_id(event)) {
  2118. X    case WIN_RESIZE:
  2119. X        resize_window(local_window.panel, local_window.list,
  2120. X            local_window.dismiss);
  2121. X        break;
  2122. X    default:
  2123. X        break;
  2124. X    }
  2125. }
  2126. X
  2127. #ifdef USE_PROTOTYPES
  2128. void schedule_event_proc(Xv_Window window, Event *event)
  2129. #else
  2130. void schedule_event_proc(window, event)
  2131. XXv_Window    window;
  2132. Event *event;
  2133. #endif
  2134. {
  2135. X    int height;
  2136. X    int    y;
  2137. X    int    rows;
  2138. X    int    rowsize;
  2139. X    int    width;
  2140. X
  2141. X    switch(event_id(event)) {
  2142. X    case WIN_RESIZE:
  2143. X        height = xv_get(schedule_window.panel, XV_HEIGHT);
  2144. X        width = xv_get(schedule_window.panel, XV_WIDTH);
  2145. X        y = xv_get(schedule_window.send_list, PANEL_ITEM_Y);
  2146. X        rowsize = xv_get(schedule_window.send_list, PANEL_LIST_ROW_HEIGHT);
  2147. X        rows = (height - y - 45) / rowsize;
  2148. X        if (rows <= 0)
  2149. X            rows = 1;
  2150. X        xv_set(schedule_window.send_list, 
  2151. X            PANEL_LIST_DISPLAY_ROWS, rows,
  2152. X            PANEL_LIST_WIDTH, width - 30, 
  2153. X            PANEL_PAINT, PANEL_NONE,
  2154. X            NULL);
  2155. X        xv_set(schedule_window.receive_list, 
  2156. X            PANEL_LIST_DISPLAY_ROWS, rows,
  2157. X            PANEL_LIST_WIDTH, width - 30, 
  2158. X            PANEL_PAINT, PANEL_NONE,
  2159. X            NULL);
  2160. X        if (xv_get(schedule_window.send_list, XV_SHOW) == TRUE)
  2161. X            panel_paint(schedule_window.send_list, PANEL_CLEAR);
  2162. X        else
  2163. X            panel_paint(schedule_window.receive_list, PANEL_CLEAR);
  2164. X        break;
  2165. X    default:
  2166. X        break;
  2167. X    }
  2168. }
  2169. X
  2170. #ifdef USE_PROTOTYPES
  2171. void host_event_proc(Xv_Window window, Event *event)
  2172. #else
  2173. void host_event_proc(window, event)
  2174. XXv_Window    window;
  2175. Event *event;
  2176. #endif
  2177. {
  2178. X    int    width;
  2179. X    int panelwidth;
  2180. X    Rect    *connect_rect;
  2181. X    Rect    *dismiss_rect;
  2182. X    int    space;
  2183. X    int    pos;
  2184. X    int    y;
  2185. X    Panel_item    item;
  2186. X    Panel_item_type    item_type;
  2187. X
  2188. X    switch(event_id(event)) {
  2189. X    case WIN_RESIZE:
  2190. X        width = xv_get(host_window.frame, XV_WIDTH);
  2191. X        if (xv_get(host_window.advanced.panel, XV_SHOW) == TRUE)
  2192. X            panelwidth = width / 2;
  2193. X        else
  2194. X            panelwidth = width - 2;
  2195. X        xv_set(host_window.panel, 
  2196. X            XV_WIDTH, width,
  2197. X            NULL);
  2198. X        xv_set(host_window.basic.panel, 
  2199. X            XV_WIDTH, panelwidth,
  2200. X            NULL);
  2201. X        xv_set(host_window.advanced.panel, 
  2202. X            XV_WIDTH, panelwidth + 2,
  2203. X            XV_X, panelwidth - 3,
  2204. X            NULL);
  2205. X        PANEL_EACH_ITEM(host_window.basic.panel, item) {
  2206. X            item_type = (Panel_item_type)xv_get(item, PANEL_ITEM_CLASS);
  2207. X            if (item_type == PANEL_TEXT_ITEM)
  2208. X                resize_text_item(host_window.basic.panel, item);
  2209. X        } PANEL_END_EACH;
  2210. X        PANEL_EACH_ITEM(host_window.advanced.panel, item) {
  2211. X            item_type = (Panel_item_type)xv_get(item, PANEL_ITEM_CLASS);
  2212. X            if (item_type == PANEL_TEXT_ITEM)
  2213. SHAR_EOF
  2214. true || echo 'restore of event.c failed'
  2215. fi
  2216. echo 'End of  part 4'
  2217. echo 'File event.c is continued in part 5'
  2218. echo 5 > _shar_seq_.tmp
  2219. exit 0
  2220. -- 
  2221. Senior Systems Scientist        mail: dcmartin@msi.com
  2222. Molecular Simulations, Inc.        uucp: uunet!dcmartin
  2223. 796 North Pastoria Avenue        at&t: 408/522-9236
  2224. Sunnyvale, California 94086        fax: 408/732-0831
  2225.