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