Return to cmds.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / new / xns / examples / filing_client

Annotation of 43BSDTahoe/new/xns/examples/filing_client/cmds.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: static char RCSid[] = "$Header: cmds.c,v 2.5 87/04/01 09:32:37 ed Exp $";
        !             3: #endif
        !             4: /* $Log:       cmds.c,v $
        !             5:  * Revision 2.5  87/04/01  09:32:37  ed
        !             6:  * Fixed bug in setpeer if no host accompanies -F (from Chris Liebman)
        !             7:  * 
        !             8:  * Revision 2.4  87/01/09  16:52:00  ed
        !             9:  * Use FilingSubset, if rejected attempt Filing
        !            10:  * Allows user override with -F switch
        !            11:  * Maintain FilingSubset mandatory attributes
        !            12:  * User niceties:  echo file name/type on transfer commands
        !            13:  *             prompt on delete
        !            14:  * guess type which will determine file type implied by content
        !            15:  * New commands: (type related) Guess, Whatis
        !            16:  *           (file transfer) Copy, Move, Rename
        !            17:  * 
        !            18:  * Revision 2.3  86/12/15  11:40:49  jqj
        !            19:  * Added support for more ViewPoint file types (no other attributes, though)
        !            20:  * 
        !            21:  * Revision 2.2  86/12/11  06:11:30  jqj
        !            22:  * Eliminated form, mode, and struct commands.  Started adding support for
        !            23:  * more file types.
        !            24:  * 
        !            25:  * Revision 2.1  86/06/30  12:18:56  jqj
        !            26:  * get proper order of args to allow mget to work right.
        !            27:  * 
        !            28:  * Revision 2.0  85/11/21  07:22:41  jqj
        !            29:  * 4.3BSD standard release
        !            30:  * 
        !            31:  * Revision 1.2  85/10/30  08:06:37  root
        !            32:  * if prompt=off but verbose=on, print the name of each file during
        !            33:  * multiplefile transfers.
        !            34:  * 
        !            35:  * Revision 1.1  85/05/27  06:30:51  jqj
        !            36:  * Initial revision
        !            37:  * 
        !            38:  * based on Berkeley tcp/ftp
        !            39:  */
        !            40: /* static char sccsid[] = "@(#)cmds.c  4.9 (Berkeley) 7/26/83"; */
        !            41: 
        !            42: /*
        !            43:  * FTP User Program -- Command Routines.
        !            44:  */
        !            45: #include <sys/param.h>
        !            46: #include <sys/stat.h>
        !            47: #include <sys/socket.h>
        !            48: #include <sys/file.h>
        !            49: 
        !            50: #include <signal.h>
        !            51: #include <stdio.h>
        !            52: #include <errno.h>
        !            53: 
        !            54: #include "ftp_var.h"
        !            55: 
        !            56: extern char *globerr;
        !            57: extern char **glob();
        !            58: extern char *home;
        !            59: extern short gflag;
        !            60: extern char *remglob();
        !            61: extern char *getenv();
        !            62: extern char *index();
        !            63: extern char *rindex();
        !            64: 
        !            65: /*
        !            66:  * Connect to peer server and
        !            67:  * auto-login, if possible.
        !            68:  */
        !            69: setpeer(argc, argv)
        !            70:        int argc;
        !            71:        char *argv[];
        !            72: {
        !            73:        CourierConnection *hookup();
        !            74: 
        !            75:        if (connected != (CourierConnection*)0) {
        !            76:                printf("Already connected to %s, use disconnect first.\n",
        !            77:                        hostname);
        !            78:                return;
        !            79:        }
        !            80: 
        !            81:        if (argc < 2) {
        !            82:                strcat(line, " ");
        !            83:                printf("(to) ");
        !            84:                gets(&line[strlen(line)]);
        !            85:                makeargv();
        !            86:                argc = margc;
        !            87:                argv = margv;
        !            88:        } else if (strcmp(argv[1], "-F") == 0) {
        !            89:                usefiling= 1;
        !            90:                if (argc < 3) {
        !            91:                        strcat(line, " ");
        !            92:                        printf("(to) ");
        !            93:                        gets(&line[strlen(line)]);
        !            94:                        makeargv();
        !            95:                        argc = margc;
        !            96:                        argv = margv;
        !            97:                }
        !            98:                argc--;
        !            99:                argv[1]= argv[2];
        !           100:        }
        !           101: 
        !           102:        if (argc > 2) {
        !           103:                printf("usage: %s [-F] fileservice-name\n", argv[0]);
        !           104:                return;
        !           105:        }
        !           106:        connected = hookup(argv[1]);
        !           107:        if (connected != (CourierConnection*)0) {
        !           108:                if (autologin) {
        !           109:                        login(0,0);
        !           110:                }
        !           111:        }
        !           112: }
        !           113: 
        !           114: struct types {
        !           115:        char    *t_name;
        !           116:        int     t_type;
        !           117: } types[] = {
        !           118:        { "ascii",      TYPE_A },
        !           119:        { "binary",     TYPE_I },
        !           120:        { "image",      TYPE_I },
        !           121:        { "interpress", TYPE_Interpress },
        !           122:        { "viewpoint",  TYPE_VP },
        !           123:        { "vpcanvas",   TYPE_VPCanvas },
        !           124:        { "vpdictionary",TYPE_VPDictionary },
        !           125:        { "vpmailnote", TYPE_VPMailNote },
        !           126:        { "vpreference",TYPE_VPReference },
        !           127:        { "serialized", TYPE_S },
        !           128:        { "guess",      TYPE_Guess },
        !           129:        0
        !           130: };
        !           131: 
        !           132: /*
        !           133:  * Set transfer type.
        !           134:  */
        !           135: settype(argc, argv)
        !           136:        char *argv[];
        !           137: {
        !           138:        register struct types *p;
        !           139:        int comret;
        !           140: 
        !           141:        if (argc > 2 || (argc == 2 && strcmp(argv[1],"?") == 0)) {
        !           142:                char *sep;
        !           143: 
        !           144:                printf("usage: %s [ <integer> ", argv[0]);
        !           145:                sep = " | ";
        !           146:                for (p = types; p->t_name; p++) {
        !           147:                        printf("%s%s", sep, p->t_name);
        !           148:                }
        !           149:                printf(" ]\n");
        !           150:                return;
        !           151:        }
        !           152:        if (argc < 2) {
        !           153:                printf("Using %s mode to transfer files.\n", typename);
        !           154:                return;
        !           155:        }
        !           156:        for (p = types; p->t_name; p++)
        !           157:                if (strcmp(argv[1], p->t_name) == 0)
        !           158:                        break;
        !           159:        if (p->t_name == 0) {
        !           160:                int tmp = atoi(argv[1]);
        !           161:                if (tmp == 0 && strcmp(argv[1],"0") != 0) {
        !           162:                        printf("%s: unknown mode (\"%s ?\" for help)\n",
        !           163:                                argv[1], argv[0]);
        !           164:                        return;
        !           165:                }
        !           166:                sprintf(typename,"%d",tmp);
        !           167:                typevalue = tmp;
        !           168:                return;
        !           169:        }
        !           170:        strcpy(typename, p->t_name);
        !           171:        typevalue = p->t_type;
        !           172: }
        !           173: 
        !           174: /*
        !           175:  * Set binary transfer type.
        !           176:  */
        !           177: /*VARARGS*/
        !           178: setbinary()
        !           179: {
        !           180: 
        !           181:        call(settype, "type", "binary", 0);
        !           182: }
        !           183: 
        !           184: /*
        !           185:  * Set ascii transfer type.
        !           186:  */
        !           187: /*VARARGS*/
        !           188: setascii()
        !           189: {
        !           190: 
        !           191:        call(settype, "type", "ascii", 0);
        !           192: }
        !           193: 
        !           194: /*
        !           195:  * Set guess transfer type.
        !           196:  *     basically make educated guess of file type as stored
        !           197:  */
        !           198: /*VARARGS*/
        !           199: setguess()
        !           200: {
        !           201:        call(settype, "type", "guess", 0);
        !           202: }
        !           203: 
        !           204: put(argc, argv)
        !           205:        int argc;
        !           206:        char *argv[];
        !           207: {
        !           208:        char *cmd;
        !           209: 
        !           210:        if (argc == 2)
        !           211:                argc++, argv[2] = argv[1];
        !           212:        if (argc < 2) {
        !           213:                strcat(line, " ");
        !           214:                printf("(local-file) ");
        !           215:                gets(&line[strlen(line)]);
        !           216:                makeargv();
        !           217:                argc = margc;
        !           218:                argv = margv;
        !           219:        }
        !           220:        if (argc < 2) {
        !           221: usage:
        !           222:                printf("%s local-file remote-file\n", argv[0]);
        !           223:                return;
        !           224:        }
        !           225:        if (argc < 3) {
        !           226:                strcat(line, " ");
        !           227:                printf("(remote-file) ");
        !           228:                gets(&line[strlen(line)]);
        !           229:                makeargv();
        !           230:                argc = margc;
        !           231:                argv = margv;
        !           232:        }
        !           233:        if (argc < 3) 
        !           234:                goto usage;
        !           235:        if (!globulize(&argv[1]))
        !           236:                return;
        !           237:        cmd = (argv[0][0] == 'a') ? "APPE" : "STOR";
        !           238: 
        !           239:        sendrequest(cmd, argv[1], argv[2]);
        !           240: 
        !           241: }
        !           242: 
        !           243: /*
        !           244:  * Send multiple files.
        !           245:  */
        !           246: mput(argc, argv)
        !           247:        char *argv[];
        !           248: {
        !           249:        register int i;
        !           250: 
        !           251:        if (argc < 2) {
        !           252:                strcat(line, " ");
        !           253:                printf("(local-files) ");
        !           254:                gets(&line[strlen(line)]);
        !           255:                makeargv();
        !           256:                argc = margc;
        !           257:                argv = margv;
        !           258:        }
        !           259:        if (argc < 2) {
        !           260:                printf("%s local-files\n", argv[0]);
        !           261:                return;
        !           262:        }
        !           263:        for (i = 1; i < argc; i++) {
        !           264:                register char **cpp, **gargs;
        !           265: 
        !           266:                if (!doglob) {
        !           267:                        if (confirm(argv[0], argv[i]))
        !           268:                                sendrequest("STOR", argv[i], argv[i]);
        !           269:                        continue;
        !           270:                }
        !           271:                gargs = glob(argv[i]);
        !           272:                if (globerr != NULL) {
        !           273:                        printf("%s\n", globerr);
        !           274:                        if (gargs)
        !           275:                                blkfree(gargs);
        !           276:                        continue;
        !           277:                }
        !           278:                for (cpp = gargs; cpp && *cpp != NULL; cpp++)
        !           279:                        if (confirm(argv[0], *cpp))
        !           280:                                sendrequest("STOR", *cpp, *cpp);
        !           281:                if (gargs != NULL)
        !           282:                        blkfree(gargs);
        !           283:        }
        !           284: }
        !           285: 
        !           286: /*
        !           287:  * Receive one file.
        !           288:  */
        !           289: get(argc, argv)
        !           290:        char *argv[];
        !           291: {
        !           292: 
        !           293:        if (argc == 2)
        !           294:                argc++, argv[2] = argv[1];
        !           295:        if (argc < 2) {
        !           296:                strcat(line, " ");
        !           297:                printf("(remote-file) ");
        !           298:                gets(&line[strlen(line)]);
        !           299:                makeargv();
        !           300:                argc = margc;
        !           301:                argv = margv;
        !           302:        }
        !           303:        if (argc < 2) {
        !           304: usage:
        !           305:                printf("%s remote-file [ local-file ]\n", argv[0]);
        !           306:                return;
        !           307:        }
        !           308:        if (argc < 3) {
        !           309:                strcat(line, " ");
        !           310:                printf("(local-file) ");
        !           311:                gets(&line[strlen(line)]);
        !           312:                makeargv();
        !           313:                argc = margc;
        !           314:                argv = margv;
        !           315:        }
        !           316:        if (argc < 3) 
        !           317:                goto usage;
        !           318:        if (!globulize(&argv[2]))
        !           319:                return;
        !           320: 
        !           321:        recvrequest("RETR", argv[2], argv[1], "w");
        !           322: }
        !           323: /*
        !           324:  * given a remote file name, strip directory path and version number
        !           325:  */
        !           326: char *
        !           327: getlocalname(cp)
        !           328:        char *cp;
        !           329: {
        !           330:        char *result;
        !           331:        static char buf[MAXPATHLEN];
        !           332: 
        !           333:        result = rindex(cp,'/'); /* find last component */
        !           334:        if (result == NULL) result = cp;
        !           335:        else result += 1;
        !           336:        strcpy(buf, result);
        !           337:        result = index(buf,'!'); /* strip version # if any */
        !           338:        if (result != NULL && result != buf) *result = '\000';
        !           339:        return(buf);
        !           340: }
        !           341: 
        !           342: /*
        !           343:  * Get multiple files.
        !           344:  */
        !           345: mget(argc, argv)
        !           346:        char *argv[];
        !           347: {
        !           348:        char *cp;
        !           349:        char *tailp;
        !           350: 
        !           351:        if (argc < 2) {
        !           352:                strcat(line, " ");
        !           353:                printf("(remote-files) ");
        !           354:                gets(&line[strlen(line)]);
        !           355:                makeargv();
        !           356:                argc = margc;
        !           357:                argv = margv;
        !           358:        }
        !           359:        if (argc < 2) {
        !           360:                printf("%s remote-files\n", argv[0]);
        !           361:                return;
        !           362:        }
        !           363:        while ((cp = remglob(argc, argv)) != NULL)
        !           364:                if (confirm(argv[0], cp)) {
        !           365:                        tailp = getlocalname(cp);
        !           366:                        recvrequest("RETR", tailp, cp, "w");
        !           367:                }
        !           368: }
        !           369: 
        !           370: /*
        !           371:  * Deserialize a file to file/descendants]
        !           372:  */
        !           373: restore(argc, argv)
        !           374:        int argc;
        !           375:        char *argv[];
        !           376: {
        !           377:        char *cmd;
        !           378: 
        !           379:        if (argc == 2)
        !           380:                argc++, argv[2] = argv[1];
        !           381:        if (argc < 2) {
        !           382:                strcat(line, " ");
        !           383:                printf("(local-file) ");
        !           384:                gets(&line[strlen(line)]);
        !           385:                makeargv();
        !           386:                argc = margc;
        !           387:                argv = margv;
        !           388:        }
        !           389:        if (argc < 2) {
        !           390: usage:
        !           391:                printf("%s local-file remote-file\n", argv[0]);
        !           392:                return;
        !           393:        }
        !           394:        if (argc < 3) {
        !           395:                strcat(line, " ");
        !           396:                printf("(remote-file) ");
        !           397:                gets(&line[strlen(line)]);
        !           398:                makeargv();
        !           399:                argc = margc;
        !           400:                argv = margv;
        !           401:        }
        !           402:        if (argc < 3) 
        !           403:                goto usage;
        !           404:        if (!globulize(&argv[1]))
        !           405:                return;
        !           406:        cmd = "DSER";
        !           407: 
        !           408:        sendrequest(cmd, argv[1], argv[2]);
        !           409: 
        !           410: }
        !           411: 
        !           412: /*
        !           413:  * Serialize a file/descendants.
        !           414:  */
        !           415: archive(argc, argv)
        !           416:        char *argv[];
        !           417: {
        !           418: 
        !           419:        if (argc == 2)
        !           420:                argc++, argv[2] = argv[1];
        !           421:        if (argc < 2) {
        !           422:                strcat(line, " ");
        !           423:                printf("(remote-file) ");
        !           424:                gets(&line[strlen(line)]);
        !           425:                makeargv();
        !           426:                argc = margc;
        !           427:                argv = margv;
        !           428:        }
        !           429:        if (argc < 2) {
        !           430: usage:
        !           431:                printf("%s remote-file [ local-file ]\n", argv[0]);
        !           432:                return;
        !           433:        }
        !           434:        if (argc < 3) {
        !           435:                strcat(line, " ");
        !           436:                printf("(local-file) ");
        !           437:                gets(&line[strlen(line)]);
        !           438:                makeargv();
        !           439:                argc = margc;
        !           440:                argv = margv;
        !           441:        }
        !           442:        if (argc < 3) 
        !           443:                goto usage;
        !           444:        if (!globulize(&argv[2]))
        !           445:                return;
        !           446: 
        !           447:        recvrequest("SER", argv[2], argv[1], "w");
        !           448: }
        !           449: 
        !           450: char *
        !           451: remglob(argc, argv)
        !           452:        char *argv[];
        !           453: {
        !           454:        char temp[16];
        !           455:        static char buf[MAXPATHLEN];
        !           456:        static FILE *ftemp = NULL;
        !           457:        static char **args;
        !           458:        int oldverbose, oldhash;
        !           459:        char *cp, *mode;
        !           460: 
        !           461:        if (!doglob) {
        !           462:                if (args == NULL)
        !           463:                        args = argv;
        !           464:                if ((cp = *++args) == NULL)
        !           465:                        args = NULL;
        !           466:                return (cp);
        !           467:        }
        !           468:        if (ftemp == NULL) {
        !           469:                strcpy(temp, "/tmp/ftpXXXXXX");
        !           470:                mktemp(temp);
        !           471:                oldverbose = verbose, verbose = 0;
        !           472:                oldhash = hash, hash = 0;
        !           473:                for (mode = "w"; *++argv != NULL; mode = "a")
        !           474:                        recvrequest("NLST", temp, *argv, mode);
        !           475:                verbose = oldverbose; hash = oldhash;
        !           476:                ftemp = fopen(temp, "r");
        !           477:                unlink(temp);
        !           478:                if (ftemp == NULL) {
        !           479:                        printf("can't find list of remote files, oops\n");
        !           480:                        return (NULL);
        !           481:                }
        !           482:        }
        !           483:        if (fgets(buf, sizeof (buf), ftemp) == NULL) {
        !           484:                fclose(ftemp), ftemp = NULL;
        !           485:                return (NULL);
        !           486:        }
        !           487:        if ((cp = index(buf, '\n')) != NULL)
        !           488:                *cp = '\0';
        !           489:        return (buf);
        !           490: }
        !           491: 
        !           492: char *
        !           493: onoff(bool)
        !           494:        int bool;
        !           495: {
        !           496: 
        !           497:        return (bool ? "on" : "off");
        !           498: }
        !           499: 
        !           500: /*
        !           501:  * Show status.
        !           502:  */
        !           503: status(argc, argv)
        !           504:        char *argv[];
        !           505: {
        !           506: 
        !           507:        if (connected)
        !           508:                printf("Connected to %s.\n", hostname);
        !           509:        else
        !           510:                printf("Not connected.\n");
        !           511:        printf("Type: %s\n", typename);
        !           512:        printf("Verbose: %s; Bell: %s; Prompting: %s; Globbing: %s\n", 
        !           513:                onoff(verbose), onoff(bell), onoff(interactive),
        !           514:                onoff(doglob));
        !           515:        printf("Hash mark printing: %s\n",
        !           516:                onoff(hash));
        !           517: }
        !           518: 
        !           519: /*
        !           520:  * Set beep on cmd completed mode.
        !           521:  */
        !           522: /*VARARGS*/
        !           523: setbell()
        !           524: {
        !           525: 
        !           526:        bell = !bell;
        !           527:        printf("Bell mode %s.\n", onoff(bell));
        !           528: }
        !           529: 
        !           530: /*
        !           531:  * Turn on packet tracing.
        !           532:  */
        !           533: /*VARARGS*/
        !           534: settrace()
        !           535: {
        !           536: 
        !           537:        trace = !trace;
        !           538:        printf("Packet tracing %s.\n", onoff(trace));
        !           539: }
        !           540: 
        !           541: /*
        !           542:  * Toggle hash mark printing during transfers.
        !           543:  */
        !           544: /*VARARGS*/
        !           545: sethash()
        !           546: {
        !           547: 
        !           548:        hash = !hash;
        !           549:        printf("Hash mark printing %s", onoff(hash));
        !           550:        if (hash)
        !           551:                printf(" (1 packet/hash mark)");
        !           552:        printf(".\n");
        !           553: }
        !           554: 
        !           555: /*
        !           556:  * Turn on printing of server echo's.
        !           557:  */
        !           558: /*VARARGS*/
        !           559: setverbose()
        !           560: {
        !           561: 
        !           562:        verbose = !verbose;
        !           563:        printf("Verbose mode %s.\n", onoff(verbose));
        !           564: }
        !           565: 
        !           566: /*
        !           567:  * Turn on interactive prompting
        !           568:  * during mget, mput, and mdelete.
        !           569:  */
        !           570: /*VARARGS*/
        !           571: setprompt()
        !           572: {
        !           573: 
        !           574:        interactive = !interactive;
        !           575:        printf("Interactive mode %s.\n", onoff(interactive));
        !           576: }
        !           577: 
        !           578: /*
        !           579:  * Toggle metacharacter interpretation
        !           580:  * on local file names.
        !           581:  */
        !           582: /*VARARGS*/
        !           583: setglob()
        !           584: {
        !           585:        
        !           586:        doglob = !doglob;
        !           587:        printf("Globbing %s.\n", onoff(doglob));
        !           588: }
        !           589: 
        !           590: /*
        !           591:  * Set debugging mode on/off and/or
        !           592:  * set level of debugging.
        !           593:  */
        !           594: /*VARARGS*/
        !           595: setdebug(argc, argv)
        !           596:        char *argv[];
        !           597: {
        !           598:        int val;
        !           599: 
        !           600:        if (argc > 1) {
        !           601:                val = atoi(argv[1]);
        !           602:                if (val < 0) {
        !           603:                        printf("%s: bad debugging value.\n", argv[1]);
        !           604:                        return;
        !           605:                }
        !           606:        } else
        !           607:                val = !debug;
        !           608:        debug = val;
        !           609:        printf("Debugging %s (debug=%d).\n", onoff(debug), debug);
        !           610: }
        !           611: 
        !           612: /*
        !           613:  * Set current working directory
        !           614:  * on remote machine.
        !           615:  */
        !           616: cd(argc, argv)
        !           617:        char *argv[];
        !           618: {
        !           619: 
        !           620:        if (argc < 2) {
        !           621:                strcat(line, " ");
        !           622:                printf("(remote-directory) ");
        !           623:                gets(&line[strlen(line)]);
        !           624:                makeargv();
        !           625:                argc = margc;
        !           626:                argv = margv;
        !           627:        }
        !           628:        if (argc < 2) {
        !           629:                printf("%s remote-directory\n", argv[0]);
        !           630:                return;
        !           631:        }
        !           632:        (void) docd(argv[1]);
        !           633: }
        !           634: 
        !           635: /*
        !           636:  * Set current working directory
        !           637:  * on local machine.
        !           638:  */
        !           639: lcd(argc, argv)
        !           640:        char *argv[];
        !           641: {
        !           642:        char buf[MAXPATHLEN];
        !           643: 
        !           644:        if (argc < 2)
        !           645:                argc++, argv[1] = home;
        !           646:        if (argc != 2) {
        !           647:                printf("%s local-directory\n", argv[0]);
        !           648:                return;
        !           649:        }
        !           650:        if (!globulize(&argv[1]))
        !           651:                return;
        !           652:        if (chdir(argv[1]) < 0) {
        !           653:                perror(argv[1]);
        !           654:                return;
        !           655:        }
        !           656:        printf("Local directory now %s\n", getwd(buf));
        !           657: }
        !           658: 
        !           659: /*
        !           660:  * Delete a single file.
        !           661:  */
        !           662: delete(argc, argv)
        !           663:        char *argv[];
        !           664: {
        !           665: 
        !           666:        if (argc < 2) {
        !           667:                strcat(line, " ");
        !           668:                printf("(remote-file) ");
        !           669:                gets(&line[strlen(line)]);
        !           670:                makeargv();
        !           671:                argc = margc;
        !           672:                argv = margv;
        !           673:        }
        !           674:        if (argc < 2) {
        !           675:                printf("%s remote-file\n", argv[0]);
        !           676:                return;
        !           677:        }
        !           678:        (void) dodelete( argv[1]);
        !           679: }
        !           680: 
        !           681: /*
        !           682:  * Delete multiple files.
        !           683:  */
        !           684: mdelete(argc, argv)
        !           685:        char *argv[];
        !           686: {
        !           687:        char *cp;
        !           688: 
        !           689:        if (argc < 2) {
        !           690:                strcat(line, " ");
        !           691:                printf("(remote-files) ");
        !           692:                gets(&line[strlen(line)]);
        !           693:                makeargv();
        !           694:                argc = margc;
        !           695:                argv = margv;
        !           696:        }
        !           697:        if (argc < 2) {
        !           698:                printf("%s remote-files\n", argv[0]);
        !           699:                return;
        !           700:        }
        !           701:        while ((cp = remglob(argc, argv)) != NULL)
        !           702:                if (confirm(argv[0], cp))
        !           703:                        (void) dodelete( cp);
        !           704: }
        !           705: 
        !           706: /*
        !           707:  * Rename a remote file.
        !           708:  */
        !           709: renamefile(argc, argv)
        !           710:        char *argv[];
        !           711: {
        !           712: 
        !           713:        if (argc < 2) {
        !           714:                strcat(line, " ");
        !           715:                printf("(from-name) ");
        !           716:                gets(&line[strlen(line)]);
        !           717:                makeargv();
        !           718:                argc = margc;
        !           719:                argv = margv;
        !           720:        }
        !           721:        if (argc < 2) {
        !           722: usage:
        !           723:                printf("%s from-name to-name\n", argv[0]);
        !           724:                return;
        !           725:        }
        !           726:        if (argc < 3) {
        !           727:                strcat(line, " ");
        !           728:                printf("(to-name) ");
        !           729:                gets(&line[strlen(line)]);
        !           730:                makeargv();
        !           731:                argc = margc;
        !           732:                argv = margv;
        !           733:        }
        !           734:        if (argc < 3) 
        !           735:                goto usage;
        !           736:        dorename(argv[1], argv[2]);
        !           737: }
        !           738: 
        !           739: /*
        !           740:  * Copy a remote file.
        !           741:  */
        !           742: copyfile(argc, argv)
        !           743:        char *argv[];
        !           744: {
        !           745: 
        !           746:        if (argc < 2) {
        !           747:                strcat(line, " ");
        !           748:                printf("(from-name) ");
        !           749:                gets(&line[strlen(line)]);
        !           750:                makeargv();
        !           751:                argc = margc;
        !           752:                argv = margv;
        !           753:        }
        !           754:        if (argc < 2) {
        !           755: usage:
        !           756:                printf("%s from-name to-name\n", argv[0]);
        !           757:                return;
        !           758:        }
        !           759:        if (argc < 3) {
        !           760:                strcat(line, " ");
        !           761:                printf("(to-name) ");
        !           762:                gets(&line[strlen(line)]);
        !           763:                makeargv();
        !           764:                argc = margc;
        !           765:                argv = margv;
        !           766:        }
        !           767:        if (argc < 3) 
        !           768:                goto usage;
        !           769:        docopy("COPY", argv[1], argv[2]);
        !           770: }
        !           771: 
        !           772: /*
        !           773:  * Move a remote file.
        !           774:  */
        !           775: movefile(argc, argv)
        !           776:        char *argv[];
        !           777: {
        !           778: 
        !           779:        if (argc < 2) {
        !           780:                strcat(line, " ");
        !           781:                printf("(from-name) ");
        !           782:                gets(&line[strlen(line)]);
        !           783:                makeargv();
        !           784:                argc = margc;
        !           785:                argv = margv;
        !           786:        }
        !           787:        if (argc < 2) {
        !           788: usage:
        !           789:                printf("%s from-name to-name\n", argv[0]);
        !           790:                return;
        !           791:        }
        !           792:        if (argc < 3) {
        !           793:                strcat(line, " ");
        !           794:                printf("(to-directory) ");
        !           795:                gets(&line[strlen(line)]);
        !           796:                makeargv();
        !           797:                argc = margc;
        !           798:                argv = margv;
        !           799:        }
        !           800:        if (argc < 3) 
        !           801:                goto usage;
        !           802:        docopy("MOVE", argv[1], argv[2]);
        !           803: }
        !           804: 
        !           805: /*
        !           806:  * Get a directory listing
        !           807:  * of remote files.
        !           808:  */
        !           809: ls(argc, argv)
        !           810:        char *argv[];
        !           811: {
        !           812:        char *cmd;
        !           813: 
        !           814:        if (argc < 2)
        !           815:                argc++, argv[1] = "*";
        !           816:        if (argc < 3)
        !           817:                argc++, argv[2] = "-";
        !           818:        if (argc > 3) {
        !           819:                printf("usage: %s remote-directory local-file\n", argv[0]);
        !           820:                return;
        !           821:        }
        !           822:        cmd = argv[0][0] == 'l' ? "NLST" : "LIST";
        !           823:        if (strcmp(argv[2], "-") && !globulize(&argv[2]))
        !           824:                return;
        !           825:        recvrequest(cmd, argv[2], argv[1], "w");
        !           826: }
        !           827: 
        !           828: /*
        !           829:  * Get a directory listing
        !           830:  * of multiple remote files.
        !           831:  */
        !           832: mls(argc, argv)
        !           833:        char *argv[];
        !           834: {
        !           835:        char *cmd, *mode, *cp, *dest;
        !           836: 
        !           837:        if (argc < 2) {
        !           838:                strcat(line, " ");
        !           839:                printf("(remote-files) ");
        !           840:                gets(&line[strlen(line)]);
        !           841:                makeargv();
        !           842:                argc = margc;
        !           843:                argv = margv;
        !           844:        }
        !           845:        if (argc < 3) {
        !           846:                strcat(line, " ");
        !           847:                printf("(local-file) ");
        !           848:                gets(&line[strlen(line)]);
        !           849:                makeargv();
        !           850:                argc = margc;
        !           851:                argv = margv;
        !           852:        }
        !           853:        if (argc < 3) {
        !           854:                printf("%s remote-files local-file\n", argv[0]);
        !           855:                return;
        !           856:        }
        !           857:        dest = argv[argc - 1];
        !           858:        argv[argc - 1] = NULL;
        !           859:        if (strcmp(dest, "-"))
        !           860:                if (globulize(&dest) && confirm("local-file", dest))
        !           861:                        return;
        !           862:        cmd = argv[0][1] == 'l' ? "NLST" : "LIST";
        !           863:        for (mode = "w"; cp = remglob(argc, argv); mode = "a")
        !           864:                if (confirm(argv[0], cp))
        !           865:                        recvrequest(cmd, argv[2], argv[1], "w");
        !           866: }
        !           867: 
        !           868: /*
        !           869:  * Unify Accesslists for a single file.
        !           870:  */
        !           871: unify(argc, argv)
        !           872:        char *argv[];
        !           873: {
        !           874: 
        !           875:        if (argc < 2) {
        !           876:                strcat(line, " ");
        !           877:                printf("(remote-directory) ");
        !           878:                gets(&line[strlen(line)]);
        !           879:                makeargv();
        !           880:                argc = margc;
        !           881:                argv = margv;
        !           882:        }
        !           883:        if (argc < 2) {
        !           884:                printf("%s remote-directory\n", argv[0]);
        !           885:                return;
        !           886:        }
        !           887:        (void) dounify( argv[1]);
        !           888: }
        !           889: 
        !           890: /*
        !           891:  * Do a shell escape
        !           892:  */
        !           893: shell(argc, argv)
        !           894:        char *argv[];
        !           895: {
        !           896:        int pid, status, (*old1)(), (*old2)();
        !           897:        char shellnam[40], *shell, *namep;
        !           898:        char **cpp, **gargs;
        !           899: 
        !           900:        old1 = signal (SIGINT, SIG_IGN);
        !           901:        old2 = signal (SIGQUIT, SIG_IGN);
        !           902:        if ((pid = fork()) == 0) {
        !           903:                for (pid = 3; pid < 20; pid++)
        !           904:                        close(pid);
        !           905:                signal(SIGINT, SIG_DFL);
        !           906:                signal(SIGQUIT, SIG_DFL);
        !           907:                if (argc <= 1) {
        !           908:                        shell = getenv("SHELL");
        !           909:                        if (shell == NULL)
        !           910:                                shell = "/bin/sh";
        !           911:                        namep = rindex(shell,'/');
        !           912:                        if (namep == NULL)
        !           913:                                namep = shell;
        !           914:                        strcpy(shellnam,"-");
        !           915:                        strcat(shellnam, ++namep);
        !           916:                        if (strcmp(namep, "sh") != 0)
        !           917:                                shellnam[0] = '+';
        !           918:                        if (debug) {
        !           919:                                printf ("%s\n", shell);
        !           920:                                fflush (stdout);
        !           921:                        }
        !           922:                        execl(shell, shellnam, 0);
        !           923:                        perror(shell);
        !           924:                        exit(1);
        !           925:                }
        !           926:                cpp = &argv[1];
        !           927:                if (argc > 2) {
        !           928:                        if ((gargs = glob(cpp)) != NULL)
        !           929:                                cpp = gargs;
        !           930:                        if (globerr != NULL) {
        !           931:                                printf("%s\n", globerr);
        !           932:                                exit(1);
        !           933:                        }
        !           934:                }
        !           935:                if (debug) {
        !           936:                        register char **zip = cpp;
        !           937: 
        !           938:                        printf("%s", *zip);
        !           939:                        while (*++zip != NULL)
        !           940:                                printf(" %s", *zip);
        !           941:                        printf("\n");
        !           942:                        fflush(stdout);
        !           943:                }
        !           944:                execvp(argv[1], cpp);
        !           945:                perror(argv[1]);
        !           946:                exit(1);
        !           947:        }
        !           948:        if (pid > 0)
        !           949:                while (wait(&status) != pid)
        !           950:                        ;
        !           951:        signal(SIGINT, old1);
        !           952:        signal(SIGQUIT, old2);
        !           953:        if (pid == -1)
        !           954:                perror("Try again later");
        !           955:        return (0);
        !           956: }
        !           957: 
        !           958: /*
        !           959:  * Send new user information (re-login)
        !           960:  */
        !           961: user(argc, argv)
        !           962:        int argc;
        !           963:        char **argv;
        !           964: {
        !           965: 
        !           966:        if (argc < 2) {
        !           967:                login(0,0);
        !           968:        }
        !           969:        if (argc > 3) {
        !           970:                printf("usage: %s username [password]\n", argv[0]);
        !           971:                return (0);
        !           972:        }
        !           973:        login(argv[1], argv[2]);
        !           974:        return (1);
        !           975: }
        !           976: 
        !           977: /*
        !           978:  * Print working directory.
        !           979:  */
        !           980: /*VARARGS*/
        !           981: pwd()
        !           982: {
        !           983:        dopwd();
        !           984: }
        !           985: 
        !           986: /*
        !           987:  * Make a directory.
        !           988:  */
        !           989: makedir(argc, argv)
        !           990:        char *argv[];
        !           991: {
        !           992: 
        !           993:        if (argc < 2) {
        !           994:                strcat(line, " ");
        !           995:                printf("(directory-name) ");
        !           996:                gets(&line[strlen(line)]);
        !           997:                makeargv();
        !           998:                argc = margc;
        !           999:                argv = margv;
        !          1000:        }
        !          1001:        if (argc < 2) {
        !          1002:                printf("%s directory-name\n", argv[0]);
        !          1003:                return;
        !          1004:        }
        !          1005:        domakedir(argv[1]);
        !          1006: }
        !          1007: 
        !          1008: /*
        !          1009:  * Remove a directory.
        !          1010:  */
        !          1011: removedir(argc, argv)
        !          1012:        char *argv[];
        !          1013: {
        !          1014: 
        !          1015:        if (argc < 2) {
        !          1016:                strcat(line, " ");
        !          1017:                printf("(directory-name) ");
        !          1018:                gets(&line[strlen(line)]);
        !          1019:                makeargv();
        !          1020:                argc = margc;
        !          1021:                argv = margv;
        !          1022:        }
        !          1023:        if (argc < 2) {
        !          1024:                printf("%s directory-name\n", argv[0]);
        !          1025:                return;
        !          1026:        }
        !          1027:        doremovedir(argv[1]);
        !          1028: }
        !          1029: 
        !          1030: /*
        !          1031:  * Terminate session and exit.
        !          1032:  */
        !          1033: /*VARARGS*/
        !          1034: quit()
        !          1035: {
        !          1036: 
        !          1037:        disconnect();
        !          1038:        exit(0);
        !          1039: }
        !          1040: 
        !          1041: /*
        !          1042:  * Terminate session, but don't exit.
        !          1043:  */
        !          1044: disconnect()
        !          1045: {
        !          1046:        extern FILE *cout;
        !          1047:        extern int data;
        !          1048: 
        !          1049:        if (!connected)
        !          1050:                return;
        !          1051:        logout();
        !          1052:        CourierClose(connected);
        !          1053:        connected = (CourierConnection *)0;
        !          1054: }
        !          1055: 
        !          1056: confirm(cmd, file)
        !          1057:        char *cmd, *file;
        !          1058: {
        !          1059:        char line[BUFSIZ];
        !          1060: 
        !          1061:        if (!interactive) {
        !          1062:                if (verbose)
        !          1063:                        printf("%s %s\n", cmd, file);
        !          1064:                return (1);
        !          1065:        }
        !          1066:        printf("%s %s? ", cmd, file);
        !          1067:        fflush(stdout);
        !          1068:        gets(line);
        !          1069:        return (*line != 'n' && *line != 'N');
        !          1070: }
        !          1071: 
        !          1072: fatal(msg)
        !          1073:        char *msg;
        !          1074: {
        !          1075: 
        !          1076:        fprintf(stderr, "ftp: %s\n");
        !          1077:        exit(1);
        !          1078: }
        !          1079: 
        !          1080: /*
        !          1081:  * Glob a local file name specification with
        !          1082:  * the expectation of a single return value.
        !          1083:  * Can't control multiple values being expanded
        !          1084:  * from the expression, we return only the first.
        !          1085:  */
        !          1086: globulize(cpp)
        !          1087:        char **cpp;
        !          1088: {
        !          1089:        char **globbed;
        !          1090: 
        !          1091:        if (!doglob)
        !          1092:                return (1);
        !          1093:        globbed = glob(*cpp);
        !          1094:        if (globerr != NULL) {
        !          1095:                printf("%s: %s\n", *cpp, globerr);
        !          1096:                if (globbed)
        !          1097:                        blkfree(globbed);
        !          1098:                return (0);
        !          1099:        }
        !          1100:        if (globbed) {
        !          1101:                *cpp = *globbed++;
        !          1102:                /* don't waste too much memory */
        !          1103:                if (*globbed)
        !          1104:                        blkfree(globbed);
        !          1105:        }
        !          1106:        return (1);
        !          1107: }
        !          1108: 
        !          1109: whatis(argc, argv)
        !          1110:        int argc;
        !          1111:        char *argv[];
        !          1112: {
        !          1113:        FILE *fin, *fopen();
        !          1114:        int type;
        !          1115:        char *typetostring();
        !          1116: 
        !          1117:        if (argc < 2) {
        !          1118:                strcat(line, " ");
        !          1119:                printf("(local-file) ");
        !          1120:                gets(&line[strlen(line)]);
        !          1121:                makeargv();
        !          1122:                argc = margc;
        !          1123:                argv = margv;
        !          1124:        }
        !          1125:        if (argc < 2) {
        !          1126: usage:
        !          1127:                printf("%s local-file\n", argv[0]);
        !          1128:                return;
        !          1129:        }
        !          1130: 
        !          1131:        if ( access(argv[1], R_OK | F_OK ) == -1 ) {
        !          1132:                perror("file error: ");
        !          1133:                return;
        !          1134:        }
        !          1135: 
        !          1136:        type= get_type(argv[1]);
        !          1137: 
        !          1138:        printf("file %s is assumed to be %s\n", argv[1], typetostring(type));
        !          1139: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.