home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume39 / ncftp / part01 next >
Encoding:
Text File  |  1993-08-25  |  60.5 KB  |  2,488 lines
  1. Newsgroups: comp.sources.misc
  2. From: mgleason@cse.unl.edu (Mike Gleason)
  3. Subject: v39i053:  ncftp - Alternative User Interface for FTP, v1.5.0, Part01/05
  4. Message-ID: <csm-v39i053=ncftp.190257@sparky.Sterling.COM>
  5. X-Md4-Signature: 5cb695d03cf85312bdbf67b868043c0d
  6. Sender: kent@sparky.sterling.com (Kent Landfield)
  7. Organization: NCEMRSoft
  8. Date: Thu, 26 Aug 1993 00:03:44 GMT
  9. Approved: kent@sparky.sterling.com
  10.  
  11. Submitted-by: mgleason@cse.unl.edu (Mike Gleason)
  12. Posting-number: Volume 39, Issue 53
  13. Archive-name: ncftp/part01
  14. Environment: UNIX, ANSI-C, !SVR4
  15. Supersedes: ncftp: Volume 35, Issue 4-7
  16.  
  17. NcFTP - Alternative user interface for FTP
  18. Version 1.5.0 by Mike Gleason, NCEMRSoft.
  19.  
  20. I used to list the features of ncftp in this blurb, but there are just
  21. too many to list.  Even if you only ftp occasionally, it is worth your
  22. time to install ncftp (or atleast bug your sysadmin to).  If you won't take
  23. my word for it, just ask around, or extract this archive and read the
  24. man page.
  25.  
  26. Note:  May not work correctly with System V R 4 (and Solaris 2.2).
  27. Note:  YOU WON'T FIND THIS in my ftp directory on cse.unl.edu.  I will
  28.   put it there in one week.
  29.  
  30. Major changes since 1.0.2:
  31.  
  32. * Supports the Getline (input-edit) and GNU Readline command-line
  33.   editing and history libraries.
  34.  
  35. * Supports the Socks firewall library, and another firewall gateway
  36.   implementation.
  37.  
  38. * Terrific new "recent-sites" file that automatically saves the
  39.   sites you call;  when you open a site in the recent-sites file
  40.   (of course you can abbreviate the names), you start in the
  41.   same directory you were in last time.
  42.  
  43. * Improved on-line help, and tips on how to use the program better
  44.   are printed each time you run the program.
  45.  
  46. * Rewritten man page.
  47.  
  48. * Faster ascii transfers.
  49.  
  50. * Typing 'open' by itself lists all the sites the program knows
  51.   about (the ones in your .netrc and the recent-sites list) so
  52.   you can just pick one.
  53.  
  54. * Enhanced colon-mode, that can dump a file to stdout (ftpcat mode)
  55.   or to a pager.  (i.e. ncftp -c wu:/README >/dev/null).
  56.  
  57. * You can choose whether an open is anonymous by default (like it
  58.   had always been) or a user login by default by setting a new
  59.   program variable.
  60.  
  61. * Bugs fixed.
  62.  
  63. Read the enclosed file, v2_Notes, which explains why I won't be
  64. able to work on the nearly finished, and much improved v2.0.
  65. -------
  66. #! /bin/sh
  67. # This is a shell archive.  Remove anything before this line, then feed it
  68. # into a shell via "sh file" or similar.  To overwrite existing files,
  69. # type "sh file -c".
  70. # Contents:  README cmds.c cmds.h open.h
  71. # Wrapped by kent@sparky on Wed Aug 25 18:59:16 1993
  72. PATH=/bin:/usr/bin:/usr/ucb:/usr/local/bin:/usr/lbin ; export PATH
  73. echo If this archive is complete, you will see the following message:
  74. echo '          "shar: End of archive 1 (of 5)."'
  75. if test -f 'README' -a "${1}" != "-c" ; then 
  76.   echo shar: Will not clobber existing file \"'README'\"
  77. else
  78.   echo shar: Extracting \"'README'\" \(11962 characters\)
  79.   sed "s/^X//" >'README' <<'END_OF_FILE'
  80. XIf you are a novice user, and don't know how to compile things, try
  81. Xcontacting your local guru first (get them to do it for you :-).  Please
  82. Xunderstand that I don't have time to walk newbies through the whole
  83. Xinstallation procedure.
  84. X
  85. X1. READ this entire file.  Part A, below, tells what to do if you want to
  86. X   use NcFTP with a command-line editor.  Part B tells you how to configure
  87. X   the Makefile to compile the program for your system.  Part C tells you
  88. X   how to configure NcFTP's optional features.  Part D tells you how to
  89. X   contact me if you want to report a bug or submit new code to the
  90. X   program.
  91. X
  92. X2. EDIT the Makefile, making any necessary changes described in parts
  93. X   A, B, or C.  Don't forget to read the directions in the Makefile,
  94. X   so you don't forget any needed libraries, etcetera.
  95. X
  96. X3. You can also change the program's default behavior by editing defaults.h.
  97. X   99% of the time you don't need to do this, so you can skip this step.
  98. X
  99. XIf you have problems, you can mail me, but please try your best to install
  100. Xit without my help.  I'm quite tired of responding to lazy SunOS users
  101. Xbecause they didn't bother reading the directions so that they would have
  102. Xknown that they needed to use GCC.  
  103. X
  104. XI _do_ want to hear from you if you have comments or bug reports/fixes.  I
  105. Xwould also like to hear from you if you had a system that wasn't covered
  106. Xin sys.h, so I can add an entry for other users of your system.
  107. X
  108. XThe latest version of ncftp is available in the directory:
  109. X    cse.unl.edu:/pub/mgleason
  110. XThis machine is heavily used by students and faculty alike, so please
  111. Xdo not call during working hours (9AM - 5PM American Central time).  In fact,
  112. XI have a cron entry that changes all the file permissions to public
  113. Xunreadable during that period, so you won't be able to download anyway.
  114. X
  115. XI am grateful to Shari Deiana and the University of Nebraska for making this
  116. Xpossible!
  117. X
  118. X
  119. XPart A.  Installing with a command line editor:
  120. X----------------------------------------------
  121. X
  122. XAs of this release, GNU Readline and Chris Thewalt's Getline command-line
  123. Xediting and history facilities are supported.  Neither are included with the
  124. Xncftp sources.  You can find Getline at:
  125. X  ce.berkeley.edu:/pub/thewalt/getline.tar.Z  (note: use 'ls', not 'dir!')
  126. Xand Readline is in the directory:
  127. X  prep.ai.mit.edu:/pub/gnu
  128. X
  129. XTo install Readline, you will need to know where libreadline.a and the
  130. Xheader <readline/readline.h> are.  You will need to link libreadline.a and
  131. Xlibcurses.a (or libtermcap.a) with ncftp (see the Makefile).  Good luck on
  132. Xtrying to compile it.  It is not an easy thing to do!  In the Makefile, you
  133. Xwill need to add -DREADLINE to PDEFS, add -lreadline -lcurses to LIBS, and
  134. Xedit the HDRDIRS and LIBDIRS lines.  This stuff is already in the Makefile,
  135. Xso you can just uncomment it.
  136. X
  137. XTo install Getline, you need to know where libgetline.a and it's header
  138. X(getline.h) are.  In the Makefile, you'll need to add -lgetline to LIBS and
  139. Xedit the HDRDIRS and LIBDIRS lines.  This stuff is already in the Makefile,
  140. Xso you can just uncomment it.
  141. X
  142. XDO NOT bug me if you can't figure out how to compile Getline or Readline.
  143. XContact their respective authors instead.  It is not essential that you use
  144. Xthem.
  145. X
  146. X
  147. XPart B.  System Dependencies:
  148. X----------------------------
  149. X
  150. XNcFTP may need work-arounds for some things due to the differences
  151. Xin implementations of unix.  The following systems are taken care
  152. Xof automatically.  For these systems, you should just be able to type
  153. X'make' (but proceed to part C):
  154. X
  155. X   Silicon Graphics IRIX
  156. X   AIX
  157. X   SINIX
  158. X   Ultrix
  159. X   NeXT
  160. X   Pyramid OSx
  161. X
  162. XOtherwise you will have to configure ncftp manually.
  163. X
  164. XYou will need to add these things to the SDEFS line in the Makefile
  165. Xas applicable.  As an example, if I say 'add -DFoobar to SDEFS,' find
  166. Xthe line in the Makefile that reads 'SDEFS=' (or 'SDEFS=-DFoo2') and
  167. Xchange it to 'SDEFS=-DFoobar' (or 'SDEFS=-DFoo2 -DFoobar).  If your
  168. Xsystem is listed below, follow the directions and then you ready to
  169. Xgo to part C, below.
  170. X
  171. X    Sun Microsystems' SunOS/Solaris:  Use an ANSI compiler such as
  172. X      gcc (set CC=gcc in the Makefile), or acc (set CC=acc).
  173. X      The regular 'cc' is not an ANSI compiler.  You could also run
  174. X      something like 'ansi2knr' on the sources and hope it works.
  175. X
  176. X    Hewlett-Packard HP-UX:  If you have 7.0, you'll need to find
  177. X      a copy of <ftp.h> from somewhere (8.0 has it though). Then
  178. X      set CFLAGS= -Aa.  You may also need to use gcc if your
  179. X      compiler is non-ANSI.
  180. X
  181. X    SCO Unix:  Add -DSCO324 to SDEFS, and -lsocket to LIBS.
  182. X
  183. X    Bull DPX/2: Add -DBULL to SDEFS, add -linet to LIBS, and
  184. X      use gcc.
  185. X
  186. X    Sequent's DYNIX: Use gcc and add -DDYNIX (if necessary) to SDEFS.
  187. X      You may also be short several string functions which you will
  188. X      have to get elsewhere.
  189. X
  190. XIf your system doesn't fit any of those, things will be trickier.  Answer
  191. Xall these questions and add to the SDEFS line.  You may want to try
  192. Xeach option one at a time until everything works.
  193. X
  194. X*  Is your system closer to System V or BSD?  Your SDEFS line should have
  195. Xeither -DBSD or -DSYSV.  If you don't know, try leaving it blank first;
  196. Xsome compilers automatically define it for you.
  197. X
  198. X*  Add -DNO_CONST if your compiler chokes on the const directive.  You
  199. Xwill know if you need to add this if the compiler spits out errors saying
  200. Xit doesn't know what 'const' is.
  201. X
  202. X*  Add -DSYSSELECTH if you need <sys/select.h> included for definitions
  203. Xof fd_set, etc.
  204. X
  205. X*  Add -DNO_UNISTDH if you don't have <unistd.h>.  If the compiler complains
  206. Xabout not being able to open <unistd.h> add this.
  207. X
  208. X*  Add -DNO_STDLIBH if you don't have <stdlib.h>.  If the compiler complains
  209. Xabout not being able to open <stdlib.h> add this.
  210. X
  211. X*  Add -DNO_UTIMEH if you don't have <utime.h>.  If the compiler complains
  212. Xabout not being able to open <utime.h> add this.
  213. X
  214. X*  Add -DGETPASS if you would rather use the standard getpass() system
  215. Xcall, instead of our version, Getpass(), which takes more than 8
  216. Xcharacters.  You may want to define this if you are having problems
  217. Xcompiling getpass.c.
  218. X
  219. XIf you haven't given up on our Getpass(), you can try adding -DSGTTYB
  220. Xif you want to use a struct sgttyb instead of a struct termio.  By default,
  221. XBSD systems define SGTTYB automatically.  You can also try adding -DTERMIOS
  222. Xto use a POSIX compliant struct termios instead.  Don't pull your hair out
  223. Xtrying to get the Getpass code to compile;  if it gives you problems just
  224. Xdefine -DGETPASS and hope your system's getpass can handle passwords
  225. Xlonger than 8 characters.
  226. X
  227. X*  Add -DBAD_INETADDR if your inet_addr() function returns a struct in_addr
  228. Xinstead of a u_long, as it should (in DG/UX 5.4.1).
  229. X
  230. X*  Add -DBROKEN_MEMCPY if ncftp mysteriously dumps core when trying to open
  231. Xa remote host.  I'm told that this happens because of some problem in System
  232. XV's sockets don't like fprintf (and memcpy).
  233. X
  234. X*  (Optional) Add -DGETCWDSIZET if your system's getcwd() takes a size_t
  235. Xas the second parameter instead of an int.
  236. X
  237. X*  (Optional) Add -DHERROR if you know you have the herror() system
  238. Xcall.
  239. X
  240. X*  (Optional) Add -DU_WAIT if you know your wait system call takes
  241. Xa pointer to a 'union wait.'  Defined automatically if you define
  242. XBSD.
  243. X
  244. X*  (Optional) Add -DHOSTNAME=\"machine.domain.nam\" if your system
  245. Xdoesn't generate it's own hostname.  To check this, compile ncftp
  246. Xthen run it and type 'set.'  Look at the variable anon-password.
  247. XIf the hostname is wrong, or if it is in the form of 'yourlogin' or
  248. X'yourlogin@machine' instead of 'yourlogin@machine.xxx.yyy,'
  249. Xre-compile it with HOSTNAME set to your machine's address, in the
  250. Xform of 'machine.xxx.yyy.'
  251. X
  252. X*  (Optional) Add -DSTRICT_PROTOS if your compiler wants function prototypes
  253. Xfor all functions, not just non-int-returning ones.
  254. X
  255. X
  256. XPart C.  Program Options:
  257. X------------------------
  258. X
  259. XAdd these as applicable to the PDEFS line in the Makefile.
  260. X
  261. X*   -DCURSES:  Uses curses library to display boldface, underline, etc.
  262. X    By default ncftp uses hard-coded ANSI escapes (^[[1m etc.) to
  263. X    save the 100k or so the curses library adds.  You will also need
  264. X    to edit the LIBS line in the Makefile to add -lcurses.
  265. X
  266. X*   -DSYSLOG:  Define this to have ncftp log connections and transfers
  267. X    to the syslog.
  268. X
  269. X*   -DNO_TIPS:  Define if you want to cut a little fat at the expense of
  270. X     novice users.
  271. X
  272. X*   -DGETLINE: If you want to use Chris Thewalt's getline input line editor
  273. X    and history facility, add this (and see below).
  274. X
  275. X*   -DREADLINE:  If you want to use GNU's readline input line editor and
  276. X    history facility, add this (and see the Makefile). If you do this, you
  277. X    also need to add -DCURSES (see above).
  278. X
  279. X*    -DSOCKS: NcFTP is now compatible with the Socks library by David Koblas,
  280. X    at koblas@sgi.com.  This lets you use NcFTP with a "firewall" gateway
  281. X    for enhanced site security.  You can get the latest version from
  282. X    netcom.com:/pub/koblas.  After you have compiled it, compile NcFTP
  283. X    with -DSOCKS added to PDEFS, and the pathname of the Rconnect.o file
  284. X    added to LIBS.
  285. X    
  286. X*   -DDB_ERRS:  Define this if you want my Perror() function to be more
  287. X    verbose.  You may want to do this if you are a programmer examining this
  288. X    code, and want to know where in the source the Perror's are coming
  289. X    from.
  290. X
  291. XPart D.  Sending me patches:
  292. X---------------------------
  293. X
  294. XI apologize in advance for problems that my coding style may cause.  The code
  295. Xitself is formatted such that each indent-level is a tab (intended to be
  296. Xequivalent to 4 spaces), and not spaces nor a combination of tabs and spaces.
  297. XThe reason for this, besides being more logical to me, is that I use a
  298. XMacintosh editor to compose the code and I prefer it's indenting method.
  299. XAnother problem in my coding-style is that I write C-code intended for ANSI
  300. XC compilers.  This means that I will use the new-style function declarations
  301. Xand function prototypes, like:
  302. X
  303. X
  304. X   long Foobar(long, long, char *);
  305. X   long Foobar(long t0, long t1, char *str)
  306. X   {
  307. X   }
  308. X
  309. Xas opposed to:
  310. X
  311. X   long Foobar();
  312. X   long Foobar(t0, t1, str)
  313. X       long t0, t1;
  314. X       char *str;
  315. X   {
  316. X   }
  317. X
  318. XAnother thing may annoy you is that I always use function prototypes for any
  319. Xfunction I call, including functions that return an int.  This is a good
  320. Xpractice that I learned from the Macintosh programming world.  
  321. X
  322. XSo if you send me patches, please conform to my coding style so that 'patch'
  323. Xwon't screw up, and also that some continuity will be preserved.
  324. X
  325. XBefore you make your patch, you should be sure that you are using the most
  326. Xcurrent version of the program.  This is especially important if you are
  327. Xreporting a bug; I may have already fixed it!  See the above info to get it
  328. Xvia ftp.  Major versions are always posted to comp.sources.misc.  Bug reports
  329. Xare posted to comp.sources.bugs.  Patches that need to be posted ASAP are
  330. Xposted to this group first, so it is advisable that you check this group.
  331. X
  332. XIf you make changes to the code, surround your code in #ifdef/#endif blocks.
  333. XInstead of doing things like #ifdef SunOS, use a name that describes the
  334. Xbug fix or feature, and not your system type, like #ifdef NO_UNISTDH,
  335. Xor #ifdef GETLINE.  That way in case another system has the same problem,
  336. Xit can be added to sys.h without cluttering up the source code.  Then, add
  337. Xthe symbol you used to the end of cmds.c, in the 'CPP Hell' part of the
  338. Xversion() command.  You'll see a list of CPP symbols, so just add yours in
  339. Xa similar fashion, like #ifdef GETLINE/DStrs[nDStrs++] = "GETLINE";/#endif.
  340. X
  341. XIf you don't know how to make a patch, here's how to do it.  Things are easy
  342. Xif you've only changed one file.  Then all you need to do pipe the output of
  343. Xdiff -c into a file and send it to me, i.e. "diff -c cmds.c cmds.c.hack >pch."
  344. XIf you've hacked several files, the way I do it is to keep the originals in
  345. Xone directory (you did make a copy of everything first didn't you?) and the
  346. Xrevisions in another directory.  Then you change directory to the one with the
  347. Xoriginals and do "diff -c . ../revisions > ../pch."
  348. X
  349. X--mg (mgleason@cse.unl.edu)
  350. END_OF_FILE
  351.   if test 11962 -ne `wc -c <'README'`; then
  352.     echo shar: \"'README'\" unpacked with wrong size!
  353.   fi
  354.   # end of 'README'
  355. fi
  356. if test -f 'cmds.c' -a "${1}" != "-c" ; then 
  357.   echo shar: Will not clobber existing file \"'cmds.c'\"
  358. else
  359.   echo shar: Extracting \"'cmds.c'\" \(38637 characters\)
  360.   sed "s/^X//" >'cmds.c' <<'END_OF_FILE'
  361. X/* cmds.c */
  362. X
  363. X/*  $RCSfile: cmds.c,v $
  364. X *  $Revision: 14020.14 $
  365. X *  $Date: 93/07/09 11:31:53 $
  366. X */
  367. X
  368. X#include "sys.h"
  369. X#include <sys/types.h>
  370. X#include <sys/param.h>
  371. X
  372. X#include <sys/wait.h>
  373. X
  374. X#include <sys/stat.h>
  375. X#include <sys/socket.h>
  376. X#include <arpa/ftp.h>
  377. X#include <setjmp.h>
  378. X#include <signal.h>
  379. X#include <string.h>
  380. X#include <errno.h>
  381. X#include <netdb.h>
  382. X#include <netinet/in.h>
  383. X#include <arpa/inet.h>
  384. X#include <ctype.h>
  385. X#include <sys/time.h>
  386. X#include <time.h>
  387. X
  388. X#ifdef SYSLOG
  389. X#    include <syslog.h>
  390. X#endif
  391. X
  392. X#ifndef NO_UNISTDH
  393. X#    include <unistd.h>
  394. X#endif
  395. X
  396. X#include "util.h"
  397. X#include "cmds.h"
  398. X#include "main.h"
  399. X#include "ftp.h"
  400. X#include "ftprc.h"
  401. X#include "getpass.h"
  402. X#include "glob.h"
  403. X#include "set.h"
  404. X#include "defaults.h"
  405. X#include "copyright.h"
  406. X
  407. X/* cmds.c globals */
  408. Xint                    curtype;            /* file transfer type */
  409. Xchar                *typeabbrs = "abiet";
  410. Xstr32                curtypename;        /* name of file transfer type */
  411. Xint                    verbose;             /* verbosity level of output */
  412. Xint                    mprompt;            /* interactively prompt on m* cmds */
  413. Xint                    debug;                /* debugging level */
  414. Xint                    options;            /* used during socket creation */
  415. Xint                    macnum;                /* number of defined macros */
  416. Xint                    paging = 0;
  417. Xint                    creating = 0;
  418. Xstruct macel        macros[MAXMACROS];
  419. Xchar                *macbuf;            /* holds ALL macros */
  420. Xjmp_buf                jabort;
  421. Xchar                *mname;                /* name of current m* command */
  422. Xint                    activemcmd;            /* flag: if != 0, then active multi command */
  423. Xint                    warnNoLSFlagsWithWildcards = 0;
  424. X                                        /* Tells whether the user has been
  425. X                                         * warned about not being able to use
  426. X                                         * flags with ls when using wildcards.
  427. X                                         */
  428. Xlongstring            cwd;                /* current remote directory */
  429. Xlongstring            lcwd;                /* current local directory */
  430. XHostname            lasthostname;        /* name of last host w/ lookup(). */
  431. Xint                    logged_in = 0;        /* TRUE if connected and user/pw OK. */
  432. Xint                    is_ls = 0;            /* are we doing an ls?  if so, then
  433. X                                           read input into a line buffer
  434. X                                           for re-use. */
  435. Xextern int                    buffer_only;
  436. Xstruct lslist               *lshead = NULL;    /* hold last output from host */
  437. Xstruct lslist               *lstail = NULL;
  438. X
  439. X/* cmds.c externs */
  440. Xextern char                    *globerr, *home, *reply_string;
  441. Xextern int                    margc, connected, ansi_escapes;
  442. Xextern int                    code, connected;
  443. Xextern int                    toatty, fromatty;
  444. Xextern int                    data, progress_meter, remote_is_unix;
  445. Xextern int                    parsing_rc, keep_recent;
  446. Xextern char                    *altarg, *line, *margv[];
  447. Xextern char                    *globchars;
  448. Xextern Hostname                hostname;
  449. Xextern string                progname, pager, anon_password;
  450. Xextern string                prompt, version, indataline;
  451. Xextern longstring            logfname;
  452. Xextern long                    logsize;
  453. Xextern size_t                xferbufsize;
  454. Xextern struct servent        serv;
  455. Xextern struct cmd            cmdtab[];
  456. Xextern struct userinfo        uinfo;
  457. Xextern FILE                    *cin, *cout, *logf;
  458. Xextern int                    Optind;
  459. Xextern char                    *Optarg;
  460. Xextern int                    Optind;
  461. Xextern char                    *Optarg;
  462. X
  463. X#ifdef STRICT_PROTOS
  464. Xextern int gethostname(char *, int), getdomainname(char *, int);
  465. X#endif
  466. X
  467. X
  468. Xstruct types types[] = {
  469. X    { "ascii",  "A",    TYPE_A, 0 },
  470. X    { "binary", "I",    TYPE_I, 0 },
  471. X    { "image",  "I",    TYPE_I, 0 },
  472. X    { "ebcdic", "E",    TYPE_E, 0 },
  473. X    { "tenex",  "L",    TYPE_L, "8" },
  474. X    0
  475. X};
  476. X
  477. X
  478. X
  479. Xlong GetDateAndSize(char *fName, unsigned long *mod_time)
  480. X{
  481. X    char *cp, *np;
  482. X    string lsline;
  483. X    long size = 0L;
  484. X    int n, v;
  485. X    struct lslist *saved;
  486. X    
  487. X    *mod_time = 0;
  488. X    v = verbose; verbose = V_QUIET;
  489. X    is_ls = 1;
  490. X    buffer_only = 1;
  491. X    saved = lshead;
  492. X    lshead = NULL;
  493. X    (void) recvrequest("LIST", "-", fName, "w");
  494. X    is_ls = 0;
  495. X    buffer_only = 0;
  496. X    verbose = v;
  497. X    if (lshead == NULL) {
  498. X        PurgeLineBuffer();
  499. X        lshead = saved;
  500. X        goto aa;
  501. X    }
  502. X    (void) Strncpy(lsline, lshead->string);
  503. X    PurgeLineBuffer();
  504. X    lshead = saved;
  505. X
  506. X    if (code >= 400 && code < 500)
  507. X        goto aa;
  508. X
  509. X    /* See if this line looks like a unix-style ls line. 
  510. X     * If so, we can grab the date and size from it.
  511. X     */    
  512. X    if (strpbrk(lsline, "-dlsbcp") == lsline) {
  513. X        /* See if it looks like a typical '-rwxrwxrwx' line. */
  514. X        cp = lsline + 1;
  515. X        if (*cp != 'r' && *cp != '-')
  516. X            goto aa;
  517. X        ++cp;
  518. X        if (*cp != 'w' && *cp != '-')
  519. X            goto aa;
  520. X        cp += 2;
  521. X        if (*cp != 'r' && *cp != '-')
  522. X            goto aa;
  523. X 
  524. X         /* skip mode, links, owner (and possibly group) */
  525. X         for (n = 0; n < 4; n++) {
  526. X             np = cp;
  527. X             while (*cp != '\0' && !isspace(*cp))
  528. X                 cp++;
  529. X             while (*cp != '\0' &&  isspace(*cp))
  530. X                 cp++;
  531. X         }
  532. X         if (!isdigit(*cp))
  533. X             cp = np;    /* back up (no group) */
  534. X         (void) sscanf(cp, "%ld%n", &size, &n);
  535. X 
  536. X         *mod_time = UnLSDate(cp + n + 1);
  537. X
  538. X        if (size < 100) {
  539. X            /* May be the size of a link to the file, instead of the file. */
  540. X            if ((cp = strstr(lsline, " -> ")) != NULL) {
  541. X                /* Yes, it was a link. */
  542. X                size = GetDateAndSize(cp + 4, mod_time); /* Try the file. */
  543. X            }
  544. X        }
  545. X    }    
  546. Xaa:
  547. X    return (size);
  548. X}    /* GetDateAndSize */
  549. X
  550. X
  551. X
  552. X
  553. Xint _settype(char *typename)
  554. X{
  555. X    register struct types    *p;
  556. X    int                        comret, c;
  557. X    string                    cmd;
  558. X    char                    *cp;
  559. X 
  560. X    c = isupper(*typename) ? tolower(*typename) : (*typename);
  561. X    if ((cp = index(typeabbrs, c)) != NULL)
  562. X        p = &types[(int) (cp - typeabbrs)];
  563. X    else {
  564. X        (void) printf("%s: unknown type\n", typename);
  565. X        return USAGE;
  566. X    }
  567. X    if (c == 't')
  568. X        (void) strcpy(cmd, "TYPE L 8");
  569. X    else    
  570. X        (void) sprintf(cmd, "TYPE %s", p->t_mode);
  571. X    comret = command(cmd);
  572. X    if (comret == COMPLETE) {
  573. X        (void) Strncpy(curtypename, p->t_name);
  574. X        curtype = p->t_type;
  575. X    }
  576. X    return NOERR;
  577. X}    /* _settype */
  578. X
  579. X
  580. X
  581. X
  582. Xint SetTypeByNumber(int i)
  583. X{
  584. X    char tstr[4], *tp = tstr, c;
  585. X
  586. X    tp[1] = c = 0;
  587. X    switch (i) {
  588. X        case TYPE_A: c = 'a'; break;
  589. X        case TYPE_I: c = 'b'; break;
  590. X        case TYPE_E: c = 'e'; break;
  591. X        case TYPE_L: c = 't';
  592. X    }
  593. X    *tp = c;
  594. X    return (_settype(tp));
  595. X}    /* SetTypeByNumber */
  596. X
  597. X
  598. X
  599. X
  600. X/*
  601. X * Set transfer type.
  602. X */
  603. Xint settype(int argc, char **argv)
  604. X{
  605. X    int result = NOERR;
  606. X
  607. X    if (argc > 2) {
  608. X        result = USAGE;
  609. X    } else {
  610. X        if (argc < 2)
  611. X            goto xx;
  612. X        result = _settype(argv[1]);
  613. X        if (IS_VVERBOSE)
  614. Xxx:            (void) printf("Using %s mode to transfer files.\n", curtypename);
  615. X    }
  616. X    return result;
  617. X}    /* settype */
  618. X
  619. X
  620. X
  621. X
  622. X/*ARGSUSED*/
  623. Xint setbinary(int argc, char **argv) {    return (_settype("binary")); }
  624. X/*ARGSUSED*/
  625. Xint setascii(int argc, char **argv) {    return (_settype("ascii")); }
  626. X
  627. X
  628. X
  629. X/*
  630. X * Send a single file.
  631. X */
  632. Xint put(int argc, char **argv)
  633. X{
  634. X    char *cmd;
  635. X
  636. X    if (argc == 2) {
  637. X        argc++;
  638. X        argv[2] = argv[1];
  639. X    }
  640. X    if (argc < 2)
  641. X        argv = re_makeargv("(local-file) ", &argc);
  642. X    if (argc < 2) {
  643. Xusage:
  644. X        return USAGE;
  645. X    }
  646. X    if (argc < 3)
  647. X        argv = re_makeargv("(remote-file) ", &argc);
  648. X    if (argc < 3) 
  649. X        goto usage;
  650. X    cmd = (argv[0][0] == 'a') ? "APPE" : "STOR";
  651. X    (void) sendrequest(cmd, argv[1], argv[2]);
  652. X    return NOERR;
  653. X}    /* put */
  654. X
  655. X
  656. X
  657. X
  658. X/*
  659. X * Send multiple files.
  660. X */
  661. Xint mput(int argc, char **argv)
  662. X{
  663. X    register int i;
  664. X    sig_t oldintr;
  665. X    char *tp;
  666. X
  667. X    if (argc < 2)
  668. X        argv = re_makeargv("(local-files) ", &argc);
  669. X    if (argc < 2) {
  670. X        return USAGE;
  671. X    }
  672. X    mname = argv[0];
  673. X    activemcmd = 1;
  674. X    oldintr = Signal(SIGINT, mabort);
  675. X    (void) setjmp(jabort);
  676. X    for (i = 1; i < argc; i++) {
  677. X        register char **cpp, **gargs;
  678. X
  679. X        gargs = glob(argv[i]);
  680. X        if (globerr != NULL) {
  681. X            (void) printf("%s\n", globerr);
  682. X            if (gargs) {
  683. X                blkfree(gargs);
  684. X                free(gargs);
  685. X            }
  686. X            continue;
  687. X        }
  688. X        for (cpp = gargs; cpp && *cpp != NULL; cpp++) {
  689. X            if (activemcmd && confirm(argv[0], *cpp)) {
  690. X                tp = *cpp;
  691. X                (void) sendrequest("STOR", *cpp, tp);
  692. X                if (!activemcmd && fromatty) {
  693. X                    if (confirm("Continue with","mput")) {
  694. X                        activemcmd++;
  695. X                    }
  696. X                }
  697. X            }
  698. X        }
  699. X        if (gargs != NULL) {
  700. X            blkfree(gargs);
  701. X            free(gargs);
  702. X        }
  703. X    }
  704. X    (void) Signal(SIGINT, oldintr);
  705. X    activemcmd = 0;
  706. X    return NOERR;
  707. X}    /* mput */
  708. X
  709. X
  710. X
  711. X
  712. Xint rem_glob_one(char *pattern)
  713. X{
  714. X    int            oldverbose, result = 0;
  715. X    char        *cp;
  716. X    string        str, tname;
  717. X    FILE        *ftemp;
  718. X
  719. X    /* Check for wildcard characters. */
  720. X    if (*pattern == '|' || strpbrk(pattern, globchars) == NULL)
  721. X        return 0;
  722. X
  723. X    (void) tmp_name(tname);
  724. X    oldverbose = verbose;
  725. X    verbose = V_QUIET;
  726. X    (void) recvrequest ("NLST", tname, pattern, "w");
  727. X    verbose = oldverbose;
  728. X    ftemp = fopen(tname, "r");
  729. X    if (ftemp == NULL || FGets(str, ftemp) == NULL) {
  730. X        if (NOT_VQUIET)
  731. X            (void) printf("%s: no match.\n", pattern);
  732. X        result = -1;
  733. X        goto done;
  734. X    }
  735. X    if ((cp = index(str, '\n')) != NULL)
  736. X        *cp = '\0';
  737. X    (void) strcpy(pattern, str);
  738. X    cp = FGets(str, ftemp);
  739. X    /* It is an error if the pattern matched more than one file. */
  740. X    if (cp != NULL) {
  741. X        if (NOT_VQUIET)
  742. X            (void) printf("?Ambiguous remote file name.\n");
  743. X        result = -2;
  744. X    }
  745. Xdone:
  746. X    if (ftemp != NULL)
  747. X        (void) fclose(ftemp);
  748. X    (void) unlink(tname);
  749. X    return (result);
  750. X}    /* rem_glob_one */
  751. X
  752. X
  753. X
  754. X
  755. X/*
  756. X * Receive (and maybe page) one file.
  757. X */
  758. Xint get(int argc, char **argv)
  759. X{
  760. X    string local_file;
  761. X    char remote_file[256];
  762. X    char *cp;
  763. X    int oldtype = curtype;
  764. X
  765. X    /* paging mode is set if the command name is 'page' or 'more.' */
  766. X    paging = (**argv != 'g');
  767. X
  768. X    if (argc < 2)
  769. X        argv = re_makeargv("(remote-file) ", &argc);
  770. X
  771. X    if (argc < 2) {
  772. X        return USAGE;
  773. X    }
  774. X    cp = Strncpy(remote_file, argv[1]);
  775. X    argv[1] = cp;
  776. X    if (rem_glob_one(argv[1]) < 0)
  777. X        return CMDERR;
  778. X
  779. X    if (paging) {
  780. X        size_t len = strlen(remote_file);
  781. X
  782. X        /* Run compressed remote files through zcat, then the pager. */
  783. X        if (strlen(remote_file) > 2 && (remote_file[len - 1] == 'Z' || remote_file[len - 1] == 'z') && remote_file[len - 2] == '.') {
  784. X            (void) _settype("b");
  785. X            (void) sprintf(local_file, "|%s ", ZCAT);
  786. X            argv[2] = Strncat(local_file, pager);
  787. X        } else {
  788. X            /* Try to use text mode for paging, so newlines get converted. */
  789. X            (void) _settype("a");
  790. X            argv[2] = pager;
  791. X        }
  792. X    } else {
  793. X        /* normal get */
  794. X        if (argc == 2) {
  795. X            (void) Strncpy(local_file, argv[1]);
  796. X            argv[2] = local_file;
  797. X        } else {
  798. X            if (argc < 3)
  799. X                argv = re_makeargv("(local-file) ", &argc);
  800. X            if (argc < 3) 
  801. X                return USAGE;
  802. X            if (!globulize(&argv[2])) {
  803. X                return CMDERR;
  804. X            }
  805. X        }
  806. X    }
  807. X    (void) recvrequest("RETR", argv[2], argv[1], "w");
  808. X    if (paging) {
  809. X        (void) SetTypeByNumber(oldtype);    /* Restore it to what it was. */
  810. X        paging = 0;
  811. X    }
  812. X    return NOERR;
  813. X}    /* get */
  814. X
  815. X
  816. X
  817. X/*ARGSUSED*/
  818. Xvoid mabort SIG_PARAMS
  819. X{
  820. X    (void) printf("\n");
  821. X    (void) fflush(stdout);
  822. X    if (activemcmd && fromatty) {
  823. X        if (confirm("Continue with", mname)) {
  824. X            longjmp(jabort,0);
  825. X        }
  826. X    }
  827. X    activemcmd = 0;
  828. X    longjmp(jabort,0);
  829. X}    /* mabort */
  830. X
  831. X
  832. X
  833. X
  834. X/*
  835. X * Get multiple files.
  836. X */
  837. Xint mget(int argc, char **argv)
  838. X{
  839. X    char *cp;
  840. X    longstring local;
  841. X    sig_t oldintr;
  842. X
  843. X    if (argc < 2)
  844. X        argv = re_makeargv("(remote-files) ", &argc);
  845. X    if (argc < 2) {
  846. X        return USAGE;
  847. X    }
  848. X    mname = argv[0];
  849. X    activemcmd = 1;
  850. X    oldintr = Signal(SIGINT, mabort);
  851. X    (void) setjmp(jabort);
  852. X    while ((cp = remglob(argv)) != NULL) {
  853. X        if (*cp == '\0') {
  854. X            activemcmd = 0;
  855. X            continue;
  856. X        }
  857. X        if (activemcmd && confirm(argv[0], cp)) {
  858. X            (void) Strncpy(local, cp);
  859. X            (void) recvrequest("RETR", local, cp, "w");
  860. X            if (!activemcmd && fromatty) {
  861. X                if (confirm("Continue with","mget")) {
  862. X                    activemcmd++;
  863. X                }
  864. X            }
  865. X        }
  866. X    }
  867. X    (void) Signal(SIGINT,oldintr);
  868. X    activemcmd = 0;
  869. X    return NOERR;
  870. X}    /* mget */
  871. X
  872. X
  873. X
  874. X
  875. Xchar *remglob(char *argv[])
  876. X{
  877. X    static FILE            *ftemp = NULL;
  878. X    int                    oldverbose, i;
  879. X    char                *cp, *mode;
  880. X    static string        tmpname, str;
  881. X
  882. X    if (!activemcmd) {
  883. Xxx:
  884. X        if (ftemp) {
  885. X            (void) fclose(ftemp);
  886. X            ftemp = NULL;
  887. X            (void) unlink(tmpname);
  888. X        }
  889. X        return(NULL);
  890. X    }
  891. X    if (ftemp == NULL) {
  892. X        (void) tmp_name(tmpname);
  893. X        oldverbose = verbose, verbose = V_QUIET;
  894. X        for (mode = "w", i=1; argv[i] != NULL; i++, mode = "a")
  895. X            (void) recvrequest ("NLST", tmpname, argv[i], mode);
  896. X        verbose = oldverbose;
  897. X        ftemp = fopen(tmpname, "r");
  898. X        if (ftemp == NULL) {
  899. X            (void) printf("Can't find list of remote files (%s), oops.\n", tmpname);
  900. X            return (NULL);
  901. X        }
  902. X    }
  903. X    if (FGets(str, ftemp) == NULL) 
  904. X        goto xx;
  905. X    if ((cp = index(str, '\n')) != NULL)
  906. X        *cp = '\0';
  907. X    return (str);
  908. X}    /* remglob */
  909. X
  910. X
  911. X/*
  912. X * Turn on/off printing of server echo's, messages, and statistics.
  913. X */
  914. Xint setverbose(int argc, char **argv)
  915. X{
  916. X    if (argc > 1)
  917. X        set_verbose(argv[1], 0);
  918. X    else set_verbose(argv[1], -1);
  919. X    return NOERR;
  920. X}    /* setverbose */
  921. X
  922. X
  923. X
  924. X/*
  925. X * Toggle interactive prompting
  926. X * during mget, mput, and mdelete.
  927. X */
  928. Xint setprompt(int argc, char **argv)
  929. X{
  930. X    if (argc > 1)
  931. X        mprompt = StrToBool(argv[1]);
  932. X    else mprompt = !mprompt;
  933. X    if (IS_VVERBOSE)
  934. X        (void) printf("Interactive prompting for m* commmands %s.\n", onoff(mprompt));
  935. X    return NOERR;
  936. X}    /* setprompt */
  937. X
  938. X
  939. X
  940. X
  941. Xvoid fix_options(void)
  942. X{
  943. X    if (debug)
  944. X        options |= SO_DEBUG;
  945. X    else
  946. X    options &= ~SO_DEBUG;
  947. X}   /* fix_options */
  948. X
  949. X
  950. X/*
  951. X * Set debugging mode on/off and/or
  952. X * set level of debugging.
  953. X */
  954. Xint setdebug(int argc, char **argv)
  955. X{
  956. X    int val;
  957. X
  958. X    if (argc > 1) {
  959. X        val = StrToBool(argv[1]);
  960. X        if (val < 0) {
  961. X            (void) printf("%s: bad debugging value.\n", argv[1]);
  962. X            return USAGE;
  963. X        }
  964. X    } else
  965. X        val = !debug;
  966. X    debug = val;
  967. X    fix_options();
  968. X    if (IS_VVERBOSE)
  969. X        (void) printf("Debugging %s (debug=%d).\n", onoff(debug), debug);
  970. X    return NOERR;
  971. X}    /* debug */
  972. X
  973. X
  974. X
  975. X/*
  976. X * Set current working directory
  977. X * on remote machine.
  978. X */
  979. Xint cd(int argc, char **argv)
  980. X{
  981. X    if (argc < 2)
  982. X        argv = re_makeargv("(remote-directory) ", &argc);
  983. X    if (argc < 2) {
  984. X        return USAGE;
  985. X    }
  986. X    (void) _cd(argv[1]);
  987. X    return NOERR;
  988. X}    /* cd */
  989. X
  990. X
  991. X
  992. X
  993. Xint implicit_cd(char *dir)
  994. X{
  995. X    int i, j = 0;
  996. X    
  997. X    if (connected) {
  998. X        i = verbose;
  999. X        /* Special verbosity level that ignores errors and prints other stuff,
  1000. X         * so you will get just the unknown command message and not an error
  1001. X         * message from cd.
  1002. X         */
  1003. X        verbose = V_IMPLICITCD;
  1004. X        j = _cd(dir);
  1005. X        verbose = i;
  1006. X    }
  1007. X    return j;
  1008. X}    /* implicit_cd */
  1009. X
  1010. X
  1011. X
  1012. X
  1013. Xint _cd(char *dir)
  1014. X{
  1015. X    register char *cp;
  1016. X    int result = 0;
  1017. X    string str;
  1018. X
  1019. X    if (dir == NULL)
  1020. X        goto getrwd;
  1021. X    /* Won't work because glob really is a ls, so 'cd pu*' will match
  1022. X     * pub/README, pub/file2, etc.
  1023. X     *    if (result = rem_glob_one(dir) < 0)
  1024. X     *    return result;
  1025. X     */
  1026. X    if (strncmp(dir, "CDUP", (size_t) 4) == 0)
  1027. X        (void) Strncpy(str, dir);
  1028. X    else
  1029. X        (void) sprintf(str, "CWD %s", dir);
  1030. X    if (command(str) != 5) {
  1031. Xgetrwd:
  1032. X        (void) quiet_command("PWD");
  1033. X        cp = rindex(reply_string, '\"');
  1034. X        if (cp != NULL) {
  1035. X            result = 1;
  1036. X            *cp = '\0';
  1037. X            cp = index(reply_string, '\"');
  1038. X            if (cp != NULL)
  1039. X                (void) Strncpy(cwd, ++cp);
  1040. X        }
  1041. X    }
  1042. X    dbprintf("Current remote directory is \"%s\"\n", cwd);
  1043. X    return (result);
  1044. X}    /* _cd */
  1045. X
  1046. X
  1047. X
  1048. X
  1049. X/*
  1050. X * Set current working directory
  1051. X * on local machine.
  1052. X */
  1053. Xint lcd(int argc, char **argv)
  1054. X{
  1055. X    if (argc < 2)
  1056. X        argc++, argv[1] = home;
  1057. X    if (argc != 2) {
  1058. X        return USAGE;
  1059. X    }
  1060. X    if (!globulize(&argv[1])) {
  1061. X        return CMDERR;
  1062. X    }
  1063. X    if (chdir(argv[1]) < 0) {
  1064. X        PERROR("lcd", argv[1]);
  1065. X        return CMDERR;
  1066. X    }
  1067. X    (void) get_cwd(lcwd, (int) sizeof(lcwd));
  1068. X    if (IS_VVERBOSE) 
  1069. X        (void) printf("Local directory now %s\n", lcwd);
  1070. X    return NOERR;
  1071. X}    /* lcd */
  1072. X
  1073. X
  1074. X
  1075. X
  1076. X/*
  1077. X * Delete a single file.
  1078. X */
  1079. Xint do_delete(int argc, char **argv)
  1080. X{
  1081. X    string str;
  1082. X
  1083. X    if (argc < 2)
  1084. X        argv = re_makeargv("(remote file to delete) ", &argc);
  1085. X    if (argc < 2) {
  1086. X        return USAGE;
  1087. X    }
  1088. X    if (rem_glob_one(argv[1]) == 0) {
  1089. X        (void) sprintf(str, "DELE %s", argv[1]);
  1090. X        (void) command(str);
  1091. X    }
  1092. X    return NOERR;
  1093. X}    /* do_delete */
  1094. X
  1095. X
  1096. X
  1097. X
  1098. X/*
  1099. X * Delete multiple files.
  1100. X */
  1101. Xint mdelete(int argc, char **argv)
  1102. X{
  1103. X    char *cp;
  1104. X    sig_t oldintr;
  1105. X    string str;
  1106. X
  1107. X    if (argc < 2)
  1108. X        argv = re_makeargv("(remote-files) ", &argc);
  1109. X    if (argc < 2) {
  1110. X        return USAGE;
  1111. X    }
  1112. X    mname = argv[0];
  1113. X    activemcmd = 1;
  1114. X    oldintr = Signal(SIGINT, mabort);
  1115. X    (void) setjmp(jabort);
  1116. X    while ((cp = remglob(argv)) != NULL) {
  1117. X        if (*cp == '\0') {
  1118. X            activemcmd = 0;
  1119. X            continue;
  1120. X        }
  1121. X        if (activemcmd && confirm(argv[0], cp)) {
  1122. X            (void) sprintf(str, "DELE %s", cp);
  1123. X            (void) command(str);
  1124. X            if (!activemcmd && fromatty) {
  1125. X                if (confirm("Continue with", "mdelete")) {
  1126. X                    activemcmd++;
  1127. X                }
  1128. X            }
  1129. X        }
  1130. X    }
  1131. X    (void) Signal(SIGINT, oldintr);
  1132. X    activemcmd = 0;
  1133. X    return NOERR;
  1134. X}    /* mdelete */
  1135. X
  1136. X
  1137. X
  1138. X
  1139. X/*
  1140. X * Rename a remote file.
  1141. X */
  1142. Xint renamefile(int argc, char **argv)
  1143. X{
  1144. X    string str;
  1145. X
  1146. X    if (argc < 2)
  1147. X        argv = re_makeargv("(from-name) ", &argc);
  1148. X    if (argc < 2) {
  1149. Xusage:
  1150. X        return USAGE;
  1151. X    }
  1152. X    if (argc < 3)
  1153. X        argv = re_makeargv("(to-name) ", &argc);
  1154. X    if (argc < 3)
  1155. X        goto usage;
  1156. X    if (rem_glob_one(argv[1]) < 0)
  1157. X        return CMDERR;
  1158. X    (void) sprintf(str, "RNFR %s", argv[1]);
  1159. X    if (command(str) == CONTINUE) {
  1160. X        (void) sprintf(str, "RNTO %s", argv[2]);
  1161. X        (void) command(str);
  1162. X    }
  1163. X    return NOERR;
  1164. X}    /* renamefile */
  1165. X
  1166. X
  1167. X
  1168. X/*
  1169. X * Get a directory listing
  1170. X * of remote files.
  1171. X */
  1172. Xint ls(int argc, char **argv)
  1173. X{
  1174. X    char        *whichcmd, *cp;
  1175. X    str32        lsflags;
  1176. X    string        remote, local, str;
  1177. X    int            listmode, pagemode, i;
  1178. X
  1179. X    PurgeLineBuffer();
  1180. X    pagemode = 0;
  1181. X    switch (**argv) {
  1182. X        case 'p':                            /* pls, pdir, pnlist */
  1183. X            pagemode = 1;
  1184. X            listmode = argv[0][1] == 'd';
  1185. X            break;
  1186. X        case 'd':                            /* dir */
  1187. X            listmode = 1;
  1188. X            break;
  1189. X        default:                            /* ls, nlist */
  1190. X            listmode = 0;
  1191. X    }
  1192. X    whichcmd = listmode ? "LIST" : "NLST";
  1193. X
  1194. X    (void) strncpy(local, (pagemode ? pager : "-"), sizeof(local));
  1195. X    remote[0] = lsflags[0] = 0;
  1196. X    
  1197. X    /* Possible scenarios:
  1198. X     *  1.    ls
  1199. X     *  2.    ls -flags
  1200. X     *  3.    ls directory
  1201. X     *  4.  ls -flags >outfile
  1202. X     *  5.  ls directory >outfile
  1203. X     *  6.  ls -flags directory
  1204. X     *  7.  ls -flags directory >outfile
  1205. X     *
  1206. X     * Note that using a wildcard will choke with flags.  I.e., don't do
  1207. X     * "ls -CF *.tar," but instead do "ls *.tar."
  1208. X     */
  1209. X
  1210. X    for (i=1; i<argc; i++) {
  1211. X        switch (argv[i][0]) {
  1212. X            case '-': 
  1213. X                /*
  1214. X                 * If you give more than one set of flags, concat the each
  1215. X                 * additional set to the first one (without the dash).
  1216. X                 */
  1217. X                (void) strncat(lsflags, (argv[i] + (lsflags[0] == '-')), sizeof(lsflags));
  1218. X                break;
  1219. X            case '|':
  1220. X            case '>': (void) Strncpy(local, argv[i] + (argv[i][0] == '>')); break;
  1221. X            default:  
  1222. X                cp = argv[i];
  1223. X                /*
  1224. X                 * In case you want to get a remote file called '--README--'
  1225. X                 * or '>README,' you can use '\--README--' and '\>README.'
  1226. X                 */
  1227. X                if ((cp[1] != 0) && (*cp == '\\'))
  1228. X                    ++cp;
  1229. X                if (remote[0] != 0) {
  1230. X                    (void) Strncat(remote, " ");
  1231. X                    (void) Strncat(remote, cp);
  1232. X                } else {
  1233. X                    (void) Strncpy(remote, cp);
  1234. X                }
  1235. X        }    /* end switch */    
  1236. X    }        /* end loop */
  1237. X
  1238. X    /*
  1239. X     *    If we are given an ls with some flags, make sure we use 
  1240. X     *    columnized output (-C) unless one column output (-1) is
  1241. X     *    specified.
  1242. X     */
  1243. X    if (!listmode) {
  1244. X        if (lsflags[0] != 0) {
  1245. X            (void) Strncpy(str, lsflags);
  1246. X            for (cp = str + 1; *cp; cp++)
  1247. X                if (*cp == '1')
  1248. X                    goto aa;
  1249. X            (void) sprintf(lsflags, "-FC%s", str + 1);
  1250. X        } else {
  1251. X            if (remote_is_unix)
  1252. X                (void) strcpy(lsflags, "-FC");
  1253. X        }
  1254. X        /* As noted above, we can't use -flags if the user gave a
  1255. X         * wildcard expr.
  1256. X         */
  1257. X        if (remote_is_unix && (strpbrk(remote, globchars) != NULL)) {
  1258. X            lsflags[0] = 0;
  1259. X            /* Warn the user what's going on. */
  1260. X            if ((warnNoLSFlagsWithWildcards == 0) && NOT_VQUIET) {
  1261. X                (void) fprintf(stderr, "Warning: ls flags disabled with wildcard expressions.\n");
  1262. X                warnNoLSFlagsWithWildcards++;
  1263. X            }
  1264. X        }
  1265. X    }
  1266. X
  1267. Xaa:    if (strcmp(local, "-") != 0) {
  1268. X        char *lp = local;
  1269. X
  1270. X        if ((!globulize(&lp)) || ((local[0] != '|') && (!confirm("Output to local-file: ", local)))) {
  1271. X            return CMDERR;
  1272. X        } 
  1273. X        if (lp != local) {
  1274. X            (void) Strncpy(str, lp);
  1275. X            (void) Strncpy(local, str);
  1276. X        }
  1277. X    }
  1278. X    is_ls = 1; /* tells getreply() to start saving input to a buffer. */
  1279. X    (void) Strncpy(str, remote);
  1280. X    if (lsflags[0] && remote[0])
  1281. X        (void) sprintf(remote, "%s%c%s", lsflags, LS_FLAGS_AND_FILE, str);
  1282. X    else
  1283. X        (void) strncpy(remote, lsflags[0] ? lsflags : str, sizeof(remote));
  1284. X    (void) recvrequest(whichcmd, local, (remote[0] == 0 ? NULL : remote), "w");
  1285. X    is_ls=0;
  1286. X    return NOERR;
  1287. X}    /* ls */
  1288. X
  1289. X
  1290. X
  1291. X/*
  1292. X * Do a shell escape
  1293. X */
  1294. X/*ARGSUSED*/
  1295. Xint shell(int argc, char **argv)
  1296. X{
  1297. X    int                pid;
  1298. X    sig_t            old1, old2;
  1299. X    char            *theShell, *namep;
  1300. X#ifndef U_WAIT
  1301. X    int                Status;
  1302. X#else
  1303. X    union wait        Status;
  1304. X#endif
  1305. X    string            str;
  1306. X
  1307. X    old1 = signal (SIGINT, SIG_IGN);
  1308. X    old2 = signal (SIGQUIT, SIG_IGN);
  1309. X    if ((pid = fork()) == 0) {
  1310. X        for (pid = 3; pid < 20; pid++)
  1311. X            (void) close(pid);
  1312. X        (void) Signal(SIGINT, SIG_DFL);
  1313. X        (void) Signal(SIGQUIT, SIG_DFL);
  1314. X        if ((theShell = getenv("SHELL")) == NULL)
  1315. X            theShell = uinfo.shell;
  1316. X        if (theShell == NULL)
  1317. X            theShell = "/bin/sh";
  1318. X        namep = rindex(theShell, '/');
  1319. X        if (namep == NULL)
  1320. X            namep = theShell;
  1321. X        (void) strcpy(str, "-");
  1322. X        (void) strcat(str, ++namep);
  1323. X        if (strcmp(namep, "sh") != 0)
  1324. X            str[0] = '+';
  1325. X        dbprintf ("%s\n", theShell);
  1326. X        if (argc > 1)
  1327. X            (void) execl(theShell, str, "-c", altarg, (char *)0);
  1328. X        else
  1329. X            (void) execl(theShell, str, (char *)0);
  1330. X        PERROR("shell", theShell);
  1331. X        exit(1);
  1332. X        }
  1333. X    if (pid > 0)
  1334. X        while (wait((void *) &Status) != pid)
  1335. X            ;
  1336. X    (void) Signal(SIGINT, old1);
  1337. X    (void) Signal(SIGQUIT, old2);
  1338. X    if (pid == -1) {
  1339. X        PERROR("shell", "Try again later");
  1340. X    }
  1341. X    return NOERR;
  1342. X}    /* shell */
  1343. X
  1344. X
  1345. X
  1346. X
  1347. X/*
  1348. X * Send new user information (re-login)
  1349. X */
  1350. Xint do_user(int argc, char **argv)
  1351. X{
  1352. X    char            acct[80];
  1353. X    int                n, aflag = 0;
  1354. X    string            str;
  1355. X
  1356. X    if (argc < 2)
  1357. X        argv = re_makeargv("(username) ", &argc);
  1358. X    if (argc > 4) {
  1359. X        return USAGE;
  1360. X    }
  1361. X    (void) sprintf(str, "USER %s", argv[1]);
  1362. X    n = command(str);
  1363. X    if (n == CONTINUE) {
  1364. X        if (argc < 3 )
  1365. X            argv[2] = Getpass("Password: "), argc++;
  1366. X        (void) sprintf(str, "PASS %s", argv[2]);
  1367. X        n = command(str);
  1368. X    }
  1369. X    if (n == CONTINUE) {
  1370. X        if (argc < 4) {
  1371. X            (void) printf("Account: "); (void) fflush(stdout);
  1372. X            (void) FGets(acct, stdin);
  1373. X            acct[strlen(acct) - 1] = '\0';
  1374. X            argv[3] = acct; argc++;
  1375. X        }
  1376. X        (void) sprintf(str, "ACCT %s", argv[3]);
  1377. X        n = command(str);
  1378. X        aflag++;
  1379. X    }
  1380. X    if (n != COMPLETE) {
  1381. X        (void) fprintf(stdout, "Login failed.\n");
  1382. X        logged_in = 0;
  1383. X        return (0);
  1384. X    }
  1385. X    if (!aflag && argc == 4) {
  1386. X        (void) sprintf(str, "ACCT %s", argv[3]);
  1387. X        (void) command(str);
  1388. X    }
  1389. X    logged_in = 1;
  1390. X    return NOERR;
  1391. X}    /* do_user */
  1392. X
  1393. X
  1394. X
  1395. X
  1396. X/*
  1397. X * Print working directory.
  1398. X */
  1399. X/*ARGSUSED*/
  1400. Xint pwd(int argc, char **argv)
  1401. X{
  1402. X    (void) quiet_command("PWD");
  1403. X    return NOERR;
  1404. X}    /* pwd */
  1405. X
  1406. X
  1407. X
  1408. X
  1409. X/*
  1410. X * Make a directory.
  1411. X */
  1412. Xint makedir(int argc, char **argv)
  1413. X{
  1414. X    string str;
  1415. X
  1416. X    if (argc < 2)
  1417. X        argv = re_makeargv("(directory-name) ", &argc);
  1418. X    if (argc < 2) {
  1419. X        return USAGE;
  1420. X    }
  1421. X    (void) sprintf(str, "MKD %s", argv[1]);
  1422. X    (void) command(str);
  1423. X    return NOERR;
  1424. X}    /* makedir */
  1425. X
  1426. X
  1427. X
  1428. X
  1429. X/*
  1430. X * Remove a directory.
  1431. X */
  1432. Xint removedir(int argc, char **argv)
  1433. X{
  1434. X    string str;
  1435. X    if (argc < 2)
  1436. X        argv = re_makeargv("(directory-name) ", &argc);
  1437. X    if (argc < 2) {
  1438. X        return USAGE;
  1439. X    }
  1440. X    if (rem_glob_one(argv[1]) == 0) {
  1441. X        (void) sprintf(str, "RMD %s", argv[1]);
  1442. X        (void) command(str);
  1443. X    }
  1444. X    return NOERR;
  1445. X}    /* removedir */
  1446. X
  1447. X
  1448. X
  1449. X
  1450. X/*
  1451. X * Send a line, verbatim, to the remote machine.
  1452. X */
  1453. Xint quote(int argc, char **argv)
  1454. X{
  1455. X    int i, tmpverbose;
  1456. X    string str;
  1457. X
  1458. X    if (argc < 2)
  1459. X        argv = re_makeargv("(command line to send) ", &argc);
  1460. X    if (argc < 2) {
  1461. X        return USAGE;
  1462. X    }
  1463. X    str[0] = 0;
  1464. X    if (*argv[0] == 's')    /* Command was 'site' instead of 'quote.' */
  1465. X        (void) Strncpy(str, "site ");
  1466. X    (void) Strncat(str, argv[1]);
  1467. X    for (i = 2; i < argc; i++) {
  1468. X        (void) Strncat(str, " ");
  1469. X        (void) Strncat(str, argv[i]);
  1470. X    }
  1471. X    tmpverbose = verbose;
  1472. X    verbose = V_VERBOSE;
  1473. X    if (command(str) == PRELIM) {
  1474. X        while (getreply(0) == PRELIM);
  1475. X    }
  1476. X    verbose = tmpverbose;
  1477. X    return NOERR;
  1478. X}    /* quote */
  1479. X
  1480. X
  1481. X
  1482. X
  1483. X/*
  1484. X * Ask the other side for help.
  1485. X */
  1486. Xint rmthelp(int argc, char **argv)
  1487. X{
  1488. X    string str;
  1489. X
  1490. X    if (argc == 1) (void) verbose_command("HELP");
  1491. X    else {
  1492. X        (void) sprintf(str, "HELP %s", argv[1]);
  1493. X        (void) verbose_command(str);
  1494. X    }
  1495. X    return NOERR;
  1496. X}    /* rmthelp */
  1497. X
  1498. X
  1499. X
  1500. X
  1501. X/*
  1502. X * Terminate session and exit.
  1503. X */
  1504. X/*ARGSUSED*/
  1505. Xint quit(int argc, char **argv)
  1506. X{
  1507. X    close_up_shop();
  1508. X    trim_log();
  1509. X    exit(0);
  1510. X}    /* quit */
  1511. X
  1512. X
  1513. X
  1514. Xvoid close_streams(int wantShutDown)
  1515. X{
  1516. X    if (cout != NULL) {
  1517. X        if (wantShutDown)
  1518. X            (void) shutdown(fileno(cout), 1+1);
  1519. X        (void) fclose(cout);
  1520. X        cout = NULL;
  1521. X    }
  1522. X    if (cin != NULL) {
  1523. X        if (wantShutDown)
  1524. X            (void) shutdown(fileno(cin), 1+1);
  1525. X        (void) fclose(cin);
  1526. X        cin = NULL;
  1527. X    }
  1528. X}    /* close_streams */
  1529. X
  1530. X
  1531. X
  1532. X
  1533. X/*
  1534. X * Terminate session, but don't exit.
  1535. X */
  1536. X/*ARGSUSED*/
  1537. Xint disconnect(int argc, char **argv)
  1538. X{
  1539. X#ifdef SYSLOG
  1540. X    syslog (LOG_INFO, "%s disconnected from %s.", uinfo.username, hostname);
  1541. X#endif
  1542. X
  1543. X    (void) command("QUIT");
  1544. X    close_streams(0);
  1545. X    UpdateRecentSitesList(hostname, cwd);
  1546. X    hostname[0] = cwd[0] = 0;
  1547. X    logged_in = connected = 0;
  1548. X    data = -1;
  1549. X    macnum = 0;
  1550. X    return NOERR;
  1551. X}    /* disconnect */
  1552. X
  1553. X
  1554. X
  1555. Xvoid
  1556. Xclose_up_shop(void)
  1557. X{
  1558. X    static int only_once = 0;
  1559. X    if (only_once++ > 0)
  1560. X        return;
  1561. X    if (connected)
  1562. X        (void) disconnect(0, NULL);
  1563. X    WriteRecentSitesFile();
  1564. X    if (logf != NULL) {
  1565. X        (void) fclose(logf);
  1566. X        logf = NULL;
  1567. X    }
  1568. X}    /* close_up_shop */
  1569. X
  1570. X
  1571. X
  1572. X
  1573. X/*
  1574. X * Glob a local file name specification with
  1575. X * the expectation of a single return value.
  1576. X * Can't control multiple values being expanded
  1577. X * from the expression, we return only the first.
  1578. X */
  1579. Xint globulize(char **cpp)
  1580. X{
  1581. X    char **globbed;
  1582. X
  1583. X    (void) LocalPath(*cpp);
  1584. X    globbed = glob(*cpp);
  1585. X    if (globerr != NULL) {
  1586. X        (void) printf("%s: %s\n", *cpp, globerr);
  1587. X        if (globbed) {
  1588. X            blkfree(globbed);
  1589. X            free(globbed);
  1590. X        }
  1591. X        return (0);
  1592. X    }
  1593. X    if (globbed) {
  1594. X        *cpp = *globbed++;
  1595. X        /* don't waste too much memory */
  1596. X        if (*globbed) {
  1597. X            blkfree(globbed);
  1598. X            free(globbed);
  1599. X        }
  1600. X    }
  1601. X    return (1);
  1602. X}    /* globulize */
  1603. X
  1604. X
  1605. X
  1606. X/* change directory to perent directory */
  1607. X/*ARGSUSED*/
  1608. Xint cdup(int argc, char **argv)
  1609. X{
  1610. X    (void) _cd("CDUP");
  1611. X    return NOERR;
  1612. X}    /* cdup */
  1613. X
  1614. X
  1615. X/* show remote system type */
  1616. X/*ARGSUSED*/
  1617. Xint syst(int argc, char **argv)
  1618. X{
  1619. X    (void) verbose_command("SYST");
  1620. X    return NOERR;
  1621. X}    /* syst */
  1622. X
  1623. X
  1624. X
  1625. X
  1626. Xint make_macro(char *name, FILE *fp)
  1627. X{
  1628. X    char            *tmp;
  1629. X    char            *cp;
  1630. X    string            str;
  1631. X    size_t            len;
  1632. X    int                i;
  1633. X
  1634. X    if (macnum == MAXMACROS) {
  1635. X        (void) fprintf(stderr, "Limit of %d macros have already been defined.\n", MAXMACROS);
  1636. X        return -1;
  1637. X    }
  1638. X
  1639. X    /* Make sure macros have unique names.  If 'init' was attempted to be
  1640. X     * redefined, just return, since it was probably cmdOpen() in a redial
  1641. X     * mode which tried to define it again.
  1642. X     */
  1643. X    for (i = 0; i<macnum; i++) {
  1644. X        if (strncmp(name, macros[i].mac_name, (size_t)8) == 0) {
  1645. X            if (parsing_rc) {
  1646. X                /* Just shut up and read in the macro, but don't save it,
  1647. X                 * because we already have it.
  1648. X                 */
  1649. X                while ((cp = FGets(str, fp)) != NULL) {
  1650. X                    /* See if we have a 'blank' line: just whitespace. */
  1651. X                    while (*cp && isspace(*cp)) ++cp;
  1652. X                    if (!*cp)
  1653. X                        break;
  1654. X                }
  1655. X            } else
  1656. X                (void) fprintf(stderr,
  1657. X                    "There is already a macro named '%s.'\n", name);
  1658. X            return -1;
  1659. X        }
  1660. X    }
  1661. X    (void) strncpy(macros[macnum].mac_name, name, (size_t)8);
  1662. X    if (macnum == 0)
  1663. X        macros[macnum].mac_start = macbuf;
  1664. X    else
  1665. X        macros[macnum].mac_start = macros[macnum - 1].mac_end + 1;
  1666. X    tmp = macros[macnum].mac_start;
  1667. X    while (1) {
  1668. X        cp = FGets(str, fp);
  1669. X        if (cp == NULL) {
  1670. X            /*
  1671. X             * If we had started a macro, we will say it is
  1672. X             * okay to skip the blank line delimiter if we
  1673. X             * are at the EOF.
  1674. X             */
  1675. X            if (tmp > macros[macnum].mac_start)
  1676. X                goto endmac;
  1677. X            (void) fprintf(stderr, "No text supplied for macro \"%s.\"\n", name);
  1678. X        }
  1679. X        /* see if we have a 'blank' line: just whitespace. */
  1680. X        while (*cp && isspace(*cp)) ++cp;
  1681. X        if (*cp == '\0') {
  1682. X            /* Blank line; end this macro. */
  1683. Xendmac:
  1684. X            macros[macnum++].mac_end = tmp;
  1685. X            return 0;
  1686. X        }
  1687. X        /* Add the text of this line to the macro. */
  1688. X        len = strlen(cp) + 1;    /* we need the \0 too. */
  1689. X        if (tmp + len >= macbuf + MACBUFLEN) {
  1690. X            (void) fprintf(stderr, "Macro \"%s\" not defined -- %d byte buffer exceeded.\n", name, MACBUFLEN);
  1691. X            return -1;
  1692. X        }
  1693. X        (void) strcpy(tmp, cp);
  1694. X        tmp += len;
  1695. X    }
  1696. X}    /* make_macro */
  1697. X
  1698. X
  1699. X
  1700. X
  1701. Xint macdef(int argc, char **argv)
  1702. X{
  1703. X    if (argc < 2)
  1704. X        argv = re_makeargv("(macro name) ", &argc);
  1705. X    if (argc != 2) {
  1706. X        (void) domacro(0, NULL);
  1707. X        return USAGE;
  1708. X    }
  1709. X    (void) printf("Enter macro line by line, terminating it with a blank line\n");
  1710. X    (void) make_macro(argv[1], stdin);
  1711. X    return NOERR;
  1712. X}    /* macdef */
  1713. X
  1714. X
  1715. X
  1716. X
  1717. Xint domacro(int argc, char **argv)
  1718. X{
  1719. X    register int            i, j;
  1720. X    register char            *cp1, *cp2;
  1721. X    int                        count = 2, loopflg = 0;
  1722. X    string                    str;
  1723. X    struct cmd                *c;
  1724. X
  1725. X    if (argc < 2) {
  1726. X        /* print macros. */
  1727. X        if (macnum == 0)
  1728. X            (void) printf("No macros defined.\n");
  1729. X        else {
  1730. X            (void) printf("Current macro definitions:\n");
  1731. X            for (i = 0; i < macnum; ++i) {
  1732. X                (void) printf("%s:\n", macros[i].mac_name);
  1733. X                cp1 = macros[i].mac_start;
  1734. X                cp2 = macros[i].mac_end;
  1735. X                while (cp1 < cp2) {
  1736. X                    (void) printf("   > ");
  1737. X                    while (cp1 < cp2 && *cp1)
  1738. X                        putchar(*cp1++);
  1739. X                    ++cp1;
  1740. X                }
  1741. X            }
  1742. X        }
  1743. X        if (argc == 0) return (NOERR);    /* called from macdef(), above. */
  1744. X        argv = re_makeargv("(macro to run) ", &argc);
  1745. X    }            
  1746. X    if (argc < 2) {
  1747. X        return USAGE;
  1748. X    }
  1749. X    for (i = 0; i < macnum; ++i) {
  1750. X        if (!strncmp(argv[1], macros[i].mac_name, (size_t) 9)) {
  1751. X            break;
  1752. X        }
  1753. X    }
  1754. X    if (i == macnum) {
  1755. X        (void) printf("'%s' macro not found.\n", argv[1]);
  1756. X        return USAGE;
  1757. X    }
  1758. X    (void) Strncpy(str, line);
  1759. XTOP:
  1760. X    cp1 = macros[i].mac_start;
  1761. X    while (cp1 != macros[i].mac_end) {
  1762. X        while (isspace(*cp1)) {
  1763. X            cp1++;
  1764. X        }
  1765. X        cp2 = line;
  1766. X        while (*cp1 != '\0') {
  1767. X              switch(*cp1) {
  1768. X                   case '\\':
  1769. X                 *cp2++ = *++cp1;
  1770. X                 break;
  1771. X                case '$':
  1772. X                 if (isdigit(*(cp1+1))) {
  1773. X                    j = 0;
  1774. X                    while (isdigit(*++cp1)) {
  1775. X                      j = 10*j +  *cp1 - '0';
  1776. X                    }
  1777. X                    cp1--;
  1778. X                    if (argc - 2 >= j) {
  1779. X                    (void) strcpy(cp2, argv[j+1]);
  1780. X                    cp2 += strlen(argv[j+1]);
  1781. X                    }
  1782. X                    break;
  1783. X                 }
  1784. X                 if (*(cp1+1) == 'i') {
  1785. X                    loopflg = 1;
  1786. X                    cp1++;
  1787. X                    if (count < argc) {
  1788. X                       (void) strcpy(cp2, argv[count]);
  1789. X                       cp2 += strlen(argv[count]);
  1790. X                    }
  1791. X                    break;
  1792. X                }
  1793. X                /* intentional drop through */
  1794. X                default:
  1795. X                *cp2++ = *cp1;
  1796. X                break;
  1797. X              }
  1798. X              if (*cp1 != '\0') {
  1799. X                    cp1++;
  1800. X              }
  1801. X        }
  1802. X        *cp2 = '\0';
  1803. X        makeargv();
  1804. X        c = getcmd(margv[0]);
  1805. X        if ((c == (struct cmd *) -1) && !parsing_rc) {
  1806. X            (void) printf("?Ambiguous command\n");
  1807. X        } else if (c == NULL && !parsing_rc) {
  1808. X            (void) printf("?Invalid command\n");
  1809. X        } else if (c->c_conn && !connected) {
  1810. X            (void) printf("Not connected.\n");
  1811. X        } else {
  1812. X            if (IS_VVERBOSE)
  1813. X                (void) printf("%s\n",line);
  1814. X            if ((*c->c_handler)(margc, margv) == USAGE)
  1815. X                cmd_usage(c);
  1816. X            (void) strcpy(line, str);
  1817. X            makeargv();
  1818. X            argc = margc;
  1819. X            argv = margv;
  1820. X        }
  1821. X        if (cp1 != macros[i].mac_end) {
  1822. X            cp1++;
  1823. X        }
  1824. X    }
  1825. X    if (loopflg && ++count < argc) {
  1826. X        goto TOP;
  1827. X    }
  1828. X    return NOERR;
  1829. X}    /* domacro */
  1830. X
  1831. X
  1832. X
  1833. X/*
  1834. X * get size of file on remote machine
  1835. X */
  1836. Xint sizecmd(int argc, char **argv)
  1837. X{
  1838. X    string str;
  1839. X
  1840. X    if (argc < 2)
  1841. X        argv = re_makeargv("(remote-file) ", &argc);
  1842. X    if (argc < 2) {
  1843. X        return USAGE;
  1844. X    }
  1845. X    if (rem_glob_one(argv[1]) == 0) {
  1846. X        (void) sprintf(str, "SIZE %s", argv[1]);
  1847. X        (void) verbose_command(str);
  1848. X    }
  1849. X    return NOERR;
  1850. X}    /* sizecmd */
  1851. X
  1852. X
  1853. X
  1854. X
  1855. X/*
  1856. X * get last modification time of file on remote machine
  1857. X */
  1858. Xint modtime(int argc, char **argv)
  1859. X{
  1860. X    int overbose;
  1861. X    string str;
  1862. X
  1863. X    if (argc < 2)
  1864. X        argv = re_makeargv("(remote-file) ", &argc);
  1865. X    if (argc < 2) {
  1866. X        return USAGE;
  1867. X    }
  1868. X    if (rem_glob_one(argv[1]) == 0) {
  1869. X        overbose = verbose;
  1870. X        if (debug == 0)
  1871. X            verbose = V_QUIET;
  1872. X        (void) sprintf(str, "MDTM %s", argv[1]);
  1873. X        if (command(str) == COMPLETE) {
  1874. X            int yy, mo, day, hour, min, sec;
  1875. X            (void) sscanf(reply_string, "%*s %04d%02d%02d%02d%02d%02d", &yy, &mo,
  1876. X                &day, &hour, &min, &sec);
  1877. X            /* might want to print this in local time */
  1878. X            (void) printf("%s\t%02d/%02d/%04d %02d:%02d:%02d GMT\n", argv[1],
  1879. X                mo, day, yy, hour, min, sec);
  1880. X        } else
  1881. X            (void) fputs(reply_string, stdout);
  1882. X        verbose = overbose;
  1883. X    }
  1884. X    return NOERR;
  1885. X}    /* modtime */
  1886. X
  1887. X
  1888. X
  1889. Xint lookup(int argc, char **argv)
  1890. X{
  1891. X    int i, j, by_name, result = NOERR;
  1892. X    struct hostent *host;        /* structure returned by gethostbyaddr() */
  1893. X    extern int h_errno;
  1894. X#ifdef BAD_INETADDR
  1895. X    struct in_addr addr;        /* address in host order */
  1896. X# define ADDR    addr.s_addr
  1897. X#else
  1898. X    unsigned long addr;            /* address in host order */
  1899. X# define ADDR    addr
  1900. X#endif
  1901. X
  1902. X    if (argc < 2)
  1903. X        argv = re_makeargv("(sitename) ", &argc);
  1904. X    if (argc < 2) {
  1905. X        return USAGE;
  1906. X    }
  1907. X
  1908. X     lasthostname[0] = 0;
  1909. X    for (i=1; i<argc; i++) {
  1910. X        /* does the argument look like an address? */
  1911. X        if (4 == sscanf (argv[i], "%d.%d.%d.%d", &j, &j, &j, &j)) {
  1912. X            /* ip */
  1913. X              addr = inet_addr (argv[i]);
  1914. X              if (ADDR == 0xffffffff) {
  1915. X                 (void) fprintf(stderr, "## could not convert \"%s\" into a valid IP address.\n", argv[i]);
  1916. X                 continue;
  1917. X             }
  1918. X            host = gethostbyaddr ((char *) &ADDR, 4, AF_INET);
  1919. X            by_name = 0;
  1920. X        } else {
  1921. X            /* name */
  1922. X            host = gethostbyname (argv[i]);
  1923. X            by_name = 1;
  1924. X        }
  1925. X        if (host == NULL) {
  1926. X            if (NOT_VQUIET) {
  1927. X                /* gethostxxx error */                
  1928. X                if (h_errno == HOST_NOT_FOUND) {
  1929. X                     (void) printf("%s: lookup error (%d).\n",
  1930. X                         argv[i], h_errno);
  1931. X                     result = h_errno;
  1932. X                 } else {
  1933. X                     (void) printf("%s \"%s\"\n",
  1934. X                         (by_name==0 ? "unknown address" : "unknown host"),
  1935. X                         argv[i]);
  1936. X                     result = 
  1937. X                         h_errno != 0 ? h_errno :
  1938. X                         -1;
  1939. X                }
  1940. X            }
  1941. X         } else {
  1942. X             if (*host->h_name)
  1943. X                 (void) Strncpy(lasthostname, host->h_name);
  1944. X            if (NOT_VQUIET) {
  1945. X                (void) printf("%-32s  ", *host->h_name ? host->h_name : "???");
  1946. X                if (*host->h_addr_list) {
  1947. X                    unsigned long horder;
  1948. X    
  1949. X                    horder = ntohl (*(unsigned long *) *(char **)host->h_addr_list);
  1950. X                    (void) printf ("%lu.%lu.%lu.%lu\n",
  1951. X                        (horder >> 24),
  1952. X                        (horder >> 16) & 0xff,
  1953. X                        (horder >> 8) & 0xff,
  1954. X                        horder & 0xff);
  1955. X                }
  1956. X                else (void) printf("???\n");
  1957. X            }
  1958. X        }
  1959. X    }    /* loop thru all sites */
  1960. X    return result;
  1961. X}    /* lookup */
  1962. X
  1963. X
  1964. X
  1965. X
  1966. Xint getlocalhostname(char *host, size_t size)
  1967. X{
  1968. X    int oldv, r;
  1969. X    char *argv[2];
  1970. X    char domain[64];
  1971. X
  1972. X#ifdef HOSTNAME
  1973. X    (void) strncpy(host, HOSTNAME, size);
  1974. X    return NOERR;
  1975. X#else
  1976. X    *host = 0;
  1977. X    if ((r = gethostname(host, size)) == 0) {
  1978. X        oldv = verbose;
  1979. X        verbose = V_QUIET;
  1980. X        argv[0] = "lookup";
  1981. X        (void) sprintf(line, "lookup %s", host);
  1982. X        (void) makeargv();
  1983. X        if (lookup(margc, margv) == 0 && lasthostname[0]) {
  1984. X            (void) _Strncpy(host, lasthostname, size);
  1985. X#ifdef HAS_DOMAINNAME
  1986. X            if (index(host, '.') == NULL) {
  1987. X                if (getdomainname(domain + 1, sizeof(domain) - 1) == 0) {
  1988. X                    domain[0] = '.';
  1989. X                    (void) _Strncat(host, domain, size);
  1990. X                }
  1991. X            }
  1992. X#endif
  1993. X        }
  1994. X        verbose = oldv;
  1995. X    }
  1996. X    return r;
  1997. X#endif
  1998. X}    /* getlocalhostname */
  1999. X
  2000. X
  2001. X
  2002. X
  2003. X/*
  2004. X * show status on remote machine
  2005. X */
  2006. Xint rmtstatus(int argc, char **argv)
  2007. X{
  2008. X    string str;
  2009. X
  2010. X    if (argc > 1) {
  2011. X        (void) sprintf(str, "STAT %s" , argv[1]);
  2012. X        (void) verbose_command(str);
  2013. X    } else (void) verbose_command("STAT");
  2014. X    return NOERR;
  2015. X}    /* rmtstatus */
  2016. X
  2017. X
  2018. X
  2019. X
  2020. X/*
  2021. X * create an empty file on remote machine.
  2022. X */
  2023. Xint create(int argc, char **argv)
  2024. X{
  2025. X    string            str;
  2026. X    FILE            *ftemp;
  2027. X
  2028. X    if (argc < 2)
  2029. X        argv = re_makeargv("(remote-file) ", &argc);
  2030. X    if (argc < 2) {
  2031. X        return USAGE;
  2032. X    }
  2033. X    (void) tmp_name(str);
  2034. X    ftemp = fopen(str, "w");
  2035. X    /* (void) fputc('x', ftemp); */
  2036. X    (void) fclose(ftemp);
  2037. X    creating = 1;
  2038. X    (void) sendrequest("STOR", str, argv[1]);
  2039. X    creating = 0;
  2040. X    (void) unlink(str);
  2041. X    return NOERR;
  2042. X}    /* create */
  2043. X
  2044. X
  2045. X
  2046. X
  2047. X/* show version info */
  2048. X/*ARGSUSED*/
  2049. Xint show_version(int argc, char **argv)
  2050. X{
  2051. X    char    *DStrs[40];
  2052. X    int        nDStrs = 0, i, j;
  2053. X
  2054. X    (void) printf("%s\n%-30s %s\n", version, "Author:",
  2055. X        "Mike Gleason, NCEMRSoft (mgleason@cse.unl.edu).");
  2056. X
  2057. X/* Now entering CPP hell... */
  2058. X#ifdef __DATE__
  2059. X    (void) printf("%-30s %s\n", "Compile Date:", __DATE__);
  2060. X#endif
  2061. X    (void) printf("%-30s %s (%s)\n", "Operating System:",
  2062. X#ifdef System
  2063. X    System,
  2064. X#else
  2065. X#    ifdef unix
  2066. X    "UNIX",
  2067. X#    else
  2068. X    "??",
  2069. X#    endif
  2070. X#endif
  2071. X#ifdef SYSV
  2072. X        "SYSV");
  2073. X#else
  2074. X#    ifdef BSD
  2075. X            "BSD");
  2076. X#    else
  2077. X            "neither BSD nor SYSV?");
  2078. X#    endif
  2079. X#endif
  2080. X
  2081. X    /* Show which CPP symbols were used in compilation. */
  2082. X#ifdef __GNUC__
  2083. X    DStrs[nDStrs++] = "__GNUC__";
  2084. X#endif
  2085. X#ifdef RINDEX
  2086. X    DStrs[nDStrs++] = "RINDEX";
  2087. X#endif
  2088. X#ifdef CURSES
  2089. X    DStrs[nDStrs++] = "CURSES";
  2090. X#endif
  2091. X#ifdef HERROR
  2092. X    DStrs[nDStrs++] = "HERROR";
  2093. X#endif
  2094. X#ifdef U_WAIT
  2095. X    DStrs[nDStrs++] = "U_WAIT";
  2096. X#endif
  2097. X#if defined(NO_CONST) || defined(const)
  2098. X    DStrs[nDStrs++] = "NO_CONST";
  2099. X#endif
  2100. X#ifdef GETPASS
  2101. X    DStrs[nDStrs++] = "GETPASS";
  2102. X#endif
  2103. X#ifdef GETCWDSIZET
  2104. X    DStrs[nDStrs++] = "GETCWDSIZET";
  2105. X#endif
  2106. X#ifdef HOSTNAME
  2107. X    DStrs[nDStrs++] = "HOSTNAME";
  2108. X#endif
  2109. X#ifdef SYSDIRH
  2110. X    DStrs[nDStrs++] = "SYSDIRH";
  2111. X#endif
  2112. X#ifdef SYSSELECTH
  2113. X    DStrs[nDStrs++] = "SYSSELECTH";
  2114. X#endif
  2115. X#ifdef NO_UNISTDH 
  2116. X    DStrs[nDStrs++] = "NO_UNISTDH";
  2117. X#endif
  2118. X#ifdef NO_STDLIBH
  2119. X    DStrs[nDStrs++] = "NO_STDLIBH";
  2120. X#endif
  2121. X#ifdef SYSLOG 
  2122. X    DStrs[nDStrs++] = "SYSLOG";
  2123. X#endif
  2124. X#ifdef BAD_INETADDR
  2125. X    DStrs[nDStrs++] = "BAD_INETADDR";
  2126. X#endif
  2127. X#ifdef SGTTYB
  2128. X    DStrs[nDStrs++] = "SGTTYB";
  2129. X#endif
  2130. X#ifdef TERMIOS
  2131. X    DStrs[nDStrs++] = "TERMIOS";
  2132. X#endif
  2133. X#ifdef STRICT_PROTOS
  2134. X    DStrs[nDStrs++] = "STRICT_PROTOS";
  2135. X#endif
  2136. X#ifdef dFTP_PORT
  2137. X    DStrs[nDStrs++] = "dFTP_PORT";
  2138. X#endif
  2139. X#ifdef BROKEN_MEMCPY
  2140. X    DStrs[nDStrs++] = "BROKEN_MEMCPY";
  2141. X#endif
  2142. X#ifdef READLINE
  2143. X    DStrs[nDStrs++] = "READLINE";
  2144. X#endif
  2145. X#ifdef GETLINE 
  2146. X    DStrs[nDStrs++] = "GETLINE";
  2147. X#endif
  2148. X#ifdef _POSIX_SOURCE
  2149. X    DStrs[nDStrs++] = "_POSIX_SOURCE";
  2150. X#endif
  2151. X#ifdef NO_TIPS
  2152. X    DStrs[nDStrs++] = "NO_TIPS";
  2153. X#endif
  2154. X#ifdef NO_UTIMEH 
  2155. X    DStrs[nDStrs++] = "NO_UTIMEH";
  2156. X#endif
  2157. X#ifdef DB_ERRS
  2158. X    DStrs[nDStrs++] = "DB_ERRS";
  2159. X#endif
  2160. X#ifdef NO_VARARGS 
  2161. X    DStrs[nDStrs++] = "NO_VARARGS";
  2162. X#endif
  2163. X#ifdef GATEWAY
  2164. X    DStrs[nDStrs++] = "GATEWAY";
  2165. X#endif
  2166. X#ifdef SOCKS
  2167. X    DStrs[nDStrs++] = "SOCKS";
  2168. X#endif
  2169. X
  2170. X/* DONE with #ifdefs for now! */
  2171. X
  2172. X    (void) printf ("\nCompile Options:\n");
  2173. X    for (i=j=0; i<nDStrs; i++) {
  2174. X        if (j == 0)
  2175. X            (void) printf("    ");
  2176. X        (void) printf("%-15s", DStrs[i]);
  2177. X        if (++j == 4) {
  2178. X            j = 0;
  2179. X            (void) putchar('\n');
  2180. X        }
  2181. X    }
  2182. X    if (j != 0)
  2183. X        (void) putchar('\n');
  2184. X
  2185. X#ifdef MK
  2186. X    (void) printf("\nMK: %s\n", MK);
  2187. X#endif /* MK */
  2188. X
  2189. X    (void) printf("\nDefaults:\n");
  2190. X    (void) printf("\
  2191. X    Xfer Buf Size: %8d   Debug: %d   MPrompt: %d   Verbosity: %d\n\
  2192. X    Prompt: %s   Pager: %s  ZCat: %s\n\
  2193. X    Logname: %s   Logging: %d   Type: %s   Cmd Len: %d\n\
  2194. X    Recv Line Len: %d   #Macros: %d   Macbuf: %d  Auto-Binary: %d\n\
  2195. X    Recent File: %s   Recent On: %d   nRecents: %d\n\
  2196. X    Redial Delay: %d  Anon Open: %d  New Mail Message: \"%s\"\n",
  2197. X        MAX_XFER_BUFSIZE, dDEBUG, dMPROMPT, dVERBOSE,
  2198. X        dPROMPT, dPAGER, ZCAT,
  2199. X        dLOGNAME, dLOGGING, dTYPESTR, CMDLINELEN,
  2200. X        RECEIVEDLINELEN, MAXMACROS, MACBUFLEN, dAUTOBINARY,
  2201. X        dRECENTF, dRECENT_ON, dMAXRECENTS,
  2202. X        dREDIALDELAY, dANONOPEN, NEWMAILMESSAGE
  2203. X    );
  2204. X#ifdef GATEWAY
  2205. X    (void) printf("\
  2206. X    Gateway Login: %s\n", dGATEWAY_LOGIN);
  2207. X#endif
  2208. X    return NOERR;
  2209. X}    /* show_version */
  2210. X
  2211. X
  2212. X
  2213. Xvoid PurgeLineBuffer(void)
  2214. X{
  2215. X    register struct lslist *a, *b;
  2216. X         
  2217. X    for (a = lshead; a != NULL; ) {
  2218. X        b = a->next;
  2219. X        if (a->string)
  2220. X            free(a->string);    /* free string */
  2221. X        free(a);                /* free node */
  2222. X        a = b;
  2223. X    }
  2224. X    lshead = lstail = NULL;
  2225. X}    /* PurgeLineBuffer */
  2226. X
  2227. X
  2228. X
  2229. X
  2230. X/*ARGSUSED*/
  2231. Xint ShowLineBuffer(int argc, char **argv)
  2232. X{
  2233. X    register struct lslist *a = lshead;
  2234. X    int pagemode;
  2235. X    FILE *fp;
  2236. X    sig_t oldintp;
  2237. X
  2238. X    if (a == NULL)
  2239. X        return CMDERR;
  2240. X    pagemode= (**argv) == 'p' && pager[0] == '|';
  2241. X    if (pagemode) {
  2242. X        fp = popen(pager + 1, "w");
  2243. X        if (!fp) {
  2244. X            PERROR("ShowLineBuffer", pager + 1);
  2245. X            return CMDERR;
  2246. X        }
  2247. X    } else
  2248. X        fp = stdout;
  2249. X    oldintp = Signal(SIGPIPE, SIG_IGN);
  2250. X    while (a) {
  2251. X        if (a->string)
  2252. X            (void) fprintf(fp, "%s\n", a->string);
  2253. X        a = a->next;
  2254. X    }
  2255. X    if (pagemode)
  2256. X        (void) pclose(fp);
  2257. X    if (oldintp)
  2258. X        (void) Signal(SIGPIPE, oldintp);
  2259. X    return NOERR;
  2260. X}    /* ShowLineBuffer */
  2261. X
  2262. X
  2263. X
  2264. X
  2265. X/*ARGSUSED*/
  2266. Xint unimpl(int argc, char **argv)
  2267. X{
  2268. X    if (!parsing_rc)
  2269. X        (void) printf("%s: command not supported. (and probably won't ever be).\n", argv[0]);
  2270. X    return (NOERR);
  2271. X}    /* unimpl */
  2272. X
  2273. X/* eof cmds.c */
  2274. END_OF_FILE
  2275.   if test 38637 -ne `wc -c <'cmds.c'`; then
  2276.     echo shar: \"'cmds.c'\" unpacked with wrong size!
  2277.   fi
  2278.   # end of 'cmds.c'
  2279. fi
  2280. if test -f 'cmds.h' -a "${1}" != "-c" ; then 
  2281.   echo shar: Will not clobber existing file \"'cmds.h'\"
  2282. else
  2283.   echo shar: Extracting \"'cmds.h'\" \(3287 characters\)
  2284.   sed "s/^X//" >'cmds.h' <<'END_OF_FILE'
  2285. X/* cmds.h */
  2286. X
  2287. X#ifndef _cmd_h_
  2288. X#define _cmd_h_
  2289. X
  2290. X/*  $RCSfile: cmds.h,v $
  2291. X *  $Revision: 14020.11 $
  2292. X *  $Date: 93/07/09 10:58:19 $
  2293. X */
  2294. X
  2295. X/* Verbosity levels. */
  2296. X#define V_QUIET        -1
  2297. X#define V_ERRS        0
  2298. X#define V_TERSE        1
  2299. X#define V_VERBOSE    2
  2300. X#define V_IMPLICITCD 4
  2301. X#define IS_VQUIET    (verbose <= V_QUIET)
  2302. X#define IS_VERRS    (verbose == V_ERRS)
  2303. X#define IS_VTERSE    (verbose == V_TERSE)
  2304. X#define IS_VVERBOSE    (verbose == V_VERBOSE)
  2305. X#define NOT_VQUIET    (verbose > V_QUIET)
  2306. X
  2307. X/* Open modes. */
  2308. X#define OPEN_A 1
  2309. X#define OPEN_U 0
  2310. X
  2311. X#define LS_FLAGS_AND_FILE '\1'
  2312. X
  2313. X/* Command result codes. */
  2314. X#define USAGE (88)
  2315. X#define NOERR (0)
  2316. X#define CMDERR (-1)
  2317. X
  2318. X/*
  2319. X * Format of command table.
  2320. X */
  2321. Xstruct cmd {
  2322. X    char    *c_name;    /* name of command */
  2323. X    char    c_conn;        /* must be connected to use command */
  2324. X    char    c_hidden;    /* a hidden command or alias (won't show up in help) */
  2325. X    int        (*c_handler)(int, char **);    /* function to call */
  2326. X    char    *c_help;    /* help string */
  2327. X    char    *c_usage;    /* usage string or NULL, to ask the function itself. */
  2328. X};
  2329. X
  2330. X#define NCMDS ((int) ((sizeof (cmdtab) / sizeof (struct cmd)) - 1))
  2331. X
  2332. Xstruct macel {
  2333. X    char mac_name[9];    /* macro name */
  2334. X    char *mac_start;    /* start of macro in macbuf */
  2335. X    char *mac_end;        /* end of macro in macbuf */
  2336. X};
  2337. X
  2338. Xstruct types {
  2339. X    char    *t_name;
  2340. X    char    *t_mode;
  2341. X    int        t_type;
  2342. X    char    *t_arg;
  2343. X};
  2344. X
  2345. Xstruct lslist {
  2346. X    char            *string;
  2347. X    struct lslist    *next;
  2348. X};
  2349. X
  2350. Xint settype(int argc, char **argv);
  2351. Xint _settype(char *typename);
  2352. Xint setbinary(int argc, char **argv);
  2353. Xint setascii(int argc, char **argv);
  2354. Xint put(int argc, char **argv);
  2355. Xint mput(int argc, char **argv);
  2356. Xint rem_glob_one(char *pattern);
  2357. Xint get(int argc, char **argv);
  2358. Xvoid mabort SIG_PARAMS;
  2359. Xint mget(int argc, char **argv);
  2360. Xchar *remglob(char *argv[]);
  2361. Xint setverbose(int argc, char **argv);
  2362. Xint setprompt(int argc, char **argv);
  2363. Xint setdebug(int argc, char **argv);
  2364. Xvoid fix_options(void);
  2365. Xint cd(int argc, char **argv);
  2366. Xint implicit_cd(char *dir);
  2367. Xint _cd(char *dir);
  2368. Xint lcd(int argc, char **argv);
  2369. Xint do_delete(int argc, char **argv);
  2370. Xint mdelete(int argc, char **argv);
  2371. Xint renamefile(int argc, char **argv);
  2372. Xint ls(int argc, char **argv);
  2373. Xint shell(int argc, char **argv);
  2374. Xint do_user(int argc, char **argv);
  2375. Xint pwd(int argc, char **argv);
  2376. Xint makedir(int argc, char **argv);
  2377. Xint removedir(int argc, char **argv);
  2378. Xint quote(int argc, char **argv);
  2379. Xint rmthelp(int argc, char **argv);
  2380. Xint quit(int argc, char **argv);
  2381. Xvoid close_streams(int wantShutDown);
  2382. Xint disconnect(int argc, char **argv);
  2383. Xvoid close_up_shop(void);
  2384. Xint globulize(char **cpp);
  2385. Xint cdup(int argc, char **argv);
  2386. Xint syst(int argc, char **argv);
  2387. Xint make_macro(char *name, FILE *fp);
  2388. Xint macdef(int argc, char **argv);
  2389. Xint domacro(int argc, char **argv);
  2390. Xint sizecmd(int argc, char **argv);
  2391. Xint modtime(int argc, char **argv);
  2392. Xint lookup(int argc, char **argv);
  2393. Xint rmtstatus(int argc, char **argv);
  2394. Xint create(int argc, char **argv);
  2395. Xint getlocalhostname(char *host, size_t size);
  2396. Xint show_version(int argc, char **argv);
  2397. Xvoid PurgeLineBuffer(void);
  2398. Xint ShowLineBuffer(int argc, char **argv);
  2399. Xint unimpl(int argc, char **argv);
  2400. Xlong GetDateAndSize(char *fName, unsigned long *mod_time);
  2401. Xint SetTypeByNumber(int i);
  2402. X
  2403. X/* In util.c: */
  2404. Xvoid cmd_help(struct cmd *c);
  2405. Xvoid cmd_usage(struct cmd *c);
  2406. Xstruct cmd *getcmd(char *name);
  2407. X
  2408. X#endif    /* _cmd_h_ */
  2409. END_OF_FILE
  2410.   if test 3287 -ne `wc -c <'cmds.h'`; then
  2411.     echo shar: \"'cmds.h'\" unpacked with wrong size!
  2412.   fi
  2413.   # end of 'cmds.h'
  2414. fi
  2415. if test -f 'open.h' -a "${1}" != "-c" ; then 
  2416.   echo shar: Will not clobber existing file \"'open.h'\"
  2417. else
  2418.   echo shar: Extracting \"'open.h'\" \(1194 characters\)
  2419.   sed "s/^X//" >'open.h' <<'END_OF_FILE'
  2420. X/* open.h */
  2421. X
  2422. X#ifndef _open_h_
  2423. X#define _open_h_ 1
  2424. X
  2425. X/* Variables for Open() that can be changed from the command line. */
  2426. Xtypedef struct OpenOptions {
  2427. X    int                openmode;
  2428. X    int                ignore_rc;
  2429. X    unsigned int    port;
  2430. X    int                redial_delay;
  2431. X    int                max_dials;
  2432. X    int                ftpcat;
  2433. X    Hostname        hostname;
  2434. X    longstring        cdpath;
  2435. X    longstring        colonmodepath;
  2436. X} OpenOptions;
  2437. X
  2438. X/* Open modes. */
  2439. X#define openImplicitAnon 1
  2440. X#define openImplicitUser 4
  2441. X#define openExplicitAnon 3
  2442. X#define openExplicitUser 2
  2443. X
  2444. X#define ISUSEROPEN(a) ((a==openImplicitUser)||(a==openExplicitUser))
  2445. X#define ISANONOPEN(a) (!ISUSEROPEN(a))
  2446. X#define ISEXPLICITOPEN(a) ((a==openExplicitAnon)||(a==openExplicitUser))
  2447. X#define ISIMPLICITOPEN(a) (!ISEXPLICITOPEN(a))
  2448. X
  2449. X/* ftpcat modes. */
  2450. X#define NO_FTPCAT    0
  2451. X#define FTPCAT        1
  2452. X#define FTPMORE        2
  2453. X
  2454. X/* Protos: */
  2455. Xint InitOpenOptions(OpenOptions *openopt);
  2456. Xint GetOpenOptions(int argc, char **argv, OpenOptions *openopt);
  2457. Xint CheckForColonMode(OpenOptions *openopt, int *login_verbosity);
  2458. Xint HookupToRemote(OpenOptions *openopt);
  2459. Xvoid CheckRemoteSystemType(OpenOptions *openopt);
  2460. Xvoid ColonMode(OpenOptions *openopt);
  2461. Xint Open(OpenOptions *openopt);
  2462. Xint cmdOpen(int argc, char **argv);
  2463. X
  2464. X#endif    /* _open_h_ */
  2465. END_OF_FILE
  2466.   if test 1194 -ne `wc -c <'open.h'`; then
  2467.     echo shar: \"'open.h'\" unpacked with wrong size!
  2468.   fi
  2469.   # end of 'open.h'
  2470. fi
  2471. echo shar: End of archive 1 \(of 5\).
  2472. cp /dev/null ark1isdone
  2473. MISSING=""
  2474. for I in 1 2 3 4 5 ; do
  2475.     if test ! -f ark${I}isdone ; then
  2476.     MISSING="${MISSING} ${I}"
  2477.     fi
  2478. done
  2479. if test "${MISSING}" = "" ; then
  2480.     echo You have unpacked all 5 archives.
  2481.     rm -f ark[1-9]isdone
  2482. else
  2483.     echo You still must unpack the following archives:
  2484.     echo "        " ${MISSING}
  2485. fi
  2486. exit 0
  2487. exit 0 # Just in case...
  2488.