home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume35 / ncftp / part01 next >
Text File  |  1993-01-25  |  56KB  |  2,497 lines
  1. Newsgroups: comp.sources.misc
  2. From: mgleason@cse.unl.edu (Michael Gleason)
  3. Subject: v35i004:  ncftp - Alternative User Interface for FTP, Part01/04
  4. Message-ID: <csm-v35i004=ncftp.095334@sparky.IMD.Sterling.COM>
  5. X-Md4-Signature: e3a2b18b99720bdd10123e1feb0d6783
  6. Date: Mon, 25 Jan 1993 15:54:08 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: mgleason@cse.unl.edu (Michael Gleason)
  10. Posting-number: Volume 35, Issue 4
  11. Archive-name: ncftp/part01
  12. Environment: UNIX, ANSI-C, getopt
  13. Supersedes: ncftp: Volume 34, Issue 14-16
  14.  
  15. ncftp - Alternative user interface for FTP
  16. version 1.0 PL 2 by Mike Gleason, NCEMRSoft.
  17.  
  18. Changes from 1.0 PL 1:
  19.  
  20.   * ls is more flexible, so now you can do things like "ls -flags directory."
  21.     Previous versions of ncftp (and ftp) only allowed "ls -flags" or
  22.     "ls directory."
  23.  
  24.   * Some new progress meters, a fancy bargraph and another similar to the
  25.     original % meter that shows how many kilobytes have been transferred.
  26.     This meter is also used when the remote site doesn't support the SIZE
  27.     command, so you can always have a progress meter.
  28.  
  29.   * If you don't want ftp and ncftp to share an rc, you can use a '.ncftprc'
  30.     for ncftp and a '.netrc' for ftp.
  31.  
  32.   * Better portability; in addition to support for DG/UX, NeXT, and DYNIX,
  33.     the getpass2() function which was causing problems has been replaced
  34.     by a more portable version.  Also using a private getopt which can be
  35.     called more than once.
  36.  
  37.   * Syslog'ging capability added for system administrators.
  38.  
  39.   * So many small enhancements and bug fixes that the patch is almost as
  40.     large as the shar-chive.  See patchlevel.h for the gory details.
  41.  
  42.  
  43. ncftp was created out of disgust with using the regular 'ftp'
  44. command found on many brands of Unix.  People who spend a lot
  45. of time in ftp will want to install ncftp.
  46.  
  47. Features:
  48.  
  49.  * No more typing 'anonymous' and your email address every time
  50.    you want to ftp anonymously.  You don't need to have the
  51.    site in your .netrc.
  52.    
  53.  * No more typing complete site names.  Sites in your .netrc
  54.    can be abbreviated.  Type 'o wuar' to call wuarchive.wustl.edu.
  55.  
  56.  * Use your pager (like 'more') to read remote files (and also
  57.    compressed files).
  58.  
  59.  * Use your pager to view remote directory listings.
  60.  
  61.  * Transfers feature a progress meter.
  62.  
  63.  * Implicit cd.
  64.  
  65.  * Fancy prompts.
  66.  
  67.  * You can keep a log of your actions.  See what the path was of
  68.    that file you downloaded yesterday so you don't have to
  69.    look for it today.
  70.  
  71.  * Built-in mini-nslookup.
  72.  
  73.  * The 'ls' command is ls -CF.  Some ftp's ls was identical to 'dir.'
  74.  
  75.  * You can 'redial' a remote host until you connect.
  76.  
  77.  * Don't need to 'close' a site, just open a new one.
  78.  
  79.  * Don't feel like typing a long filename?  Use a wildcard in single
  80.    file commands like get and page.
  81.  
  82.  * You can create empty remote files.
  83.  
  84.  * Supports 'colon mode', so you can type 'ncftp cse.unl.edu:/pub/foo',
  85.    to copy foo into your current directory.
  86.  
  87.  * You can re-display the last directory listing without getting it
  88.    across the network.
  89.  
  90.  * Detects when new mail arrives.
  91.  
  92.  * ncftp is quieter by default -- who cares if the PORT command was
  93.    successful (if you do, turn verbose on :-).
  94.  
  95.  * It can be compiled to log transfers, etc., to the system log.
  96. -------------
  97. #! /bin/sh
  98. # This is a shell archive.  Remove anything before this line, then feed it
  99. # into a shell via "sh file" or similar.  To overwrite existing files,
  100. # type "sh file -c".
  101. # Contents:  cmds.c ftp.h
  102. # Wrapped by kent@sparky on Mon Jan 25 09:48:02 1993
  103. PATH=/bin:/usr/bin:/usr/ucb:/usr/local/bin:/usr/lbin ; export PATH
  104. echo If this archive is complete, you will see the following message:
  105. echo '          "shar: End of archive 1 (of 4)."'
  106. if test -f 'cmds.c' -a "${1}" != "-c" ; then 
  107.   echo shar: Will not clobber existing file \"'cmds.c'\"
  108. else
  109.   echo shar: Extracting \"'cmds.c'\" \(48279 characters\)
  110.   sed "s/^X//" >'cmds.c' <<'END_OF_FILE'
  111. X/* cmds.c */
  112. X
  113. X#include "sys.h"
  114. X#include <sys/types.h>
  115. X#include <sys/param.h>
  116. X
  117. X#include <sys/wait.h>
  118. X
  119. X#include <sys/stat.h>
  120. X#include <sys/socket.h>
  121. X#include <arpa/ftp.h>
  122. X#include <setjmp.h>
  123. X#include <signal.h>
  124. X#include <string.h>
  125. X#include <errno.h>
  126. X#include <netdb.h>
  127. X#include <netinet/in.h>
  128. X#include <arpa/inet.h>
  129. X#include <ctype.h>
  130. X#include <sys/time.h>
  131. X#include <time.h>
  132. X
  133. X#ifdef SYSLOG
  134. X#    include <syslog.h>
  135. X#endif
  136. X
  137. X#ifndef NO_UNISTDH
  138. X#    include <unistd.h>
  139. X#endif
  140. X
  141. X#include "ftpdefs.h"
  142. X#include "defaults.h"
  143. X#include "cmds.h"
  144. X#include "main.h"
  145. X#include "ftp.h"
  146. X#include "ftprc.h"
  147. X#include "getpass.h"
  148. X#include "glob.h"
  149. X#include "copyright.h"
  150. X
  151. X/* cmds.c globals */
  152. Xint                    curtype;            /* file transfer type */
  153. Xstr32                curtypename;        /* name of file transfer type */
  154. Xint                    verbose;            /* print messages coming back from server */
  155. Xint                    mprompt;            /* interactively prompt on m* cmds */
  156. Xint                    debug;                /* debugging level */
  157. Xint                    options;            /* used during socket creation */
  158. Xint                    macnum;                /* number of defined macros */
  159. Xint                    paging = 0;
  160. Xint                    creating = 0;
  161. Xstruct macel        macros[16];
  162. Xchar                *macbuf;            /* holds ALL macros */
  163. Xjmp_buf                jabort;
  164. Xchar                *mname;                /* name of current m* command */
  165. Xint                    activemcmd;            /* flag: if != 0, then active multi command */
  166. Xstring                cwd;                /* current remote directory */
  167. Xstring                lcwd;                /* current local directory */
  168. Xchar                lasthostname[64];    /* name of last host w/ lookup(). */
  169. Xint                    remote_is_unix;        /* TRUE if remote host is unix. */
  170. Xint                    auto_binary = dAUTOBINARY;    /* If TRUE, set binary each connection. */
  171. Xint                    Opterr = 1;            /* if error message should be printed */
  172. Xint                    Optind = 1;            /* index into parent argv vector */
  173. Xint                    Optopt;                /* character checked for validity */
  174. Xchar                *Optarg;            /* argument associated with option */
  175. Xchar                *Optplace = EMSG;    /* saved position in an arg */
  176. X
  177. X#ifdef REDIR
  178. Xint                            is_ls = 0;        /* are we doing an ls?  if so, then buffer */
  179. Xstruct lslist               *lshead = NULL;    /* hold last output from host */
  180. Xstruct lslist               *lstail = NULL;
  181. X#endif
  182. X
  183. X/* cmds.c externs */
  184. Xextern char                    *globerr, *home, *reply_string;
  185. Xextern int                    code, margc, connected, ansi_escapes;
  186. Xextern int                    connected, fromatty, data, progress_meter;
  187. Xextern int                    parsing_rc;
  188. Xextern char                    *altarg, *line, *margv[];
  189. Xextern char                    *globchars;
  190. Xextern string                hostname, progname, pager, anon_password;
  191. Xextern string                prompt, logfname, version;
  192. Xextern long                    logsize, eventnumber;
  193. Xextern size_t                xferbufsize;
  194. Xextern struct servent        *sp;
  195. Xextern struct cmd            cmdtab[];
  196. Xextern struct userinfo        uinfo;
  197. Xextern FILE                    *cin, *cout, *logf;
  198. Xextern int                    Optind;
  199. Xextern char                    *Optarg;
  200. Xextern int gethostname (char *, int);
  201. Xextern int ioctl (int, int, ...);
  202. X
  203. Xstruct var vars[] = {
  204. X    { "anon-password",        STR,    0,    anon_password,    (setvarproc) 0    },
  205. X    { "ansi-escapes",        INT,    0,    &ansi_escapes,    (setvarproc) 0    },
  206. X    { "auto-binary",        INT,    0,    &auto_binary,    (setvarproc) 0    },
  207. X    { "debug",                INT,    0,    &debug,            (setvarproc) 0    },
  208. X    { "local-dir",            STR,    0,    lcwd,            set_ldir         },
  209. X    { "logfile",            STR,    0,    logfname,        set_log            },
  210. X    { "logsize",            LONG,    0,    &logsize,        (setvarproc) 0    },
  211. X    { "mprompt",            INT,    0,    &mprompt,        (setvarproc) 0    },
  212. X    { "pager",                STR,    0,    pager + 1,        set_pager        },
  213. X    { "prompt",                STR,    0,    prompt,            set_prompt        },
  214. X    { "progress-reports",    INT,    0,    &progress_meter,(setvarproc) 0    },
  215. X    { "remote-is-unix",        INT,    1,    &remote_is_unix,(setvarproc) 0    },
  216. X    { "type",                STR,    1,    curtypename,    set_type        },
  217. X    { "verbose",            INT,    0,    &verbose,        set_verbose        }
  218. X};
  219. X
  220. Xstruct types types[] = {
  221. X    { "ascii",  "A",    TYPE_A, 0 },
  222. X    { "binary", "I",    TYPE_I, 0 },
  223. X    { "image",  "I",    TYPE_I, 0 },
  224. X    { "ebcdic", "E",    TYPE_E, 0 },
  225. X    { "tenex",  "L",    TYPE_L, "8" },
  226. X    0
  227. X};
  228. X
  229. X
  230. X
  231. Xvoid Getopt_Reset(void)
  232. X{
  233. X    Optind = 1;
  234. X    Optplace = "";
  235. X}    /* Getopt_Reset */
  236. X
  237. X
  238. X
  239. Xint Getopt(int nargc, char **nargv, char *ostr)
  240. X{
  241. X    register char *oli;                   /* Option letter list index */
  242. X
  243. X    if (!*Optplace) {                       /* update scanning pointer */
  244. X        if (Optind >= nargc || *(Optplace = nargv[Optind]) != '-')
  245. X            return (EOF);
  246. X        if (Optplace[1] && *++Optplace == '-') {    /* found "--" */
  247. X            ++Optind;
  248. X            return (EOF);
  249. X        }
  250. X    }                                   /* Option letter okay? */
  251. X    if ((Optopt = (int) *Optplace++) == (int) ':' ||
  252. X        !(oli = index(ostr, Optopt))) {
  253. X        if (!*Optplace)
  254. X            ++Optind;
  255. X        if (Opterr) {
  256. X            fprintf(stderr, "%s%s%c\n", *nargv, ": illegal option -- ", Optopt);
  257. X            return(BADCH);
  258. X        }
  259. X    }
  260. X    if (*++oli != ':') {               /* don't need argument */
  261. X        Optarg = NULL;
  262. X        if (!*Optplace)
  263. X            ++Optind;
  264. X    } else {                           /* need an argument */
  265. X        if (*Optplace)                       /* no white space */
  266. X            Optarg = Optplace;
  267. X        else if (nargc <= ++Optind) {  /* no arg */
  268. X            Optplace = EMSG;
  269. X            if (Opterr) {
  270. X                fprintf(stderr, "%s%s%c\n", *nargv, ": option requires an argument -- ", Optopt);
  271. X                return(BADCH);
  272. X            }
  273. X        } else                           /* white space */
  274. X            Optarg = nargv[Optind];
  275. X        Optplace = EMSG;
  276. X        ++Optind;
  277. X    }
  278. X    return (Optopt);                   /* dump back Option letter */
  279. X}                                       /* Getopt */
  280. X
  281. X
  282. X
  283. X
  284. Xchar *Gets(char *sline, size_t size)
  285. X{
  286. X    char *cp = fgets(sline, (int) (size - 1), stdin);
  287. X    if (cp != NULL) {
  288. X        cp += strlen(cp) - 1;
  289. X        if (*cp == '\n')
  290. X            *cp = 0;    /* get rid of the newline. */
  291. X    }
  292. X    return cp;
  293. X}    /* Gets */
  294. X
  295. X
  296. X
  297. X
  298. Xchar **re_makeargv(char *promptstr, int *argc)
  299. X{
  300. X    size_t sz;
  301. X
  302. X    (void) strcat(line, " ");
  303. X    (void) printf(promptstr);
  304. X    sz = strlen(line);
  305. X    (void) Gets(&line[sz], (size_t) (CMDLINELEN - sz)) ;
  306. X    (void) makeargv();
  307. X    *argc = margc;
  308. X    return (margv);
  309. X}    /* re_makeargv */
  310. X
  311. X
  312. X
  313. X
  314. Xchar *get_cwd(char *buf, int size)
  315. X{
  316. X#ifdef SYSV
  317. X#    ifdef NO_UNISTDH
  318. X#        ifdef GETCWDSIZET
  319. X    extern char *getcwd(char *, size_t);
  320. X#        else
  321. X    extern char *getcwd(char *, int);
  322. X#        endif
  323. X#    endif
  324. X    return (getcwd(buf, size - 1));
  325. X#else
  326. X    extern char *getwd(char *);
  327. X    return (getwd(buf));
  328. X#endif
  329. X}   /* get_cwd */
  330. X
  331. X/*
  332. X * Connect to peer server and
  333. X * auto-login, if possible.
  334. X */
  335. X
  336. Xint setpeer(int argc, char **argv)
  337. X{
  338. X    char                *path;
  339. X    unsigned int        port;
  340. X    time_t                now;
  341. X    int                    openmode = 1, tmpverbose, opt, hErr;
  342. X    int                    redial_delay = dREDIALDELAY;
  343. X    int                    ignore_rc = 0, dials, max_dials = 1;
  344. X    string                pathname, newhost;
  345. X    char                *cmdname = argv[0];
  346. X
  347. X    port = sp->s_port;
  348. X    Getopt_Reset();
  349. X    while ((opt = Getopt(argc, argv, "aiup:rd:g:")) >= 0) {
  350. X        switch (opt) {
  351. X            case 'a': openmode = OPEN_A; break;
  352. X            case 'u': openmode = OPEN_U; break;
  353. X            case 'i': ignore_rc = 1; break;
  354. X            case 'p':
  355. X                port = atoi(Optarg);
  356. X                if (port <= 0) {
  357. X                    (void) printf("%s: bad port number (%s).\n", cmdname, Optarg);
  358. X                    goto usage;
  359. X                }
  360. X                port = htons(port);
  361. X                break;
  362. X            case 'd': redial_delay = atoi(Optarg); break;
  363. X            case 'g': max_dials = atoi(Optarg);  break;
  364. X            case 'r': max_dials = -1; break;
  365. X            default:
  366. X            usage:
  367. X                (void) printf("usage: %s [-a | -u] [-i] [-p N] [-r [-d N] [-g N]] hostname[:pathname]\n\
  368. X    -a     : Open anonymously (this is the default).\n\
  369. X    -u     : Open, specify user/password.\n\
  370. X    -i     : Ignore machine entry in your .netrc.\n\
  371. X    -p N   : Use port #N for connection.\n\
  372. X    -r     : \"Redial\" until connected.\n\
  373. X    -d N   : Redial, pausing N seconds between tries.\n\
  374. X    -g N   : Redial, giving up after N tries.\n\
  375. X    :path  : Open site, then retrieve file \"path.\"\n", cmdname);
  376. X                code = -1;
  377. X                return;
  378. X        }
  379. X    }
  380. X
  381. X    if (argv[Optind] == NULL)
  382. X        goto usage;
  383. X    (void) Strncpy(newhost, argv[Optind]);
  384. X    if (connected) {
  385. X        if (NOT_VQUIET && hostname != NULL)
  386. X            (void) printf("Closing %s...\n", hostname);
  387. X        (void) disconnect(0, NULL);
  388. X    }
  389. X
  390. X    /*
  391. X     *    If we are given something like wuarchive.wustl.edu:/pub/foo,
  392. X     *    try to connect to the site then first try to cd to /pub/foo,
  393. X     *    or if that fails, assume it is a file then try to fetch
  394. X     *    /pub/foo and write foo in the current local directory.
  395. X     */
  396. X    if ((path = index(newhost, ':')) != NULL) {
  397. X        *path++ = 0;
  398. X        (void) Strncpy(pathname, path);
  399. X    }
  400. X
  401. X    GetFullSiteName(newhost);
  402. X    for (dials = 0; max_dials < 0 || dials < max_dials; dials++) {
  403. X        if (dials > 0) {
  404. X            (void) sleep(redial_delay);
  405. X            (void) fprintf(stderr, "Retry Number: %d\n", dials + 1);
  406. X        }
  407. X        hErr = hookup(newhost, port);
  408. X        if (hErr == -2)        /* Recoverable, so we can try again. */
  409. X            continue;
  410. X        else if (hErr == 0) {
  411. X            connected = 1;
  412. X            tmpverbose = verbose;
  413. X            if (debug == 0)
  414. X                verbose = V_QUIET;
  415. X            remote_is_unix = 1;
  416. X            if (command("SYST") == COMPLETE) {
  417. X                if (tmpverbose == V_VERBOSE) {
  418. X                    register char *cp, c;
  419. X                    cp = index(reply_string+4, ' ');
  420. X                    if (cp == NULL)
  421. X                        cp = index(reply_string+4, '\r');
  422. X                    if (cp) {
  423. X                        if (cp[-1] == '.')
  424. X                            cp--;
  425. X                        c = *cp;
  426. X                        *cp = '\0';
  427. X                    }
  428. X    
  429. X                    (void) printf("Remote system type is %s.\n",
  430. X                        reply_string+4);
  431. X                    if (cp)
  432. X                        *cp = c;
  433. X                }
  434. X                remote_is_unix = !strncmp(reply_string + 4, "UNIX", (size_t) 4);
  435. X            }
  436. X    
  437. X            if (auto_binary || path || !strncmp(reply_string, "215 UNIX Type: L8", (size_t) 17)) {
  438. X                _settype("binary");
  439. X                if (tmpverbose > V_TERSE)
  440. X                    (void) printf("Using %s mode to transfer files.\n", curtypename);
  441. X            }
  442. X            if (tmpverbose >= V_ERRS && 
  443. X                !strncmp(reply_string, "215 TOPS20", (size_t) 10)) {
  444. X                (void) printf(
  445. X    "Remember to set tenex mode when transfering _binary_ files from this machine.\n");
  446. X            }
  447. X            verbose = tmpverbose;
  448. X
  449. X            if (!login(newhost, openmode, ignore_rc) || cout == NULL)
  450. X                goto nextdial;        /* error! */
  451. X            if (logf != NULL) {
  452. X                (void) time(&now);
  453. X                (void) fprintf(logf, "%s opened at %s",
  454. X                    hostname,
  455. X                    ctime(&now));
  456. X            }
  457. X
  458. X            /* Freshen 'cwd' variable for the prompt. */
  459. X            (void) _cd(NULL);
  460. X            if (path != NULL) {
  461. X                if (! _cd(pathname)) {
  462. X                    /* Couldn't cd to this path, must be a file then. */
  463. X                    (void) sprintf(line, "get %s", pathname);
  464. X                    makeargv();
  465. X                    (void) get(margc, margv);
  466. X                    /* If we were invoked from the command line, quit
  467. X                     * after we got this file.
  468. X                     */
  469. X                    if (eventnumber == 0L) {
  470. X                        (void) quit(0, NULL);
  471. X                    }
  472. X                }
  473. X            }
  474. X            break;
  475. X            /* end if we are connected */
  476. X        } else {
  477. X            /* Irrecoverable error, so don't bother redialing. */
  478. X            break;
  479. X        }
  480. Xnextdial: continue;
  481. X    }
  482. X}    /* setpeer */
  483. X
  484. X
  485. X/*
  486. X * Set transfer type.
  487. X */
  488. Xint settype(int argc, char **argv)
  489. X{
  490. X    if (argc > 2) {
  491. X        (void) printf("usage: %s [ ascii | binary | ebcdic | image | tenex ]\n", argv[0]);
  492. X        code = -1;
  493. X        return;
  494. X    }
  495. X    code = 0;
  496. X    if (argc < 2) {
  497. Xxx:        (void) printf("Using %s mode to transfer files.\n", curtypename);
  498. X        return;
  499. X    }
  500. X    _settype(argv[1]);
  501. X    if (IS_VVERBOSE)
  502. X        goto xx;
  503. X}    /* settype */
  504. X
  505. X
  506. X
  507. X
  508. Xvoid _settype(char *typename)
  509. X{
  510. X    register struct types    *p;
  511. X    int                        comret, i;
  512. X    string                    cmd;
  513. X 
  514. X    *cmd = 0;
  515. X    switch (isupper(*typename) ? tolower(*typename) : (*typename)) {
  516. X        case 'a': i = 0; break;
  517. X        case 'b': i = 1; break;
  518. X        case 'i': i = 2; break;
  519. X        case 'e': i = 3; break;
  520. X        case 't': i = 4;
  521. X            (void) strcpy(cmd, "TYPE L 8");
  522. X            break;
  523. X        default:
  524. X            (void) printf("%s: unknown type\n", typename);
  525. X            code = -1;
  526. X            return;
  527. X    }
  528. X    p = &types[i];
  529. X    if (*cmd == 0)
  530. X        (void) sprintf(cmd, "TYPE %s", p->t_mode);
  531. X    comret = command(cmd);
  532. X    if (comret == COMPLETE) {
  533. X        (void) Strncpy(curtypename, p->t_name);
  534. X        curtype = p->t_type;
  535. X    }
  536. X}    /* _settype */
  537. X
  538. X
  539. X
  540. X
  541. X/*ARGSUSED*/
  542. Xint setbinary(int argc, char **argv) {    _settype("binary");    }
  543. X/*ARGSUSED*/
  544. Xint setascii(int argc, char **argv) {    _settype("ascii");    }
  545. X
  546. X
  547. X
  548. Xchar *verbose_msgs[] = {
  549. X    "Only printing necessary error messages.\n",
  550. X    "Printing error messages and announcements from the remote host.\n",
  551. X    "Printing all messages, errors, acknowledgments, and announcements.\n"
  552. X};
  553. X
  554. Xvoid set_verbose(char *new, int unset)
  555. X{
  556. X    int i;
  557. X
  558. X    if (unset == -1) verbose = !verbose;
  559. X    else if (unset || !new || !*new) verbose = V_ERRS;
  560. X    else {
  561. X        i = StrToBool(new);
  562. X        if (i < V_QUIET) i = V_QUIET;
  563. X        else if (i > V_VERBOSE) i = V_VERBOSE;
  564. X        verbose = i;
  565. X    }
  566. X    if (!parsing_rc && NOT_VQUIET) 
  567. X        fputs(verbose_msgs[verbose], stdout);
  568. X}    /* set_verbose */
  569. X
  570. X
  571. X
  572. X
  573. Xvoid set_prompt(char *new, int unset)
  574. X{
  575. X    (void) Strncpy(prompt, (unset || !new || !*new) ? dPROMPT : new);
  576. X    init_prompt();
  577. X}    /* set_prompt */
  578. X
  579. X
  580. X
  581. X
  582. Xvoid set_log(char *fname, int unset)
  583. X{
  584. X    if (logf) {
  585. X        (void) fclose(logf);
  586. X        logf = NULL;
  587. X    }
  588. X    if (!unset && fname && *fname) {
  589. X        (void) Strncpy(logfname, fname);
  590. X        logf = fopen (logfname, "a");
  591. X    }
  592. X}    /* set_log */
  593. X
  594. X
  595. X
  596. X
  597. Xvoid set_pager(char *new, int unset)
  598. X{
  599. X    if (unset)
  600. X        (void) strcpy(pager, "-");
  601. X    else {
  602. X        if (!new)
  603. X            new = dPAGER;
  604. X        if (!*new)
  605. X            (void) strcpy(pager, "-");
  606. X        else if (*new != '-')
  607. X            (void) sprintf(pager, "|%s", (*new == '|' ? new + 1 : new));
  608. X    }
  609. X}    /* set_pager */
  610. X
  611. X
  612. X
  613. X
  614. Xvoid set_type(char *newtype, int unset)
  615. X{
  616. X    int t = verbose;
  617. X    verbose = V_QUIET;
  618. X    if (!connected && t > V_QUIET)
  619. X        (void) printf("Not connected.\n");
  620. X    else
  621. X        _settype(newtype && !unset ? newtype : "image");
  622. X    verbose = t;
  623. X}    /* set_type */
  624. X
  625. X
  626. X
  627. X
  628. Xvoid set_ldir(char *ldir, int unset)
  629. X{
  630. X    int t = verbose;
  631. X    char *argv[2];
  632. X
  633. X    if (ldir && !unset) {
  634. X        verbose = V_QUIET;
  635. X        argv[1] = ldir;
  636. X        lcd(2, argv);
  637. X        verbose = t;
  638. X    }
  639. X}    /* set_ldir */
  640. X
  641. X
  642. X
  643. X
  644. Xint set(int argc, char **argv)
  645. X{
  646. X    int unset, i, c;
  647. X    struct var *v;
  648. X    char *var, *val = NULL;
  649. X
  650. X    if (argc < 2 || strncmp(argv[1], "all", (size_t)3) == 0) {
  651. X        /* Show all variables. */
  652. X        for (i=0; i<sizeof(vars)/sizeof(struct var); i++) {
  653. X            (void) printf("%-20s= ", vars[i].name);
  654. X            c = vars[i].type;
  655. X            if (c < 0) c = -c;
  656. X            if (vars[i].conn_required && !connected)
  657. X                (void) printf("(not connected)\n");
  658. X            else switch (c) {
  659. X                case INT:
  660. X                    (void) printf("%d\n", *(int *)vars[i].var); break;
  661. X                case LONG:
  662. X                    (void) printf("%ld\n", *(long *)vars[i].var); break;
  663. X                case STR:
  664. X                    (void) printf("\"%s\"\n", (char *) vars[i].var); break;
  665. X            }
  666. X        }
  667. X    } else {
  668. X        unset = argv[0][0] == 'u';
  669. X        var = argv[1];
  670. X        if (argc == 2)
  671. X            val = NULL;
  672. X        else if (argc > 2) {
  673. X            /* could be =, value or just value. */
  674. X            if (*argv[2] == '=') {
  675. X                if (argc > 3)
  676. X                    val = argv[3];
  677. X                else return;    /* can't do 'set var =' */
  678. X            } else
  679. X                val = argv[2];
  680. X        }
  681. X        for (i=0, v=NULL; i<sizeof(vars)/sizeof(struct var); i++) {
  682. X            if (strncmp(vars[i].name, var, sizeof(vars[i].name)) == 0) {
  683. X                v = &vars[i];
  684. X                break;
  685. X            }
  686. X        }
  687. X        if (v == NULL) 
  688. X            (void) fprintf(stderr, "%s: unknown variable.\n", var);
  689. X        else {
  690. X            if (v->conn_required && !connected)
  691. X                (void) fprintf(stderr, "%s: must be connected.\n", var);
  692. X            else if (v->type < 0)    
  693. X                (void) fprintf(stderr, "%s: read-only variable.\n", var);
  694. X            else if (v->proc != (setvarproc) 0)
  695. X                (*v->proc)(val, unset);        /* a custom set proc. */
  696. X            else if (unset) switch(v->type) {
  697. X                case INT:
  698. X                    *(int *) v->var = 0; break;
  699. X                case LONG:
  700. X                    *(long *) v->var = 0; break;
  701. X                case STR:
  702. X                    *(char *) v->var = 0; break;
  703. X            } else {
  704. X                if (val == NULL) switch(v->type) {
  705. X                    /* User just said "set varname" */
  706. X                    case INT:
  707. X                        *(int *) v->var = 1; break;
  708. X                    case LONG:
  709. X                        *(long *) v->var = 1; break;
  710. X                    case STR:
  711. X                        *(char *) v->var = 0; break;
  712. X                } else {
  713. X                    /* User said "set varname = value" */
  714. X                    switch (v->type) {
  715. X                        case INT:
  716. X                            (void) sscanf(val, "%d", (int *) v->var); break;
  717. X                        case LONG:
  718. X                            (void) sscanf(val, "%ld", (long *) v->var); break;
  719. X                        case STR:
  720. X                            (void) strcpy(v->var, val); break;
  721. X                    }
  722. X                }
  723. X            }
  724. X        }
  725. X    }
  726. X}    /* set */
  727. X
  728. X
  729. X
  730. X
  731. X/*
  732. X * Send a single file.
  733. X */
  734. Xint put(int argc, char **argv)
  735. X{
  736. X    char *cmd;
  737. X    char *oldargv1;
  738. X
  739. X    if (argc == 2) {
  740. X        argc++;
  741. X        argv[2] = argv[1];
  742. X    }
  743. X    if (argc < 2)
  744. X        argv = re_makeargv("(local-file) ", &argc);
  745. X    if (argc < 2) {
  746. Xusage:
  747. X        (void) printf("usage:%s local-file remote-file\n", argv[0]);
  748. X        code = -1;
  749. X        return;
  750. X    }
  751. X    if (argc < 3)
  752. X        argv = re_makeargv("(remote-file) ", &argc);
  753. X    if (argc < 3) 
  754. X        goto usage;
  755. X    oldargv1 = argv[1];
  756. X    if (!globulize(&argv[1])) {
  757. X        code = -1;
  758. X        return;
  759. X    }
  760. X    /*
  761. X     * If "globulize" modifies argv[1], and argv[2] is a copy of
  762. X     * the old argv[1], make it a copy of the new argv[1].
  763. X     */
  764. X    if (argv[1] != oldargv1 && argv[2] == oldargv1) {
  765. X        argv[2] = argv[1];
  766. X    }
  767. X    cmd = (argv[0][0] == 'a') ? "APPE" : "STOR";
  768. X    sendrequest(cmd, argv[1], argv[2]);
  769. X}    /* put */
  770. X
  771. X
  772. X
  773. X
  774. X/*
  775. X * Send multiple files.
  776. X */
  777. Xint mput(int argc, char **argv)
  778. X{
  779. X    register int i;
  780. X    void (*oldintr)(int);
  781. X    char *tp;
  782. X
  783. X    if (argc < 2)
  784. X        argv = re_makeargv("(local-files) ", &argc);
  785. X    if (argc < 2) {
  786. X        (void) printf("usage:%s local-files\n", argv[0]);
  787. X        code = -1;
  788. X        return;
  789. X    }
  790. X    mname = argv[0];
  791. X    activemcmd = 1;
  792. X    oldintr = signal(SIGINT, (void (*)(int)) mabort);
  793. X    (void) setjmp(jabort);
  794. X    for (i = 1; i < argc; i++) {
  795. X        register char **cpp, **gargs;
  796. X
  797. X        gargs = glob(argv[i]);
  798. X        if (globerr != NULL) {
  799. X            (void) printf("%s\n", globerr);
  800. X            if (gargs) {
  801. X                blkfree(gargs);
  802. X                free(gargs);
  803. X            }
  804. X            continue;
  805. X        }
  806. X        for (cpp = gargs; cpp && *cpp != NULL; cpp++) {
  807. X            if (activemcmd && confirm(argv[0], *cpp)) {
  808. X                tp = *cpp;
  809. X                sendrequest("STOR", *cpp, tp);
  810. X                if (!activemcmd && fromatty) {
  811. X                    if (confirm("Continue with","mput")) {
  812. X                        activemcmd++;
  813. X                    }
  814. X                }
  815. X            }
  816. X        }
  817. X        if (gargs != NULL) {
  818. X            blkfree(gargs);
  819. X            free(gargs);
  820. X        }
  821. X    }
  822. X    (void) signal(SIGINT, oldintr);
  823. X    activemcmd = 0;
  824. X}    /* mput */
  825. X
  826. X
  827. X
  828. Xint tmp_name(char *str)
  829. X{
  830. X    (void) strcpy(str, "/tmp/ncftpXXXXXX");
  831. X    return (mktemp(str) == NULL);
  832. X}    /* tmp_name */
  833. X
  834. X
  835. X
  836. X
  837. Xint rem_glob_one(char *pattern)
  838. X{
  839. X    int            oldverbose, result = 0;
  840. X    char        *cp;
  841. X    string        str, tname;
  842. X    FILE        *ftemp;
  843. X
  844. X    /* Check for wildcard characters. */
  845. X    if (*pattern == '|' || strpbrk(pattern, globchars) == NULL)
  846. X        return 0;
  847. X
  848. X    (void) tmp_name(tname);
  849. X    oldverbose = verbose;
  850. X    verbose = V_QUIET;
  851. X    recvrequest ("NLST", tname, pattern, "w");
  852. X    verbose = oldverbose;
  853. X    ftemp = fopen(tname, "r");
  854. X    if (ftemp == NULL || FGets(str, ftemp) == NULL) {
  855. X        if (NOT_VQUIET)
  856. X            (void) printf("%s: no match.\n", pattern);
  857. X        result = -1;
  858. X        goto done;
  859. X    }
  860. X    if ((cp = index(str, '\n')) != NULL)
  861. X        *cp = '\0';
  862. X    (void) strcpy(pattern, str);
  863. X    cp = FGets(str, ftemp);
  864. X    /* It is an error if the pattern matched more than one file. */
  865. X    if (cp != NULL) {
  866. X        if (NOT_VQUIET)
  867. X            (void) printf("?Ambiguous remote file name.\n");
  868. X        result = -2;
  869. X    }
  870. Xdone:
  871. X    if (ftemp != NULL)
  872. X        (void) fclose(ftemp);
  873. X    (void) unlink(tname);
  874. X    return (result);
  875. X}    /* rem_glob_one */
  876. X
  877. X
  878. X
  879. X
  880. X/*
  881. X * Receive (and maybe page) one file.
  882. X */
  883. Xint get(int argc, char **argv)
  884. X{
  885. X    string local_file;
  886. X    string remote_file;
  887. X
  888. X    /* paging mode is set if the command name is 'page' or 'more.' */
  889. X    paging = (**argv != 'g');
  890. X
  891. X    if (argc < 2)
  892. X        argv = re_makeargv("(remote-file) ", &argc);
  893. X
  894. X    if (argc < 2) {
  895. X        if (paging)
  896. X            (void) printf("usage: %s remote-file\n", argv[0]);
  897. X        else {
  898. Xgetusage:
  899. X                (void) printf("usage: %s remote-file [local-file]\n", argv[0]);
  900. X        }
  901. X        return;
  902. X    }
  903. X    argv[1] = Strncpy(remote_file, argv[1]);
  904. X    if (rem_glob_one(argv[1]) < 0)
  905. X        return;
  906. X
  907. X    if (paging) {
  908. X        size_t len = strlen(remote_file);
  909. X
  910. X        /* Run compressed remote files through zcat, then the pager. */
  911. X        if (strlen(remote_file) > 2 && remote_file[len - 1] == 'Z' && remote_file[len - 2] == '.') {
  912. X            _settype("b");
  913. X            (void) sprintf(local_file, "|%s", ZCAT);
  914. X            argv[2] = Strncat(local_file, pager);
  915. X        } else
  916. X            argv[2] = pager;
  917. X    } else {
  918. X        /* normal get */
  919. X        if (argc == 2) {
  920. X            (void) Strncpy(local_file, argv[1]);
  921. X            argv[2] = local_file;
  922. X        } else {
  923. X            if (argc < 3)
  924. X                argv = re_makeargv("(local-file) ", &argc);
  925. X            if (argc < 3) 
  926. X                goto getusage;
  927. X            if (!globulize(&argv[2])) {
  928. X                code = -1;
  929. X                return;
  930. X            }
  931. X        }
  932. X    }
  933. X    recvrequest("RETR", argv[2], argv[1], "w");
  934. X    paging = 0;
  935. X}    /* get */
  936. X
  937. X
  938. X
  939. X/*ARGSUSED*/
  940. Xvoid mabort(int unused)
  941. X{
  942. X    (void) printf("\n");
  943. X    (void) fflush(stdout);
  944. X    if (activemcmd && fromatty) {
  945. X        if (confirm("Continue with", mname)) {
  946. X            longjmp(jabort,0);
  947. X        }
  948. X    }
  949. X    activemcmd = 0;
  950. X    longjmp(jabort,0);
  951. X}    /* mabort */
  952. X
  953. X
  954. X
  955. X
  956. X/*
  957. X * Get multiple files.
  958. X */
  959. Xint mget(int argc, char **argv)
  960. X{
  961. X    char *cp, *tp;
  962. X    void (*oldintr)(int);
  963. X
  964. X    if (argc < 2)
  965. X        argv = re_makeargv("(remote-files) ", &argc);
  966. X    if (argc < 2) {
  967. X        (void) printf("usage:%s remote-files\n", argv[0]);
  968. X        code = -1;
  969. X        return;
  970. X    }
  971. X    mname = argv[0];
  972. X    activemcmd = 1;
  973. X    oldintr = signal(SIGINT,mabort);
  974. X    (void) setjmp(jabort);
  975. X    while ((cp = remglob(argv)) != NULL) {
  976. X        if (*cp == '\0') {
  977. X            activemcmd = 0;
  978. X            continue;
  979. X        }
  980. X        if (activemcmd && confirm(argv[0], cp)) {
  981. X            tp = cp;
  982. X            recvrequest("RETR", tp, cp, "w");
  983. X            if (!activemcmd && fromatty) {
  984. X                if (confirm("Continue with","mget")) {
  985. X                    activemcmd++;
  986. X                }
  987. X            }
  988. X        }
  989. X    }
  990. X    (void) signal(SIGINT,oldintr);
  991. X    activemcmd = 0;
  992. X}    /* mget */
  993. X
  994. X
  995. X
  996. X
  997. Xchar *remglob(char *argv[])
  998. X{
  999. X    static FILE            *ftemp = NULL;
  1000. X    int                    oldverbose;
  1001. X    char                *cp, *mode;
  1002. X    static string        tmpname, str;
  1003. X
  1004. X    if (!activemcmd) {
  1005. Xxx:
  1006. X        if (ftemp) {
  1007. X            (void) fclose(ftemp);
  1008. X            ftemp = NULL;
  1009. X            (void) unlink(tmpname);
  1010. X        }
  1011. X        return(NULL);
  1012. X    }
  1013. X    if (ftemp == NULL) {
  1014. X        (void) tmp_name(tmpname);
  1015. X        oldverbose = verbose, verbose = V_QUIET;
  1016. X        for (mode = "w"; *++argv != NULL; mode = "a")
  1017. X            recvrequest ("NLST", tmpname, *argv, mode);
  1018. X        verbose = oldverbose;
  1019. X        ftemp = fopen(tmpname, "r");
  1020. X        if (ftemp == NULL) {
  1021. X            (void) printf("Can't find list of remote files (%s), oops.\n", tmpname);
  1022. X            return (NULL);
  1023. X        }
  1024. X    }
  1025. X    if (FGets(str, ftemp) == NULL) 
  1026. X        goto xx;
  1027. X    if ((cp = index(str, '\n')) != NULL)
  1028. X        *cp = '\0';
  1029. X    return (str);
  1030. X}    /* remglob */
  1031. X
  1032. X
  1033. X
  1034. X
  1035. Xchar *
  1036. Xonoff(int boolf)
  1037. X{
  1038. X    return (boolf ? "on" : "off");
  1039. X}   /* onoff */
  1040. X
  1041. X
  1042. X
  1043. X
  1044. Xint
  1045. XStrToBool(char *s)
  1046. X{
  1047. X    register char c;
  1048. X
  1049. X    c = *s | 32;            /* lcase(*value) */
  1050. X    switch (c) {
  1051. X        case 'f':           /* false */
  1052. X            return (0);
  1053. X        case 'o':           /* test for "off" and "on" */
  1054. X            c = s[1] | 32;
  1055. X            return(c == 'f' ? 0 : 1);
  1056. X        case 't':           /* true */
  1057. X            return (1);
  1058. X        default:            /* 1, 0, -1, other number? */
  1059. X            return (atoi(s));
  1060. X    }
  1061. X}   /* StrToBool */
  1062. X
  1063. X
  1064. X/*
  1065. X * Turn on/off printing of server echo's, messages, and statistics.
  1066. X */
  1067. Xint setverbose(int argc, char **argv)
  1068. X{
  1069. X    if (argc > 1)
  1070. X        set_verbose(argv[1], 0);
  1071. X    else set_verbose(argv[1], -1);
  1072. X    code = verbose;
  1073. X}    /* setverbose */
  1074. X
  1075. X
  1076. X
  1077. X/*
  1078. X * Toggle interactive prompting
  1079. X * during mget, mput, and mdelete.
  1080. X */
  1081. Xint setprompt(int argc, char **argv)
  1082. X{
  1083. X    if (argc > 1)
  1084. X        mprompt = StrToBool(argv[1]);
  1085. X    else mprompt = !mprompt;
  1086. X    if (IS_VVERBOSE)
  1087. X        (void) printf("Interactive prompting for m* commmands %s.\n", onoff(mprompt));
  1088. X    code = mprompt;
  1089. X}    /* setprompt */
  1090. X
  1091. X
  1092. X/*
  1093. X * Set debugging mode on/off and/or
  1094. X * set level of debugging.
  1095. X */
  1096. Xint setdebug(int argc, char **argv)
  1097. X{
  1098. X    int val;
  1099. X
  1100. X    if (argc > 1) {
  1101. X        val = StrToBool(argv[1]);
  1102. X        if (val < 0) {
  1103. X            (void) printf("%s: bad debugging value.\n", argv[1]);
  1104. X            code = -1;
  1105. X            return;
  1106. X        }
  1107. X    } else
  1108. X        val = !debug;
  1109. X    debug = val;
  1110. X    fix_options();
  1111. X    if (IS_VVERBOSE)
  1112. X        (void) printf("Debugging %s (debug=%d).\n", onoff(debug), debug);
  1113. X    code = debug > 0;
  1114. X}    /* debug */
  1115. X
  1116. X
  1117. X
  1118. Xvoid fix_options(void)
  1119. X{
  1120. X    if (debug)
  1121. X        options |= SO_DEBUG;
  1122. X    else
  1123. X        options &= ~SO_DEBUG;
  1124. X}    /* fix_options */
  1125. X
  1126. X
  1127. X
  1128. X/*
  1129. X * Set current working directory
  1130. X * on remote machine.
  1131. X */
  1132. Xint cd(int argc, char **argv)
  1133. X{
  1134. X    if (argc < 2)
  1135. X        argv = re_makeargv("(remote-directory) ", &argc);
  1136. X    if (argc < 2) {
  1137. X        (void) printf("usage:%s remote-directory\n", argv[0]);
  1138. X        code = -1;
  1139. X        return;
  1140. X    }
  1141. X    (void) _cd(argv[1]);
  1142. X}    /* cd */
  1143. X
  1144. X
  1145. X
  1146. X
  1147. Xint implicit_cd(char *dir)
  1148. X{
  1149. X    int i, j = 0;
  1150. X    
  1151. X    if (connected) {
  1152. X        i = verbose;
  1153. X        /* Special verbosity level that ignores errors and prints other stuff,
  1154. X         * so you will get just the unknown command message and not an error
  1155. X         * message from cd.
  1156. X         */
  1157. X        verbose = V_IMPLICITCD;
  1158. X        j = _cd(dir);
  1159. X        verbose = i;
  1160. X    }
  1161. X    return j;
  1162. X}    /* implicit_cd */
  1163. X
  1164. X
  1165. X
  1166. X
  1167. Xint _cd(char *dir)
  1168. X{
  1169. X    register char *cp;
  1170. X    int result = 0, tmpverbose;
  1171. X    string str;
  1172. X
  1173. X    if (dir == NULL)
  1174. X        goto getrwd;
  1175. X    /* Won't work because glob really is a ls, so 'cd pu*' will match
  1176. X     * pub/README, pub/file2, etc.
  1177. X     *    if (result = rem_glob_one(dir) < 0)
  1178. X     *    return result;
  1179. X     */
  1180. X    if (strncmp(dir, "CDUP", (size_t) 4) == 0)
  1181. X        (void) Strncpy(str, dir);
  1182. X    else
  1183. X        (void) sprintf(str, "CWD %s", dir);
  1184. X    if (command(str) != 5) {
  1185. Xgetrwd:
  1186. X        /* (void) Strncpy(cwd, dir); */
  1187. X        tmpverbose = verbose; verbose = V_QUIET;
  1188. X        (void) command("PWD");
  1189. X        verbose = tmpverbose;
  1190. X        cp = rindex(reply_string, '\"');
  1191. X        if (cp != NULL) {
  1192. X            result = 1;
  1193. X            *cp = '\0';
  1194. X            cp = index(reply_string, '\"');
  1195. X            if (cp != NULL)
  1196. X                (void) Strncpy(cwd, ++cp);
  1197. X        }
  1198. X    }
  1199. X    if (debug > 0)
  1200. X        (void) printf("---> Current remote directory is \"%s\"\n", cwd);
  1201. X    return (result);
  1202. X}    /* _cd */
  1203. X
  1204. X
  1205. X
  1206. X
  1207. X/*
  1208. X * Set current working directory
  1209. X * on local machine.
  1210. X */
  1211. Xint lcd(int argc, char **argv)
  1212. X{
  1213. X    if (argc < 2)
  1214. X        argc++, argv[1] = home;
  1215. X    if (argc != 2) {
  1216. X        (void) printf("usage:%s local-directory\n", argv[0]);
  1217. X        code = -1;
  1218. X        return;
  1219. X    }
  1220. X    if (!globulize(&argv[1])) {
  1221. X        code = -1;
  1222. X        return;
  1223. X    }
  1224. X    if (chdir(argv[1]) < 0) {
  1225. X        Perror(argv[1]);
  1226. X        code = -1;
  1227. X        return;
  1228. X    }
  1229. X    (void) get_cwd(lcwd, (int) sizeof(lcwd));
  1230. X    if (IS_VVERBOSE) 
  1231. X        (void) printf("Local directory now %s\n", lcwd);
  1232. X    code = 0;
  1233. X}    /* lcd */
  1234. X
  1235. X
  1236. X
  1237. X
  1238. X/*
  1239. X * Delete a single file.
  1240. X */
  1241. Xint do_delete(int argc, char **argv)
  1242. X{
  1243. X    string str;
  1244. X
  1245. X    if (argc < 2)
  1246. X        argv = re_makeargv("(remote file to delete) ", &argc);
  1247. X    if (argc < 2) {
  1248. X        (void) printf("usage:%s remote-file\n", argv[0]);
  1249. X        code = -1;
  1250. X        return;
  1251. X    }
  1252. X    if (rem_glob_one(argv[1]) == 0) {
  1253. X        (void) sprintf(str, "DELE %s", argv[1]);
  1254. X        (void) command(str);
  1255. X    }
  1256. X}    /* do_delete */
  1257. X
  1258. X
  1259. X
  1260. X
  1261. X/*
  1262. X * Delete multiple files.
  1263. X */
  1264. Xint mdelete(int argc, char **argv)
  1265. X{
  1266. X    char *cp;
  1267. X    void (*oldintr)(int);
  1268. X    string str;
  1269. X
  1270. X    if (argc < 2)
  1271. X        argv = re_makeargv("(remote-files) ", &argc);
  1272. X    if (argc < 2) {
  1273. X        (void) printf("usage:%s remote-files\n", argv[0]);
  1274. X        code = -1;
  1275. X        return;
  1276. X    }
  1277. X    mname = argv[0];
  1278. X    activemcmd = 1;
  1279. X    oldintr = signal(SIGINT, mabort);
  1280. X    (void) setjmp(jabort);
  1281. X    while ((cp = remglob(argv)) != NULL) {
  1282. X        if (*cp == '\0') {
  1283. X            activemcmd = 0;
  1284. X            continue;
  1285. X        }
  1286. X        if (activemcmd && confirm(argv[0], cp)) {
  1287. X            (void) sprintf(str, "DELE %s", cp);
  1288. X            (void) command(str);
  1289. X            if (!activemcmd && fromatty) {
  1290. X                if (confirm("Continue with", "mdelete")) {
  1291. X                    activemcmd++;
  1292. X                }
  1293. X            }
  1294. X        }
  1295. X    }
  1296. X    (void) signal(SIGINT, oldintr);
  1297. X    activemcmd = 0;
  1298. X}    /* mdelete */
  1299. X
  1300. X
  1301. X
  1302. X
  1303. X/*
  1304. X * Rename a remote file.
  1305. X */
  1306. Xint renamefile(int argc, char **argv)
  1307. X{
  1308. X    string str;
  1309. X
  1310. X    if (argc < 2)
  1311. X        argv = re_makeargv("(from-name) ", &argc);
  1312. X    if (argc < 2) {
  1313. Xusage:
  1314. X        (void) printf("%s from-name to-name\n", argv[0]);
  1315. X        code = -1;
  1316. X        return;
  1317. X    }
  1318. X    if (argc < 3)
  1319. X        argv = re_makeargv("(to-name) ", &argc);
  1320. X    if (argc < 3)
  1321. X        goto usage;
  1322. X    if (rem_glob_one(argv[1]) < 0)
  1323. X        return;
  1324. X    (void) sprintf(str, "RNFR %s", argv[1]);
  1325. X    if (command(str) == CONTINUE) {
  1326. X        (void) sprintf(str, "RNTO %s", argv[1]);
  1327. X        (void) command(str);
  1328. X    }
  1329. X}    /* renamefile */
  1330. X
  1331. X
  1332. X
  1333. X/*
  1334. X * Get a directory listing
  1335. X * of remote files.
  1336. X */
  1337. Xint ls(int argc, char **argv)
  1338. X{
  1339. X    char        *whichcmd, *cp;
  1340. X    str32        lsflags;
  1341. X    string        remote, local, str;
  1342. X    int            listmode, pagemode, i;
  1343. X
  1344. X#ifdef REDIR
  1345. X    register struct lslist *a, *b;
  1346. X    for (a = lshead; a != NULL; ) {
  1347. X        b = a->next;
  1348. X        if (a->string)
  1349. X            free(a->string);    /* free string */
  1350. X        free(a);                  /* free node */
  1351. X        a = b;
  1352. X    }
  1353. X    lshead = lstail = NULL;
  1354. X#endif
  1355. X
  1356. X    pagemode = 0;
  1357. X    switch (**argv) {
  1358. X        case 'p':                            /* pls, pdir, pnlist */
  1359. X            pagemode = 1;
  1360. X            listmode = argv[0][1] == 'd';
  1361. X            break;
  1362. X        case 'd':                            /* dir */
  1363. X            listmode = 1;
  1364. X            break;
  1365. X        default:                            /* ls, nlist */
  1366. X            listmode = 0;
  1367. X    }
  1368. X    whichcmd = listmode ? "LIST" : "NLST";
  1369. X
  1370. X    (void) strncpy(local, (pagemode ? pager : "-"), sizeof(local));
  1371. X    remote[0] = lsflags[0] = 0;
  1372. X    
  1373. X    /* Possible scenarios:
  1374. X     *  1.    ls
  1375. X     *  2.    ls -flags
  1376. X     *  3.    ls directory
  1377. X     *  4.  ls -flags >outfile
  1378. X     *  5.  ls directory >outfile
  1379. X     *  6.  ls -flags directory
  1380. X     *  7.  ls -flags directory >outfile
  1381. X     */
  1382. X
  1383. X    for (i=1; i<argc; i++) {
  1384. X        switch (argv[i][0]) {
  1385. X            case '-': 
  1386. X                /*
  1387. X                 * If you give more than one set of flags, concat the each
  1388. X                 * additional set to the first one (without the dash).
  1389. X                 */
  1390. X                (void) strncat(lsflags, (argv[i] + (lsflags[0] == '-')), sizeof(lsflags));
  1391. X                break;
  1392. X            case '|':
  1393. X            case '>': (void) Strncpy(local, argv[i] + (argv[i][0] == '>')); break;
  1394. X            default:  
  1395. X                if (remote[0] != 0) {
  1396. X                    printf("ls: only one directory at a time please (or don't forget the '>' in >outfile).\n");
  1397. Xlsusage:
  1398. X                    (void) printf("usage: %s [-flags] [remote-directory] [>local-file]\n", argv[0]);
  1399. X                    code = -1;
  1400. X                    return;
  1401. X                }
  1402. X                /*
  1403. X                 * In case you want to get a remote file called '--README--'
  1404. X                 * or '>README,' you can use '\--README--' and '\>README.'
  1405. X                 */
  1406. X                (void) strncpy(remote, ((argv[i][0] == '\\') && (argv[i][1] != 0)) ? argv[i] + 1 : argv[i], sizeof(remote));
  1407. X        }    /* end switch */    
  1408. X    }        /* end loop */
  1409. X
  1410. X    /*
  1411. X     *    If we are given an ls with some flags, make sure we use 
  1412. X     *    columnized output (-C) unless one column output (-1) is
  1413. X     *    specified.
  1414. X     */
  1415. X    if (!listmode) {
  1416. X        if (lsflags[0] != 0) {
  1417. X            (void) Strncpy(str, lsflags);
  1418. X            for (cp = str + 1; *cp; cp++)
  1419. X                if (*cp == '1')
  1420. X                    goto aa;
  1421. X            (void) sprintf(lsflags, "-FC%s", str + 1);
  1422. X        } else {
  1423. X            if (remote_is_unix)
  1424. X                (void) strcpy(lsflags, "-FC");
  1425. X        }
  1426. X    }
  1427. Xaa:    if (strcmp(local, "-") != 0) {
  1428. X        char *lp = local;
  1429. X
  1430. X        if ((!globulize(&lp)) || ((local[0] != '|') && (!confirm("Output to local-file: ", local)))) {
  1431. X            code = -1;
  1432. X            return;
  1433. X        } 
  1434. X        if (lp != local) {
  1435. X            (void) Strncpy(str, lp);
  1436. X            (void) Strncpy(local, str);
  1437. X        }
  1438. X    }
  1439. X#ifdef REDIR
  1440. X    is_ls=1; /* tells getreply() to buffer output on a lshead list */
  1441. X#endif
  1442. X    (void) Strncpy(str, remote);
  1443. X    if (lsflags[0] && remote[0])
  1444. X        (void) sprintf(remote, "%s%c%s", lsflags, LS_FLAGS_AND_FILE, str);
  1445. X    else
  1446. X        (void) strncpy(remote, lsflags[0] ? lsflags : str, sizeof(remote));
  1447. X    recvrequest(whichcmd, local, (remote[0] == 0 ? NULL : remote), "w");
  1448. X#ifdef REDIR
  1449. X    is_ls=0;
  1450. X#endif
  1451. X}    /* ls */
  1452. X
  1453. X
  1454. X
  1455. X
  1456. X/*
  1457. X * Get a directory listing
  1458. X * of multiple remote files.
  1459. X */
  1460. Xint mls(int argc, char **argv)
  1461. X{
  1462. X    char *cmd, mode[1], *dest;
  1463. X    int i;
  1464. X    void (*oldintr)(int);
  1465. X
  1466. X    if (argc < 2)
  1467. X        argv = re_makeargv("(remote-files) ", &argc);
  1468. X    if (argc < 3)
  1469. X        argv = re_makeargv("(local-file) ", &argc);
  1470. X    if (argc < 3) {
  1471. X        (void) printf("usage:%s remote-files local-file\n", argv[0]);
  1472. X        code = -1;
  1473. X        return;
  1474. X    }
  1475. X    dest = argv[argc - 1];
  1476. X    argv[argc - 1] = NULL;
  1477. X    if (strcmp(dest, "-") && *dest != '|')
  1478. X        if (!globulize(&dest) || !confirm("output to local-file:", dest)) {
  1479. X            code = -1;
  1480. X            return;
  1481. X    }
  1482. X    cmd = argv[0][1] != 'd' ? "NLST" : "LIST";
  1483. X    mname = argv[0];
  1484. X    activemcmd = 1;
  1485. X    oldintr = signal(SIGINT, mabort);
  1486. X    (void) setjmp(jabort);
  1487. X    for (i = 1; activemcmd && i < argc-1; ++i) {
  1488. X        *mode = (i == 1) ? 'w' : 'a';
  1489. X        recvrequest(cmd, dest, argv[i], mode);
  1490. X        if (!activemcmd && fromatty) {
  1491. X            if (confirm("Continue with", argv[0])) {
  1492. X                activemcmd++;
  1493. X            }
  1494. X        }
  1495. X    }
  1496. X    (void) signal(SIGINT, oldintr);
  1497. X    activemcmd = 0;
  1498. X}    /* mls */
  1499. X
  1500. X
  1501. X
  1502. X
  1503. X/*
  1504. X * Do a shell escape
  1505. X */
  1506. X/*ARGSUSED*/
  1507. Xint shell(int argc, char **argv)
  1508. X{
  1509. X    int                pid;
  1510. X    void            (*old1)(int), (*old2)(int);
  1511. X    char            *theShell, *namep;
  1512. X#ifndef U_WAIT
  1513. X    int                Status;
  1514. X#else
  1515. X    union wait        Status;
  1516. X#endif
  1517. X    string            str;
  1518. X
  1519. X    old1 = signal (SIGINT, SIG_IGN);
  1520. X    old2 = signal (SIGQUIT, SIG_IGN);
  1521. X    if ((pid = fork()) == 0) {
  1522. X        for (pid = 3; pid < 20; pid++)
  1523. X            (void) close(pid);
  1524. X        (void) signal(SIGINT, SIG_DFL);
  1525. X        (void) signal(SIGQUIT, SIG_DFL);
  1526. X        if ((theShell = getenv("SHELL")) == NULL)
  1527. X            theShell = uinfo.shell;
  1528. X        if (theShell == NULL)
  1529. X            theShell = "/bin/sh";
  1530. X        namep = rindex(theShell, '/');
  1531. X        if (namep == NULL)
  1532. X            namep = theShell;
  1533. X        (void) strcpy(str, "-");
  1534. X        (void) strcat(str, ++namep);
  1535. X        if (strcmp(namep, "sh") != 0)
  1536. X            str[0] = '+';
  1537. X        if (debug) {
  1538. X            (void) printf ("%s\n", theShell);
  1539. X            (void) fflush (stdout);
  1540. X        }
  1541. X        if (argc > 1)
  1542. X            (void) execl(theShell, str, "-c", altarg, (char *)0);
  1543. X        else
  1544. X            (void) execl(theShell, str, (char *)0);
  1545. X        Perror(theShell);
  1546. X        code = -1;
  1547. X        exit(1);
  1548. X        }
  1549. X    if (pid > 0)
  1550. X        while (wait((void *) &Status) != pid)
  1551. X            ;
  1552. X    (void) signal(SIGINT, old1);
  1553. X    (void) signal(SIGQUIT, old2);
  1554. X    if (pid == -1) {
  1555. X        Perror("Try again later");
  1556. X        code = -1;
  1557. X    } else code = 0;
  1558. X    return (0);
  1559. X}    /* shell */
  1560. X
  1561. X
  1562. X
  1563. X
  1564. X/*
  1565. X * Send new user information (re-login)
  1566. X */
  1567. Xint do_user(int argc, char **argv)
  1568. X{
  1569. X    char            acct[80];
  1570. X    int                n, aflag = 0;
  1571. X    string            str;
  1572. X
  1573. X    if (argc < 2)
  1574. X        argv = re_makeargv("(username) ", &argc);
  1575. X    if (argc > 4) {
  1576. X        (void) printf("usage: %s username [password] [account]\n", argv[0]);
  1577. X        code = -1;
  1578. X        return (0);
  1579. X    }
  1580. X    (void) sprintf(str, "USER %s", argv[1]);
  1581. X    n = command(str);
  1582. X    if (n == CONTINUE) {
  1583. X        if (argc < 3 )
  1584. X            argv[2] = Getpass("Password: "), argc++;
  1585. X        (void) sprintf(str, "PASS %s", argv[2]);
  1586. X        n = command(str);
  1587. X    }
  1588. X    if (n == CONTINUE) {
  1589. X        if (argc < 4) {
  1590. X            (void) printf("Account: "); (void) fflush(stdout);
  1591. X            (void) FGets(acct, stdin);
  1592. X            acct[strlen(acct) - 1] = '\0';
  1593. X            argv[3] = acct; argc++;
  1594. X        }
  1595. X        (void) sprintf(str, "ACCT %s", argv[3]);
  1596. X        n = command(str);
  1597. X        aflag++;
  1598. X    }
  1599. X    if (n != COMPLETE) {
  1600. X        (void) fprintf(stdout, "Login failed.\n");
  1601. X        return (0);
  1602. X    }
  1603. X    if (!aflag && argc == 4) {
  1604. X        (void) sprintf(str, "ACCT %s", argv[3]);
  1605. X        (void) command(str);
  1606. X    }
  1607. X    return (1);
  1608. X}    /* user */
  1609. X
  1610. X
  1611. X
  1612. X
  1613. X/*
  1614. X * Print working directory.
  1615. X */
  1616. X/*ARGSUSED*/
  1617. Xint pwd(int argc, char **argv)
  1618. X{
  1619. X    int tmpverbose = verbose;
  1620. X    verbose = V_VERBOSE;
  1621. X    (void) command("PWD");
  1622. X    verbose = tmpverbose;
  1623. X}    /* pwd */
  1624. X
  1625. X
  1626. X
  1627. X
  1628. X/*
  1629. X * Make a directory.
  1630. X */
  1631. Xint makedir(int argc, char **argv)
  1632. X{
  1633. X    string str;
  1634. X
  1635. X    if (argc < 2)
  1636. X        argv = re_makeargv("(directory-name) ", &argc);
  1637. X    if (argc < 2) {
  1638. X        (void) printf("usage: %s directory-name\n", argv[0]);
  1639. X        code = -1;
  1640. X        return;
  1641. X    }
  1642. X    (void) sprintf(str, "MKD %s", argv[1]);
  1643. X    (void) command(str);
  1644. X}    /* makedir */
  1645. X
  1646. X
  1647. X
  1648. X
  1649. X/*
  1650. X * Remove a directory.
  1651. X */
  1652. Xint removedir(int argc, char **argv)
  1653. X{
  1654. X    string str;
  1655. X    if (argc < 2)
  1656. X        argv = re_makeargv("(directory-name) ", &argc);
  1657. X    if (argc < 2) {
  1658. X        (void) printf("usage: %s directory-name\n", argv[0]);
  1659. X        code = -1;
  1660. X        return;
  1661. X    }
  1662. X    if (rem_glob_one(argv[1]) == 0) {
  1663. X        (void) sprintf(str, "RMD %s", argv[1]);
  1664. X        (void) command(str);
  1665. X    }
  1666. X}    /* removedir */
  1667. X
  1668. X
  1669. X
  1670. X
  1671. X/*
  1672. X * Send a line, verbatim, to the remote machine.
  1673. X */
  1674. Xint quote(int argc, char **argv)
  1675. X{
  1676. X    int i, tmpverbose;
  1677. X    string str;
  1678. X
  1679. X    if (argc < 2)
  1680. X        argv = re_makeargv("(command line to send) ", &argc);
  1681. X    if (argc < 2) {
  1682. X        (void) printf("usage: %s line-to-send\n", argv[0]);
  1683. X        code = -1;
  1684. X        return;
  1685. X    }
  1686. X    (void) Strncpy(str, argv[1]);
  1687. X    for (i = 2; i < argc; i++) {
  1688. X        (void) Strncat(str, " ");
  1689. X        (void) Strncat(str, argv[i]);
  1690. X    }
  1691. X    tmpverbose = verbose;
  1692. X    verbose = V_VERBOSE;
  1693. X    if (command(str) == PRELIM) {
  1694. X        while (getreply(0) == PRELIM);
  1695. X    }
  1696. X    verbose = tmpverbose;
  1697. X}    /* quote */
  1698. X
  1699. X
  1700. X
  1701. X
  1702. X/*
  1703. X * Ask the other side for help.
  1704. X */
  1705. Xint rmthelp(int argc, char **argv)
  1706. X{
  1707. X    int oldverbose = verbose;
  1708. X    string str;
  1709. X
  1710. X    verbose = V_VERBOSE;
  1711. X    if (argc == 1) (void) command("HELP");
  1712. X    else {
  1713. X        (void) sprintf(str, "HELP %s", argv[1]);
  1714. X        (void) command(str);
  1715. X    }
  1716. X    verbose = oldverbose;
  1717. X}    /* rmthelp */
  1718. X
  1719. X
  1720. X
  1721. X
  1722. X/*
  1723. X * Terminate session and exit.
  1724. X */
  1725. X/*ARGSUSED*/
  1726. Xint quit(int argc, char **argv)
  1727. X{
  1728. X    close_up_shop();
  1729. X    trim_log();
  1730. X    exit(0);
  1731. X}    /* quit */
  1732. X
  1733. X
  1734. X
  1735. Xvoid close_streams(int wantShutDown)
  1736. X{
  1737. X    if (cout != NULL) {
  1738. X        if (wantShutDown)
  1739. X            (void) shutdown(fileno(cout), 1+1);
  1740. X        (void) fclose(cout);
  1741. X        cout = NULL;
  1742. X    }
  1743. X    if (cin != NULL) {
  1744. X        if (wantShutDown)
  1745. X            (void) shutdown(fileno(cin), 1+1);
  1746. X        (void) fclose(cin);
  1747. X        cin = NULL;
  1748. X    }
  1749. X}    /* close_streams */
  1750. X
  1751. X
  1752. X
  1753. X
  1754. X/*
  1755. X * Terminate session, but don't exit.
  1756. X */
  1757. X/*ARGSUSED*/
  1758. Xint disconnect(int argc, char **argv)
  1759. X{
  1760. X#ifdef SYSLOG
  1761. X    syslog (LOG_INFO, "%s disconnected from %s.", uinfo.username, hostname);
  1762. X#endif
  1763. X
  1764. X    (void) command("QUIT");
  1765. X    close_streams(0);
  1766. X    hostname[0] = cwd[0] = 0;
  1767. X    connected = 0;
  1768. X    data = -1;
  1769. X    macnum = 0;
  1770. X}    /* disconnect */
  1771. X
  1772. X
  1773. X
  1774. X
  1775. Xint confirm(char *cmd, char *file)
  1776. X{
  1777. X    str32 str;
  1778. X
  1779. X    if (!fromatty || (activemcmd && !mprompt))
  1780. X        return 1;
  1781. X    (void) printf("%s %s? ", cmd, file);
  1782. X    (void) fflush(stdout);
  1783. X    (void) Gets(str, sizeof(str));
  1784. X    return (*str != 'n' && *str != 'N');
  1785. X}    /* confirm */
  1786. X
  1787. X
  1788. X
  1789. Xvoid
  1790. Xfatal(char *msg)
  1791. X{
  1792. X    (void) fprintf(stderr, "%s: %s\n", progname, msg);
  1793. X    close_up_shop();
  1794. X    exit(1);
  1795. X}    /* fatal */
  1796. X
  1797. X
  1798. X
  1799. Xvoid
  1800. Xclose_up_shop(void)
  1801. X{
  1802. X    static int only_once = 0;
  1803. X    if (only_once++ > 0)
  1804. X        return;
  1805. X    if (connected)
  1806. X        disconnect(0, NULL);
  1807. X    if (logf != NULL) {
  1808. X        (void) fclose(logf);
  1809. X        logf = NULL;
  1810. X    }
  1811. X}    /* close_up_shop */
  1812. X
  1813. X
  1814. X
  1815. X
  1816. X/*
  1817. X * Glob a local file name specification with
  1818. X * the expectation of a single return value.
  1819. X * Can't control multiple values being expanded
  1820. X * from the expression, we return only the first.
  1821. X */
  1822. Xint globulize(char **cpp)
  1823. X{
  1824. X    char **globbed;
  1825. X
  1826. X    globbed = glob(*cpp);
  1827. X    if (globerr != NULL) {
  1828. X        (void) printf("%s: %s\n", *cpp, globerr);
  1829. X        if (globbed) {
  1830. X            blkfree(globbed);
  1831. X            free(globbed);
  1832. X        }
  1833. X        return (0);
  1834. X    }
  1835. X    if (globbed) {
  1836. X        *cpp = *globbed++;
  1837. X        /* don't waste too much memory */
  1838. X        if (*globbed) {
  1839. X            blkfree(globbed);
  1840. X            free(globbed);
  1841. X        }
  1842. X    }
  1843. X    return (1);
  1844. X}    /* globulize */
  1845. X
  1846. X
  1847. X
  1848. X/* change directory to perent directory */
  1849. X/*ARGSUSED*/
  1850. Xint cdup(int argc, char **argv)
  1851. X{
  1852. X    (void) _cd("CDUP");
  1853. X}
  1854. X
  1855. X
  1856. X/* show remote system type */
  1857. X/*ARGSUSED*/
  1858. Xint syst(int argc, char **argv)
  1859. X{
  1860. X    (void) command("SYST");
  1861. X}
  1862. X
  1863. X
  1864. X
  1865. X
  1866. Xint make_macro(char *name, FILE *fp)
  1867. X{
  1868. X    char            *tmp;
  1869. X    char            *cp;
  1870. X    string            str;
  1871. X    size_t            len;
  1872. X
  1873. X    if (macnum == MAXMACROS) {
  1874. X        (void) fprintf(stderr, "Limit of %d macros have already been defined.\n", MAXMACROS);
  1875. X        return -1;
  1876. X    }
  1877. X    (void) strncpy(macros[macnum].mac_name, name, (size_t)8);
  1878. X    if (macnum == 0)
  1879. X        macros[macnum].mac_start = macbuf;
  1880. X    else
  1881. X        macros[macnum].mac_start = macros[macnum - 1].mac_end + 1;
  1882. X    tmp = macros[macnum].mac_start;
  1883. X    while (1) {
  1884. X        cp = fgets(str, sizeof(str) - 1, fp);
  1885. X        if (cp == NULL) {
  1886. X            /*
  1887. X             * If we had started a macro, we will say it is
  1888. X             * okay to skip the blank line delimiter if we
  1889. X             * are at the EOF.
  1890. X             */
  1891. X            if (tmp > macros[macnum].mac_start)
  1892. X                goto endmac;
  1893. X            (void) fprintf(stderr, "No text supplied for macro \"%s.\"\n", name);
  1894. X        }
  1895. X        /* see if we have a 'blank' line: just whitespace. */
  1896. X        while (*cp && isspace(*cp)) ++cp;
  1897. X        if (*cp == '\0') {
  1898. X            /* Blank line; end this macro. */
  1899. Xendmac:
  1900. X            macros[macnum++].mac_end = tmp;
  1901. X            return 0;
  1902. X        }
  1903. X        len = strlen(cp) + 1;    /* we need the \0 too. */
  1904. X        if (tmp + len >= macbuf + MACBUFLEN) {
  1905. X            (void) fprintf(stderr, "Macro \"%s\" not defined -- %d byte buffer exceeded.\n", name, MACBUFLEN);
  1906. X            return -1;
  1907. X        }
  1908. X        (void) strcpy(tmp, cp);
  1909. X        tmp += len;
  1910. X    }
  1911. X}    /* make_macro */
  1912. X
  1913. X
  1914. X
  1915. X
  1916. Xint macdef(int argc, char **argv)
  1917. X{
  1918. X    if (argc < 2)
  1919. X        argv = re_makeargv("(macro name) ", &argc);
  1920. X    if (argc != 2) {
  1921. X        (void) printf("Usage: %s macro_name\n", argv[0]);
  1922. X        domacro(0, NULL);
  1923. X        return;
  1924. X    }
  1925. X    (void) printf("Enter macro line by line, terminating it with a blank line\n");
  1926. X    code = make_macro(argv[1], stdin);
  1927. X}    /* macdef */
  1928. X
  1929. X
  1930. X
  1931. X
  1932. Xint domacro(int argc, char **argv)
  1933. X{
  1934. X    register int            i, j;
  1935. X    register char            *cp1, *cp2;
  1936. X    int                        count = 2, loopflg = 0;
  1937. X    string                    str;
  1938. X    struct cmd                *c;
  1939. X
  1940. X    if (argc < 2) {
  1941. X        /* print macros. */
  1942. X        if (macnum == 0)
  1943. X            (void) printf("No macros defined.\n");
  1944. X        else {
  1945. X            printf("Current macro definitions:\n");
  1946. X            for (i = 0; i < macnum; ++i) {
  1947. X                (void) printf("%s:\n", macros[i].mac_name);
  1948. X                cp1 = macros[i].mac_start;
  1949. X                cp2 = macros[i].mac_end;
  1950. X                while (cp1 < cp2) {
  1951. X                    (void) printf("   > ");
  1952. X                    while (cp1 < cp2 && *cp1)
  1953. X                        putchar(*cp1++);
  1954. X                    ++cp1;
  1955. X                }
  1956. X            }
  1957. X        }
  1958. X        if (argc == 0) return;    /* called from macdef(), above. */
  1959. X        argv = re_makeargv("(macro to run) ", &argc);
  1960. X    }            
  1961. X    if (argc < 2) {
  1962. X        (void) printf("Usage: %s macro_name.\n", argv[0]);
  1963. X        code = -1;
  1964. X        return;
  1965. X    }
  1966. X    for (i = 0; i < macnum; ++i) {
  1967. X        if (!strncmp(argv[1], macros[i].mac_name, (size_t) 9)) {
  1968. X            break;
  1969. X        }
  1970. X    }
  1971. X    if (i == macnum) {
  1972. X        (void) printf("'%s' macro not found.\n", argv[1]);
  1973. X        code = -1;
  1974. X        return;
  1975. X    }
  1976. X    (void) Strncpy(str, line);
  1977. XTOP:
  1978. X    cp1 = macros[i].mac_start;
  1979. X    while (cp1 != macros[i].mac_end) {
  1980. X        while (isspace(*cp1)) {
  1981. X            cp1++;
  1982. X        }
  1983. X        cp2 = line;
  1984. X        while (*cp1 != '\0') {
  1985. X              switch(*cp1) {
  1986. X                   case '\\':
  1987. X                 *cp2++ = *++cp1;
  1988. X                 break;
  1989. X                case '$':
  1990. X                 if (isdigit(*(cp1+1))) {
  1991. X                    j = 0;
  1992. X                    while (isdigit(*++cp1)) {
  1993. X                      j = 10*j +  *cp1 - '0';
  1994. X                    }
  1995. X                    cp1--;
  1996. X                    if (argc - 2 >= j) {
  1997. X                    (void) strcpy(cp2, argv[j+1]);
  1998. X                    cp2 += strlen(argv[j+1]);
  1999. X                    }
  2000. X                    break;
  2001. X                 }
  2002. X                 if (*(cp1+1) == 'i') {
  2003. X                    loopflg = 1;
  2004. X                    cp1++;
  2005. X                    if (count < argc) {
  2006. X                       (void) strcpy(cp2, argv[count]);
  2007. X                       cp2 += strlen(argv[count]);
  2008. X                    }
  2009. X                    break;
  2010. X                }
  2011. X                /* intentional drop through */
  2012. X                default:
  2013. X                *cp2++ = *cp1;
  2014. X                break;
  2015. X              }
  2016. X              if (*cp1 != '\0') {
  2017. X                    cp1++;
  2018. X              }
  2019. X        }
  2020. X        *cp2 = '\0';
  2021. X        makeargv();
  2022. X        c = getcmd(margv[0]);
  2023. X        if ((c == (struct cmd *)-1) && !parsing_rc) {
  2024. X            (void) printf("?Ambiguous command\n");
  2025. X            code = -1;
  2026. X        }
  2027. X        else if (c == NULL && !parsing_rc) {
  2028. X            (void) printf("?Invalid command\n");
  2029. X            code = -1;
  2030. X        } else if (c->c_conn && !connected) {
  2031. X            (void) printf("Not connected.\n");
  2032. X            code = -1;
  2033. X        } else {
  2034. X            if (IS_VVERBOSE)
  2035. X                (void) printf("%s\n",line);
  2036. X            (*c->c_handler)(margc, margv);
  2037. X            (void) strcpy(line, str);
  2038. X            makeargv();
  2039. X            argc = margc;
  2040. X            argv = margv;
  2041. X        }
  2042. X        if (cp1 != macros[i].mac_end) {
  2043. X            cp1++;
  2044. X        }
  2045. X    }
  2046. X    if (loopflg && ++count < argc) {
  2047. X        goto TOP;
  2048. X    }
  2049. X}    /* domacro */
  2050. X
  2051. X
  2052. X
  2053. X/*
  2054. X * get size of file on remote machine
  2055. X */
  2056. Xint sizecmd(int argc, char **argv)
  2057. X{
  2058. X    string str;
  2059. X    int oldv;
  2060. X
  2061. X    if (argc < 2)
  2062. X        argv = re_makeargv("(remote-file) ", &argc);
  2063. X    if (argc < 2) {
  2064. X        (void) printf("usage:%s filename\n", argv[0]);
  2065. X        code = -1;
  2066. X        return;
  2067. X    }
  2068. X    if (rem_glob_one(argv[1]) == 0) {
  2069. X        (void) sprintf(str, "SIZE %s", argv[1]);
  2070. X        oldv = verbose;
  2071. X        verbose = V_VERBOSE;
  2072. X        (void) command(str);
  2073. X        verbose = oldv;
  2074. X    }
  2075. X}    /* sizecmd */
  2076. X
  2077. X
  2078. X
  2079. X
  2080. X/*
  2081. X * get last modification time of file on remote machine
  2082. X */
  2083. Xint modtime(int argc, char **argv)
  2084. X{
  2085. X    int overbose;
  2086. X    string str;
  2087. X
  2088. X    if (argc < 2)
  2089. X        argv = re_makeargv("(remote-file) ", &argc);
  2090. X    if (argc < 2) {
  2091. X        (void) printf("usage:%s filename\n", argv[0]);
  2092. X        code = -1;
  2093. X        return;
  2094. X    }
  2095. X    if (rem_glob_one(argv[1]) == 0) {
  2096. X        overbose = verbose;
  2097. X        if (debug == 0)
  2098. X            verbose = V_QUIET;
  2099. X        (void) sprintf(str, "MDTM %s", argv[1]);
  2100. X        if (command(str) == COMPLETE) {
  2101. X            int yy, mo, day, hour, min, sec;
  2102. X            (void) sscanf(reply_string, "%*s %04d%02d%02d%02d%02d%02d", &yy, &mo,
  2103. X                &day, &hour, &min, &sec);
  2104. X            /* might want to print this in local time */
  2105. X            (void) printf("%s\t%02d/%02d/%04d %02d:%02d:%02d GMT\n", argv[1],
  2106. X                mo, day, yy, hour, min, sec);
  2107. X        } else
  2108. X            (void) fputs(reply_string, stdout);
  2109. X        verbose = overbose;
  2110. X    }
  2111. X}    /* modtime */
  2112. X
  2113. X
  2114. X
  2115. Xint lookup(int argc, char **argv)
  2116. X{
  2117. X    int i, j, by_name, result = 0;
  2118. X    unsigned long addr;            /* address in host order */
  2119. X    struct hostent *host;        /* structure returned by gethostbyaddr() */
  2120. X    extern int h_errno;
  2121. X
  2122. X    if (argc < 2)
  2123. X        argv = re_makeargv("(sitename) ", &argc);
  2124. X    if (argc < 2) {
  2125. X        (void) printf("usages:\n\t%s <sitenames>\n\t%s <ip numbers>\n",
  2126. X            argv[0], argv[0]);
  2127. X    }
  2128. X
  2129. X     lasthostname[0] = 0;
  2130. X    for (i=1; i<argc; i++) {
  2131. X        /* does the argument look like an address? */
  2132. X        if (4 == sscanf (argv[i], "%d.%d.%d.%d", &j, &j, &j, &j)) {
  2133. X            /* ip */
  2134. X              if ((addr = inet_addr (argv[i])) == 0xffffffff) {
  2135. X                 (void) fprintf(stderr, "## could not convert \"%s\" into a valid IP address.\n", argv[i]);
  2136. X                 continue;
  2137. X             }
  2138. X            host = gethostbyaddr ((char *) &addr, 4, AF_INET);
  2139. X            by_name = 0;
  2140. X        } else {
  2141. X            /* name */
  2142. X            host = gethostbyname (argv[i]);
  2143. X            by_name = 1;
  2144. X        }
  2145. X        if (host == NULL) {
  2146. X            if (NOT_VQUIET) {
  2147. X                /* gethostxxx error */                
  2148. X                result = h_errno;
  2149. X                if (h_errno == HOST_NOT_FOUND) {
  2150. X                     (void) printf("%s: lookup error (%d).\n",
  2151. X                         argv[i], h_errno);
  2152. X                     result = h_errno;
  2153. X                 } else {
  2154. X                     (void) printf("%s \"%s\"\n",
  2155. X                         (by_name==0 ? "unknown address" : "unknown host"),
  2156. X                         argv[i]);
  2157. X                     result = 
  2158. X                         h_errno != 0 ? h_errno :
  2159. X                         -1;
  2160. X                }
  2161. X            }
  2162. X         } else {
  2163. X             if (*host->h_name)
  2164. X                 Strncpy(lasthostname, host->h_name);
  2165. X            if (NOT_VQUIET) {
  2166. X                (void) printf("%-32s  ", *host->h_name ? host->h_name : "???");
  2167. X                if (*host->h_addr_list) {
  2168. X                    unsigned long horder;
  2169. X    
  2170. X                    horder = ntohl (*(unsigned long *) *(char **)host->h_addr_list);
  2171. X                    (void) printf ("%lu.%lu.%lu.%lu\n",
  2172. X                        (horder >> 24),
  2173. X                        (horder >> 16) & 0xff,
  2174. X                        (horder >> 8) & 0xff,
  2175. X                        horder & 0xff);
  2176. X                }
  2177. X                else (void) printf("???\n");
  2178. X            }
  2179. X        }
  2180. X    }    /* loop thru all sites */
  2181. X    return result;
  2182. X}    /* lookup */
  2183. X
  2184. X
  2185. X
  2186. X
  2187. Xint getlocalhostname(char *host, size_t size)
  2188. X{
  2189. X    int oldv, r;
  2190. X    char *argv[2];
  2191. X
  2192. X#ifdef HOSTNAME
  2193. X    (void) strncpy(host, HOSTNAME, size);
  2194. X    return 0;
  2195. X#else
  2196. X    *host = 0;
  2197. X    if ((r = gethostname(host, size)) == 0) {
  2198. X        oldv = verbose;
  2199. X        verbose = V_QUIET;
  2200. X        argv[0] = "lookup";
  2201. X        (void) sprintf(line, "lookup %s", host);
  2202. X        (void) makeargv();
  2203. X        if (lookup(margc, margv) == 0 && lasthostname[0])
  2204. X            (void) strncpy(host, lasthostname, size);
  2205. X        verbose = oldv;
  2206. X    }
  2207. X    return r;
  2208. X#endif
  2209. X}    /* getlocalhostname */
  2210. X
  2211. X
  2212. X
  2213. X
  2214. X/*
  2215. X * show status on remote machine
  2216. X */
  2217. Xint rmtstatus(int argc, char **argv)
  2218. X{
  2219. X    string str;
  2220. X    if (argc > 1) {
  2221. X        (void) sprintf(str, "STAT %s" , argv[1]);
  2222. X        (void) command(str);
  2223. X    } else (void) command("STAT");
  2224. X}    /* rmtstatus */
  2225. X
  2226. X
  2227. X
  2228. X
  2229. X/*
  2230. X * create an empty file on remote machine.
  2231. X */
  2232. Xint create(int argc, char **argv)
  2233. X{
  2234. X    string            str;
  2235. X    FILE            *ftemp;
  2236. X
  2237. X    if (argc < 2)
  2238. X        argv = re_makeargv("(remote-file) ", &argc);
  2239. X    if (argc < 2) {
  2240. X        (void) printf("usage:%s filename\n", argv[0]);
  2241. X        code = -1;
  2242. X        return;
  2243. X    }
  2244. X    (void) tmp_name(str);
  2245. X    ftemp = fopen(str, "w");
  2246. X    /* (void) fputc('x', ftemp); */
  2247. X    (void) fclose(ftemp);
  2248. X    creating = 1;
  2249. X    sendrequest("STOR", str, argv[1]);
  2250. X    creating = 0;
  2251. X    (void) unlink(str);
  2252. X}    /* create */
  2253. X
  2254. X
  2255. X
  2256. X
  2257. X/* show version info */
  2258. X/*ARGSUSED*/
  2259. Xint show_version(int argc, char **argv)
  2260. X{
  2261. X    char    *DStrs[20];
  2262. X    int        nDStrs = 0, i, j;
  2263. X
  2264. X    (void) printf("%s\n%-30s %s\n", version, "Author:",
  2265. X        "Mike Gleason, NCEMRSoft (mgleason@cse.unl.edu).");
  2266. X
  2267. X/* Now entering CPP hell... */
  2268. X#ifdef __DATE__
  2269. X    (void) printf("%-30s %s\n", "Compile Date:", __DATE__);
  2270. X#endif
  2271. X    (void) printf("%-30s %s (%s)\n", "Operating System:",
  2272. X#ifdef System
  2273. X    System,
  2274. X#else
  2275. X#    ifdef unix
  2276. X    "UNIX",
  2277. X#    else
  2278. X    "??",
  2279. X#    endif
  2280. X#endif
  2281. X#ifdef SYSV
  2282. X        "SYSV");
  2283. X#else
  2284. X#    ifdef BSD
  2285. X            "BSD");
  2286. X#    else
  2287. X            "neither BSD nor SYSV?");
  2288. X#    endif
  2289. X#endif
  2290. X
  2291. X    /* Show which CPP symbols were used in compilation. */
  2292. X#ifdef __GNUC__
  2293. X    DStrs[nDStrs++] = "__GNUC__";
  2294. X#endif
  2295. X#ifdef RINDEX
  2296. X    DStrs[nDStrs++] = "RINDEX";
  2297. X#endif
  2298. X#ifdef CURSES
  2299. X    DStrs[nDStrs++] = "CURSES";
  2300. X#endif
  2301. X#ifdef HERROR
  2302. X    DStrs[nDStrs++] = "HERROR";
  2303. X#endif
  2304. X#ifdef U_WAIT
  2305. X    DStrs[nDStrs++] = "U_WAIT";
  2306. X#endif
  2307. X#if defined(CONST) || defined(const)
  2308. X    DStrs[nDStrs++] = "CONST";
  2309. X#endif
  2310. X#ifdef GETPASS
  2311. X    DStrs[nDStrs++] = "GETPASS";
  2312. X#endif
  2313. X#ifdef GETCWDSIZET
  2314. X    DStrs[nDStrs++] = "GETCWDSIZET";
  2315. X#endif
  2316. X#ifdef HOSTNAME
  2317. X    DStrs[nDStrs++] = "HOSTNAME";
  2318. X#endif
  2319. X#ifdef SYSDIRH
  2320. X    DStrs[nDStrs++] = "SYSDIRH";
  2321. X#endif
  2322. X#ifdef SYSSELECTH
  2323. X    DStrs[nDStrs++] = "SYSSELECTH";
  2324. X#endif
  2325. X#ifdef NO_UNISTDH 
  2326. X    DStrs[nDStrs++] = "NO_UNISTDH";
  2327. X#endif
  2328. X#ifdef NO_STDLIBH
  2329. X    DStrs[nDStrs++] = "NO_STDLIBH";
  2330. X#endif
  2331. X#ifdef SYSLOG 
  2332. X    DStrs[nDStrs++] = "SYSLOG";
  2333. X#endif
  2334. X#ifdef REDIR
  2335. X    DStrs[nDStrs++] = "REDIR";
  2336. X#endif
  2337. X#ifdef BAD_INETADDR
  2338. X    DStrs[nDStrs++] = "BAD_INETADDR";
  2339. X#endif
  2340. X#ifdef SGTTYB
  2341. X    DStrs[nDStrs++] = "SGTTYB";
  2342. X#endif
  2343. X#ifdef TERMIOS
  2344. X    DStrs[nDStrs++] = "TERMIOS";
  2345. X#endif
  2346. X#ifdef _POSIX_SOURCE
  2347. X    DStrs[nDStrs++] = "_POSIX_SOURCE";
  2348. X#endif
  2349. X
  2350. X
  2351. X    (void) printf ("\nCompile Options:\n");
  2352. X    for (i=j=0; i<nDStrs; i++) {
  2353. X        if (j == 0)
  2354. X            (void) printf("    ");
  2355. X        (void) printf("%-15s", DStrs[i]);
  2356. X        if (++j == 4) {
  2357. X            j = 0;
  2358. X            (void) putchar('\n');
  2359. X        }
  2360. X    }
  2361. X    if (j != 0)
  2362. X        (void) putchar('\n');
  2363. X    
  2364. X    (void) printf("\nDefaults:\n");
  2365. X    (void) printf("\
  2366. X    Xfer Buf Size: %8d   Debug: %d   MPrompt: %d   Verbosity: %d\n\
  2367. X    Prompt: %s   Pager: %s  ZCat: %s\n\
  2368. X    Logname: %s   Logging: %d   Type: %s   Cmd Len: %d\n\
  2369. X    Recv Line Len: %d   #Macros: %d   Macbuf: %d  Auto-Binary: %d\n\
  2370. X    Redial Delay: %d  New Mail Message: \"%s\"\n",
  2371. X        MAX_XFER_BUFSIZE, dDEBUG, dMPROMPT, dVERBOSE,
  2372. X        dPROMPT, dPAGER, ZCAT,
  2373. X        dLOGNAME, dLOGGING, dTYPESTR, CMDLINELEN,
  2374. X        RECEIVEDLINELEN, MAXMACROS, MACBUFLEN, dAUTOBINARY,
  2375. X        dREDIALDELAY, NEWMAILMESSAGE
  2376. X    );
  2377. X}    /* show_version */
  2378. X
  2379. X
  2380. X
  2381. Xvoid Perror(char *s)
  2382. X{
  2383. X    extern int errno;
  2384. X
  2385. X    if (NOT_VQUIET) {
  2386. X        if (s != NULL)
  2387. X            (void) fprintf(stderr, "NcFTP: %s (%d): ", s, errno);
  2388. X        perror(NULL);
  2389. X    }
  2390. X}    /* Perror */
  2391. X
  2392. X
  2393. X
  2394. X#ifdef REDIR
  2395. X/*ARGSUSED*/
  2396. Xint showlsbuffer(int argc, char **argv)
  2397. X{
  2398. X    register struct lslist *a = lshead;
  2399. X    int pagemode;
  2400. X    FILE *fp;
  2401. X    void (*oldintp)(int);
  2402. X
  2403. X    if (a == NULL)
  2404. X        return;
  2405. X    pagemode= (**argv) == 'p' && pager[0] == '|';
  2406. X    if (pagemode) {
  2407. X        fp = popen(pager + 1, "w");
  2408. X        if (!fp) {
  2409. X            Perror(pager + 1);
  2410. X            return;
  2411. X        }
  2412. X    } else
  2413. X        fp = stdout;
  2414. X    oldintp = signal(SIGPIPE, SIG_IGN);
  2415. X    while (a) {
  2416. X        if (a->string)
  2417. X            (void) fprintf(fp, "%s\n", a->string);
  2418. X        a = a->next;
  2419. X    }
  2420. X    if (pagemode)
  2421. X        (void) pclose(fp);
  2422. X    if (oldintp)
  2423. X        signal(SIGPIPE, oldintp);
  2424. X}    /* showlsbuffer */
  2425. X#endif
  2426. X
  2427. X/* eof cmds.c */
  2428. END_OF_FILE
  2429.   if test 48279 -ne `wc -c <'cmds.c'`; then
  2430.     echo shar: \"'cmds.c'\" unpacked with wrong size!
  2431.   fi
  2432.   # end of 'cmds.c'
  2433. fi
  2434. if test -f 'ftp.h' -a "${1}" != "-c" ; then 
  2435.   echo shar: Will not clobber existing file \"'ftp.h'\"
  2436. else
  2437.   echo shar: Extracting \"'ftp.h'\" \(852 characters\)
  2438.   sed "s/^X//" >'ftp.h' <<'END_OF_FILE'
  2439. X/* ftp.h */
  2440. X
  2441. X#ifndef _ftp_h_
  2442. X#define _ftp_h_
  2443. X
  2444. X#define IS_FILE 1
  2445. X#define IS_STREAM 0
  2446. X#define IS_PIPE -1
  2447. X
  2448. X/* Progress-meter types. */
  2449. X#define pr_none 0
  2450. X#define pr_percent 1
  2451. X#define pr_philbar 2
  2452. X#define pr_kbytes 3
  2453. X
  2454. Xint hookup(char *host, int port);
  2455. Xint login(char *, int, int);
  2456. Xvoid cmdabort(int unused);
  2457. Xint command(char *cmd);
  2458. Xint getreply(int expecteof);
  2459. Xvoid abortsend(int unused);
  2460. Xvoid sendrequest(char *cmd, char *local, char *remote);
  2461. Xvoid abortrecv(int unused);
  2462. Xvoid recvrequest(char *cmd, char *local, char *remote, char *mode);
  2463. Xint initconn(void);
  2464. XFILE *dataconn(char *mode);
  2465. Xvoid close_file(FILE **fin, int filetype);
  2466. Xlong get_remote_size(char *remote, int filetype);
  2467. Xint start_progress(int sending, char *local);
  2468. Xvoid progress_report(int);
  2469. Xvoid end_progress(char *direction, char *local, char *remote);
  2470. X
  2471. X#endif /* _ftp_h_ */
  2472. X
  2473. X/* eof ftp.h */
  2474. END_OF_FILE
  2475.   if test 852 -ne `wc -c <'ftp.h'`; then
  2476.     echo shar: \"'ftp.h'\" unpacked with wrong size!
  2477.   fi
  2478.   # end of 'ftp.h'
  2479. fi
  2480. echo shar: End of archive 1 \(of 4\).
  2481. cp /dev/null ark1isdone
  2482. MISSING=""
  2483. for I in 1 2 3 4 ; do
  2484.     if test ! -f ark${I}isdone ; then
  2485.     MISSING="${MISSING} ${I}"
  2486.     fi
  2487. done
  2488. if test "${MISSING}" = "" ; then
  2489.     echo You have unpacked all 4 archives.
  2490.     rm -f ark[1-9]isdone
  2491. else
  2492.     echo You still must unpack the following archives:
  2493.     echo "        " ${MISSING}
  2494. fi
  2495. exit 0
  2496. exit 0 # Just in case...
  2497.