Return to cmds.c CVS log

Up to [CSRG BSD Unix] / 43BSD / ucb / ftp

Annotation of 43BSD/ucb/ftp/cmds.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1985 Regents of the University of California.
        !             3:  * All rights reserved.  The Berkeley software License Agreement
        !             4:  * specifies the terms and conditions for redistribution.
        !             5:  */
        !             6: 
        !             7: #ifndef lint
        !             8: static char sccsid[] = "@(#)cmds.c     5.5 (Berkeley) 3/7/86";
        !             9: #endif not lint
        !            10: 
        !            11: /*
        !            12:  * FTP User Program -- Command Routines.
        !            13:  */
        !            14: #include "ftp_var.h"
        !            15: #include <sys/socket.h>
        !            16: 
        !            17: #include <arpa/ftp.h>
        !            18: 
        !            19: #include <signal.h>
        !            20: #include <stdio.h>
        !            21: #include <errno.h>
        !            22: #include <netdb.h>
        !            23: #include <ctype.h>
        !            24: #include <sys/wait.h>
        !            25: 
        !            26: 
        !            27: extern char *globerr;
        !            28: extern char **glob();
        !            29: extern char *home;
        !            30: extern short gflag;
        !            31: extern char *remglob();
        !            32: extern char *getenv();
        !            33: extern char *index();
        !            34: extern char *rindex();
        !            35: char *mname;
        !            36: jmp_buf jabort;
        !            37: char *dotrans(), *domap();
        !            38: 
        !            39: /*
        !            40:  * Connect to peer server and
        !            41:  * auto-login, if possible.
        !            42:  */
        !            43: setpeer(argc, argv)
        !            44:        int argc;
        !            45:        char *argv[];
        !            46: {
        !            47:        char *host, *hookup();
        !            48:        int port;
        !            49: 
        !            50:        if (connected) {
        !            51:                printf("Already connected to %s, use close first.\n",
        !            52:                        hostname);
        !            53:                code = -1;
        !            54:                return;
        !            55:        }
        !            56:        if (argc < 2) {
        !            57:                (void) strcat(line, " ");
        !            58:                printf("(to) ");
        !            59:                (void) gets(&line[strlen(line)]);
        !            60:                makeargv();
        !            61:                argc = margc;
        !            62:                argv = margv;
        !            63:        }
        !            64:        if (argc > 3) {
        !            65:                printf("usage: %s host-name [port]\n", argv[0]);
        !            66:                code = -1;
        !            67:                return;
        !            68:        }
        !            69:        port = sp->s_port;
        !            70:        if (argc > 2) {
        !            71:                port = atoi(argv[2]);
        !            72:                if (port <= 0) {
        !            73:                        printf("%s: bad port number-- %s\n", argv[1], argv[2]);
        !            74:                        printf ("usage: %s host-name [port]\n", argv[0]);
        !            75:                        code = -1;
        !            76:                        return;
        !            77:                }
        !            78:                port = htons(port);
        !            79:        }
        !            80:        host = hookup(argv[1], port);
        !            81:        if (host) {
        !            82:                connected = 1;
        !            83:                if (autologin)
        !            84:                        (void) login(argv[1]);
        !            85:        }
        !            86: }
        !            87: 
        !            88: struct types {
        !            89:        char    *t_name;
        !            90:        char    *t_mode;
        !            91:        int     t_type;
        !            92:        char    *t_arg;
        !            93: } types[] = {
        !            94:        { "ascii",      "A",    TYPE_A, 0 },
        !            95:        { "binary",     "I",    TYPE_I, 0 },
        !            96:        { "image",      "I",    TYPE_I, 0 },
        !            97:        { "ebcdic",     "E",    TYPE_E, 0 },
        !            98:        { "tenex",      "L",    TYPE_L, bytename },
        !            99:        0
        !           100: };
        !           101: 
        !           102: /*
        !           103:  * Set transfer type.
        !           104:  */
        !           105: settype(argc, argv)
        !           106:        char *argv[];
        !           107: {
        !           108:        register struct types *p;
        !           109:        int comret;
        !           110: 
        !           111:        if (argc > 2) {
        !           112:                char *sep;
        !           113: 
        !           114:                printf("usage: %s [", argv[0]);
        !           115:                sep = " ";
        !           116:                for (p = types; p->t_name; p++) {
        !           117:                        printf("%s%s", sep, p->t_name);
        !           118:                        if (*sep == ' ')
        !           119:                                sep = " | ";
        !           120:                }
        !           121:                printf(" ]\n");
        !           122:                code = -1;
        !           123:                return;
        !           124:        }
        !           125:        if (argc < 2) {
        !           126:                printf("Using %s mode to transfer files.\n", typename);
        !           127:                code = 0;
        !           128:                return;
        !           129:        }
        !           130:        for (p = types; p->t_name; p++)
        !           131:                if (strcmp(argv[1], p->t_name) == 0)
        !           132:                        break;
        !           133:        if (p->t_name == 0) {
        !           134:                printf("%s: unknown mode\n", argv[1]);
        !           135:                code = -1;
        !           136:                return;
        !           137:        }
        !           138:        if ((p->t_arg != NULL) && (*(p->t_arg) != '\0'))
        !           139:                comret = command ("TYPE %s %s", p->t_mode, p->t_arg);
        !           140:        else
        !           141:                comret = command("TYPE %s", p->t_mode);
        !           142:        if (comret == COMPLETE) {
        !           143:                (void) strcpy(typename, p->t_name);
        !           144:                type = p->t_type;
        !           145:        }
        !           146: }
        !           147: 
        !           148: /*
        !           149:  * Set binary transfer type.
        !           150:  */
        !           151: /*VARARGS*/
        !           152: setbinary()
        !           153: {
        !           154: 
        !           155:        call(settype, "type", "binary", 0);
        !           156: }
        !           157: 
        !           158: /*
        !           159:  * Set ascii transfer type.
        !           160:  */
        !           161: /*VARARGS*/
        !           162: setascii()
        !           163: {
        !           164: 
        !           165:        call(settype, "type", "ascii", 0);
        !           166: }
        !           167: 
        !           168: /*
        !           169:  * Set tenex transfer type.
        !           170:  */
        !           171: /*VARARGS*/
        !           172: settenex()
        !           173: {
        !           174: 
        !           175:        call(settype, "type", "tenex", 0);
        !           176: }
        !           177: 
        !           178: /*
        !           179:  * Set ebcdic transfer type.
        !           180:  */
        !           181: /*VARARGS*/
        !           182: setebcdic()
        !           183: {
        !           184: 
        !           185:        call(settype, "type", "ebcdic", 0);
        !           186: }
        !           187: 
        !           188: /*
        !           189:  * Set file transfer mode.
        !           190:  */
        !           191: /*ARGSUSED*/
        !           192: setmode(argc, argv)
        !           193:        char *argv[];
        !           194: {
        !           195: 
        !           196:        printf("We only support %s mode, sorry.\n", modename);
        !           197:        code = -1;
        !           198: }
        !           199: 
        !           200: /*
        !           201:  * Set file transfer format.
        !           202:  */
        !           203: /*ARGSUSED*/
        !           204: setform(argc, argv)
        !           205:        char *argv[];
        !           206: {
        !           207: 
        !           208:        printf("We only support %s format, sorry.\n", formname);
        !           209:        code = -1;
        !           210: }
        !           211: 
        !           212: /*
        !           213:  * Set file transfer structure.
        !           214:  */
        !           215: /*ARGSUSED*/
        !           216: setstruct(argc, argv)
        !           217:        char *argv[];
        !           218: {
        !           219: 
        !           220:        printf("We only support %s structure, sorry.\n", structname);
        !           221:        code = -1;
        !           222: }
        !           223: 
        !           224: /*
        !           225:  * Send a single file.
        !           226:  */
        !           227: put(argc, argv)
        !           228:        int argc;
        !           229:        char *argv[];
        !           230: {
        !           231:        char *cmd;
        !           232:        int loc = 0;
        !           233:        char *oldargv1;
        !           234: 
        !           235:        if (argc == 2) {
        !           236:                argc++;
        !           237:                argv[2] = argv[1];
        !           238:                loc++;
        !           239:        }
        !           240:        if (argc < 2) {
        !           241:                (void) strcat(line, " ");
        !           242:                printf("(local-file) ");
        !           243:                (void) gets(&line[strlen(line)]);
        !           244:                makeargv();
        !           245:                argc = margc;
        !           246:                argv = margv;
        !           247:        }
        !           248:        if (argc < 2) {
        !           249: usage:
        !           250:                printf("usage:%s local-file remote-file\n", argv[0]);
        !           251:                code = -1;
        !           252:                return;
        !           253:        }
        !           254:        if (argc < 3) {
        !           255:                (void) strcat(line, " ");
        !           256:                printf("(remote-file) ");
        !           257:                (void) gets(&line[strlen(line)]);
        !           258:                makeargv();
        !           259:                argc = margc;
        !           260:                argv = margv;
        !           261:        }
        !           262:        if (argc < 3) 
        !           263:                goto usage;
        !           264:        oldargv1 = argv[1];
        !           265:        if (!globulize(&argv[1])) {
        !           266:                code = -1;
        !           267:                return;
        !           268:        }
        !           269:        /*
        !           270:         * If "globulize" modifies argv[1], and argv[2] is a copy of
        !           271:         * the old argv[1], make it a copy of the new argv[1].
        !           272:         */
        !           273:        if (argv[1] != oldargv1 && argv[2] == oldargv1) {
        !           274:                argv[2] = argv[1];
        !           275:        }
        !           276:        cmd = (argv[0][0] == 'a') ? "APPE" : ((sunique) ? "STOU" : "STOR");
        !           277:        if (loc && ntflag) {
        !           278:                argv[2] = dotrans(argv[2]);
        !           279:        }
        !           280:        if (loc && mapflag) {
        !           281:                argv[2] = domap(argv[2]);
        !           282:        }
        !           283:        sendrequest(cmd, argv[1], argv[2]);
        !           284: }
        !           285: 
        !           286: /*
        !           287:  * Send multiple files.
        !           288:  */
        !           289: mput(argc, argv)
        !           290:        char *argv[];
        !           291: {
        !           292:        register int i;
        !           293:        int ointer, (*oldintr)(), mabort();
        !           294:        extern jmp_buf jabort;
        !           295:        char *tp;
        !           296: 
        !           297:        if (argc < 2) {
        !           298:                (void) strcat(line, " ");
        !           299:                printf("(local-files) ");
        !           300:                (void) gets(&line[strlen(line)]);
        !           301:                makeargv();
        !           302:                argc = margc;
        !           303:                argv = margv;
        !           304:        }
        !           305:        if (argc < 2) {
        !           306:                printf("usage:%s local-files\n", argv[0]);
        !           307:                code = -1;
        !           308:                return;
        !           309:        }
        !           310:        mname = argv[0];
        !           311:        mflag = 1;
        !           312:        oldintr = signal(SIGINT, mabort);
        !           313:        (void) setjmp(jabort);
        !           314:        if (proxy) {
        !           315:                char *cp, *tp2, tmpbuf[MAXPATHLEN];
        !           316: 
        !           317:                while ((cp = remglob(argv,0)) != NULL) {
        !           318:                        if (*cp == 0) {
        !           319:                                mflag = 0;
        !           320:                                continue;
        !           321:                        }
        !           322:                        if (mflag && confirm(argv[0], cp)) {
        !           323:                                tp = cp;
        !           324:                                if (mcase) {
        !           325:                                        while (*tp && !islower(*tp)) {
        !           326:                                                tp++;
        !           327:                                        }
        !           328:                                        if (!*tp) {
        !           329:                                                tp = cp;
        !           330:                                                tp2 = tmpbuf;
        !           331:                                                while ((*tp2 = *tp) != NULL) {
        !           332:                                                     if (isupper(*tp2)) {
        !           333:                                                        *tp2 = 'a' + *tp2 - 'A';
        !           334:                                                     }
        !           335:                                                     tp++;
        !           336:                                                     tp2++;
        !           337:                                                }
        !           338:                                        }
        !           339:                                        tp = tmpbuf;
        !           340:                                }
        !           341:                                if (ntflag) {
        !           342:                                        tp = dotrans(tp);
        !           343:                                }
        !           344:                                if (mapflag) {
        !           345:                                        tp = domap(tp);
        !           346:                                }
        !           347:                                sendrequest((sunique) ? "STOU" : "STOR", cp,tp);
        !           348:                                if (!mflag && fromatty) {
        !           349:                                        ointer = interactive;
        !           350:                                        interactive = 1;
        !           351:                                        if (confirm("Continue with","mput")) {
        !           352:                                                mflag++;
        !           353:                                        }
        !           354:                                        interactive = ointer;
        !           355:                                }
        !           356:                        }
        !           357:                }
        !           358:                (void) signal(SIGINT, oldintr);
        !           359:                mflag = 0;
        !           360:                return;
        !           361:        }
        !           362:        for (i = 1; i < argc; i++) {
        !           363:                register char **cpp, **gargs;
        !           364: 
        !           365:                if (!doglob) {
        !           366:                        if (mflag && confirm(argv[0], argv[i])) {
        !           367:                                tp = (ntflag) ? dotrans(argv[i]) : argv[i];
        !           368:                                tp = (mapflag) ? domap(tp) : tp;
        !           369:                                sendrequest((sunique) ? "STOU" : "STOR",
        !           370:                                            argv[i], tp);
        !           371:                                if (!mflag && fromatty) {
        !           372:                                        ointer = interactive;
        !           373:                                        interactive = 1;
        !           374:                                        if (confirm("Continue with","mput")) {
        !           375:                                                mflag++;
        !           376:                                        }
        !           377:                                        interactive = ointer;
        !           378:                                }
        !           379:                        }
        !           380:                        continue;
        !           381:                }
        !           382:                gargs = glob(argv[i]);
        !           383:                if (globerr != NULL) {
        !           384:                        printf("%s\n", globerr);
        !           385:                        if (gargs)
        !           386:                                blkfree(gargs);
        !           387:                        continue;
        !           388:                }
        !           389:                for (cpp = gargs; cpp && *cpp != NULL; cpp++) {
        !           390:                        if (mflag && confirm(argv[0], *cpp)) {
        !           391:                                tp = (ntflag) ? dotrans(*cpp) : *cpp;
        !           392:                                tp = (mapflag) ? domap(tp) : tp;
        !           393:                                sendrequest((sunique) ? "STOU" : "STOR",
        !           394:                                           *cpp, tp);
        !           395:                                if (!mflag && fromatty) {
        !           396:                                        ointer = interactive;
        !           397:                                        interactive = 1;
        !           398:                                        if (confirm("Continue with","mput")) {
        !           399:                                                mflag++;
        !           400:                                        }
        !           401:                                        interactive = ointer;
        !           402:                                }
        !           403:                        }
        !           404:                }
        !           405:                if (gargs != NULL)
        !           406:                        blkfree(gargs);
        !           407:        }
        !           408:        (void) signal(SIGINT, oldintr);
        !           409:        mflag = 0;
        !           410: }
        !           411: 
        !           412: /*
        !           413:  * Receive one file.
        !           414:  */
        !           415: get(argc, argv)
        !           416:        char *argv[];
        !           417: {
        !           418:        int loc = 0;
        !           419: 
        !           420:        if (argc == 2) {
        !           421:                argc++;
        !           422:                argv[2] = argv[1];
        !           423:                loc++;
        !           424:        }
        !           425:        if (argc < 2) {
        !           426:                (void) strcat(line, " ");
        !           427:                printf("(remote-file) ");
        !           428:                (void) gets(&line[strlen(line)]);
        !           429:                makeargv();
        !           430:                argc = margc;
        !           431:                argv = margv;
        !           432:        }
        !           433:        if (argc < 2) {
        !           434: usage:
        !           435:                printf("usage: %s remote-file [ local-file ]\n", argv[0]);
        !           436:                code = -1;
        !           437:                return;
        !           438:        }
        !           439:        if (argc < 3) {
        !           440:                (void) strcat(line, " ");
        !           441:                printf("(local-file) ");
        !           442:                (void) gets(&line[strlen(line)]);
        !           443:                makeargv();
        !           444:                argc = margc;
        !           445:                argv = margv;
        !           446:        }
        !           447:        if (argc < 3) 
        !           448:                goto usage;
        !           449:        if (!globulize(&argv[2])) {
        !           450:                code = -1;
        !           451:                return;
        !           452:        }
        !           453:        if (loc && mcase) {
        !           454:                char *tp = argv[1], *tp2, tmpbuf[MAXPATHLEN];
        !           455: 
        !           456:                while (*tp && !islower(*tp)) {
        !           457:                        tp++;
        !           458:                }
        !           459:                if (!*tp) {
        !           460:                        tp = argv[2];
        !           461:                        tp2 = tmpbuf;
        !           462:                        while ((*tp2 = *tp) != NULL) {
        !           463:                                if (isupper(*tp2)) {
        !           464:                                        *tp2 = 'a' + *tp2 - 'A';
        !           465:                                }
        !           466:                                tp++;
        !           467:                                tp2++;
        !           468:                        }
        !           469:                        argv[2] = tmpbuf;
        !           470:                }
        !           471:        }
        !           472:        if (loc && ntflag) {
        !           473:                argv[2] = dotrans(argv[2]);
        !           474:        }
        !           475:        if (loc && mapflag) {
        !           476:                argv[2] = domap(argv[2]);
        !           477:        }
        !           478:        recvrequest("RETR", argv[2], argv[1], "w");
        !           479: }
        !           480: 
        !           481: mabort()
        !           482: {
        !           483:        int ointer;
        !           484:        extern jmp_buf jabort;
        !           485: 
        !           486:        printf("\n");
        !           487:        (void) fflush(stdout);
        !           488:        if (mflag && fromatty) {
        !           489:                ointer = interactive;
        !           490:                interactive = 1;
        !           491:                if (confirm("Continue with", mname)) {
        !           492:                        interactive = ointer;
        !           493:                        longjmp(jabort,0);
        !           494:                }
        !           495:                interactive = ointer;
        !           496:        }
        !           497:        mflag = 0;
        !           498:        longjmp(jabort,0);
        !           499: }
        !           500: 
        !           501: /*
        !           502:  * Get multiple files.
        !           503:  */
        !           504: mget(argc, argv)
        !           505:        char *argv[];
        !           506: {
        !           507:        char *cp, *tp, *tp2, tmpbuf[MAXPATHLEN];
        !           508:        int ointer, (*oldintr)(), mabort();
        !           509:        extern jmp_buf jabort;
        !           510: 
        !           511:        if (argc < 2) {
        !           512:                (void) strcat(line, " ");
        !           513:                printf("(remote-files) ");
        !           514:                (void) gets(&line[strlen(line)]);
        !           515:                makeargv();
        !           516:                argc = margc;
        !           517:                argv = margv;
        !           518:        }
        !           519:        if (argc < 2) {
        !           520:                printf("usage:%s remote-files\n", argv[0]);
        !           521:                code = -1;
        !           522:                return;
        !           523:        }
        !           524:        mname = argv[0];
        !           525:        mflag = 1;
        !           526:        oldintr = signal(SIGINT,mabort);
        !           527:        (void) setjmp(jabort);
        !           528:        while ((cp = remglob(argv,proxy)) != NULL) {
        !           529:                if (*cp == '\0') {
        !           530:                        mflag = 0;
        !           531:                        continue;
        !           532:                }
        !           533:                if (mflag && confirm(argv[0], cp)) {
        !           534:                        tp = cp;
        !           535:                        if (mcase) {
        !           536:                                while (*tp && !islower(*tp)) {
        !           537:                                        tp++;
        !           538:                                }
        !           539:                                if (!*tp) {
        !           540:                                        tp = cp;
        !           541:                                        tp2 = tmpbuf;
        !           542:                                        while ((*tp2 = *tp) != NULL) {
        !           543:                                                if (isupper(*tp2)) {
        !           544:                                                        *tp2 = 'a' + *tp2 - 'A';
        !           545:                                                }
        !           546:                                                tp++;
        !           547:                                                tp2++;
        !           548:                                        }
        !           549:                                }
        !           550:                                tp = tmpbuf;
        !           551:                        }
        !           552:                        if (ntflag) {
        !           553:                                tp = dotrans(tp);
        !           554:                        }
        !           555:                        if (mapflag) {
        !           556:                                tp = domap(tp);
        !           557:                        }
        !           558:                        recvrequest("RETR", tp, cp, "w");
        !           559:                        if (!mflag && fromatty) {
        !           560:                                ointer = interactive;
        !           561:                                interactive = 1;
        !           562:                                if (confirm("Continue with","mget")) {
        !           563:                                        mflag++;
        !           564:                                }
        !           565:                                interactive = ointer;
        !           566:                        }
        !           567:                }
        !           568:        }
        !           569:        (void) signal(SIGINT,oldintr);
        !           570:        mflag = 0;
        !           571: }
        !           572: 
        !           573: char *
        !           574: remglob(argv,doswitch)
        !           575:        char *argv[];
        !           576:        int doswitch;
        !           577: {
        !           578:        char temp[16];
        !           579:        static char buf[MAXPATHLEN];
        !           580:        static FILE *ftemp = NULL;
        !           581:        static char **args;
        !           582:        int oldverbose, oldhash;
        !           583:        char *cp, *mode;
        !           584: 
        !           585:        if (!mflag) {
        !           586:                if (!doglob) {
        !           587:                        args = NULL;
        !           588:                }
        !           589:                else {
        !           590:                        if (ftemp) {
        !           591:                                (void) fclose(ftemp);
        !           592:                                ftemp = NULL;
        !           593:                        }
        !           594:                }
        !           595:                return(NULL);
        !           596:        }
        !           597:        if (!doglob) {
        !           598:                if (args == NULL)
        !           599:                        args = argv;
        !           600:                if ((cp = *++args) == NULL)
        !           601:                        args = NULL;
        !           602:                return (cp);
        !           603:        }
        !           604:        if (ftemp == NULL) {
        !           605:                (void) strcpy(temp, "/tmp/ftpXXXXXX");
        !           606:                (void) mktemp(temp);
        !           607:                oldverbose = verbose, verbose = 0;
        !           608:                oldhash = hash, hash = 0;
        !           609:                if (doswitch) {
        !           610:                        pswitch(!proxy);
        !           611:                }
        !           612:                for (mode = "w"; *++argv != NULL; mode = "a")
        !           613:                        recvrequest ("NLST", temp, *argv, mode);
        !           614:                if (doswitch) {
        !           615:                        pswitch(!proxy);
        !           616:                }
        !           617:                verbose = oldverbose; hash = oldhash;
        !           618:                ftemp = fopen(temp, "r");
        !           619:                (void) unlink(temp);
        !           620:                if (ftemp == NULL) {
        !           621:                        printf("can't find list of remote files, oops\n");
        !           622:                        return (NULL);
        !           623:                }
        !           624:        }
        !           625:        if (fgets(buf, sizeof (buf), ftemp) == NULL) {
        !           626:                (void) fclose(ftemp), ftemp = NULL;
        !           627:                return (NULL);
        !           628:        }
        !           629:        if ((cp = index(buf, '\n')) != NULL)
        !           630:                *cp = '\0';
        !           631:        return (buf);
        !           632: }
        !           633: 
        !           634: char *
        !           635: onoff(bool)
        !           636:        int bool;
        !           637: {
        !           638: 
        !           639:        return (bool ? "on" : "off");
        !           640: }
        !           641: 
        !           642: /*
        !           643:  * Show status.
        !           644:  */
        !           645: /*ARGSUSED*/
        !           646: status(argc, argv)
        !           647:        char *argv[];
        !           648: {
        !           649:        int i;
        !           650: 
        !           651:        if (connected)
        !           652:                printf("Connected to %s.\n", hostname);
        !           653:        else
        !           654:                printf("Not connected.\n");
        !           655:        if (!proxy) {
        !           656:                pswitch(1);
        !           657:                if (connected) {
        !           658:                        printf("Connected for proxy commands to %s.\n", hostname);
        !           659:                }
        !           660:                else {
        !           661:                        printf("No proxy connection.\n");
        !           662:                }
        !           663:                pswitch(0);
        !           664:        }
        !           665:        printf("Mode: %s; Type: %s; Form: %s; Structure: %s\n",
        !           666:                modename, typename, formname, structname);
        !           667:        printf("Verbose: %s; Bell: %s; Prompting: %s; Globbing: %s\n", 
        !           668:                onoff(verbose), onoff(bell), onoff(interactive),
        !           669:                onoff(doglob));
        !           670:        printf("Store unique: %s; Receive unique: %s\n", onoff(sunique),
        !           671:                onoff(runique));
        !           672:        printf("Case: %s; CR stripping: %s\n",onoff(mcase),onoff(crflag));
        !           673:        if (ntflag) {
        !           674:                printf("Ntrans: (in) %s (out) %s\n", ntin,ntout);
        !           675:        }
        !           676:        else {
        !           677:                printf("Ntrans: off\n");
        !           678:        }
        !           679:        if (mapflag) {
        !           680:                printf("Nmap: (in) %s (out) %s\n", mapin, mapout);
        !           681:        }
        !           682:        else {
        !           683:                printf("Nmap: off\n");
        !           684:        }
        !           685:        printf("Hash mark printing: %s; Use of PORT cmds: %s\n",
        !           686:                onoff(hash), onoff(sendport));
        !           687:        if (macnum > 0) {
        !           688:                printf("Macros:\n");
        !           689:                for (i=0; i<macnum; i++) {
        !           690:                        printf("\t%s\n",macros[i].mac_name);
        !           691:                }
        !           692:        }
        !           693:        code = 0;
        !           694: }
        !           695: 
        !           696: /*
        !           697:  * Set beep on cmd completed mode.
        !           698:  */
        !           699: /*VARARGS*/
        !           700: setbell()
        !           701: {
        !           702: 
        !           703:        bell = !bell;
        !           704:        printf("Bell mode %s.\n", onoff(bell));
        !           705:        code = bell;
        !           706: }
        !           707: 
        !           708: /*
        !           709:  * Turn on packet tracing.
        !           710:  */
        !           711: /*VARARGS*/
        !           712: settrace()
        !           713: {
        !           714: 
        !           715:        trace = !trace;
        !           716:        printf("Packet tracing %s.\n", onoff(trace));
        !           717:        code = trace;
        !           718: }
        !           719: 
        !           720: /*
        !           721:  * Toggle hash mark printing during transfers.
        !           722:  */
        !           723: /*VARARGS*/
        !           724: sethash()
        !           725: {
        !           726: 
        !           727:        hash = !hash;
        !           728:        printf("Hash mark printing %s", onoff(hash));
        !           729:        code = hash;
        !           730:        if (hash)
        !           731:                printf(" (%d bytes/hash mark)", BUFSIZ);
        !           732:        printf(".\n");
        !           733: }
        !           734: 
        !           735: /*
        !           736:  * Turn on printing of server echo's.
        !           737:  */
        !           738: /*VARARGS*/
        !           739: setverbose()
        !           740: {
        !           741: 
        !           742:        verbose = !verbose;
        !           743:        printf("Verbose mode %s.\n", onoff(verbose));
        !           744:        code = verbose;
        !           745: }
        !           746: 
        !           747: /*
        !           748:  * Toggle PORT cmd use before each data connection.
        !           749:  */
        !           750: /*VARARGS*/
        !           751: setport()
        !           752: {
        !           753: 
        !           754:        sendport = !sendport;
        !           755:        printf("Use of PORT cmds %s.\n", onoff(sendport));
        !           756:        code = sendport;
        !           757: }
        !           758: 
        !           759: /*
        !           760:  * Turn on interactive prompting
        !           761:  * during mget, mput, and mdelete.
        !           762:  */
        !           763: /*VARARGS*/
        !           764: setprompt()
        !           765: {
        !           766: 
        !           767:        interactive = !interactive;
        !           768:        printf("Interactive mode %s.\n", onoff(interactive));
        !           769:        code = interactive;
        !           770: }
        !           771: 
        !           772: /*
        !           773:  * Toggle metacharacter interpretation
        !           774:  * on local file names.
        !           775:  */
        !           776: /*VARARGS*/
        !           777: setglob()
        !           778: {
        !           779:        
        !           780:        doglob = !doglob;
        !           781:        printf("Globbing %s.\n", onoff(doglob));
        !           782:        code = doglob;
        !           783: }
        !           784: 
        !           785: /*
        !           786:  * Set debugging mode on/off and/or
        !           787:  * set level of debugging.
        !           788:  */
        !           789: /*VARARGS*/
        !           790: setdebug(argc, argv)
        !           791:        char *argv[];
        !           792: {
        !           793:        int val;
        !           794: 
        !           795:        if (argc > 1) {
        !           796:                val = atoi(argv[1]);
        !           797:                if (val < 0) {
        !           798:                        printf("%s: bad debugging value.\n", argv[1]);
        !           799:                        code = -1;
        !           800:                        return;
        !           801:                }
        !           802:        } else
        !           803:                val = !debug;
        !           804:        debug = val;
        !           805:        if (debug)
        !           806:                options |= SO_DEBUG;
        !           807:        else
        !           808:                options &= ~SO_DEBUG;
        !           809:        printf("Debugging %s (debug=%d).\n", onoff(debug), debug);
        !           810:        code = debug > 0;
        !           811: }
        !           812: 
        !           813: /*
        !           814:  * Set current working directory
        !           815:  * on remote machine.
        !           816:  */
        !           817: cd(argc, argv)
        !           818:        char *argv[];
        !           819: {
        !           820: 
        !           821:        if (argc < 2) {
        !           822:                (void) strcat(line, " ");
        !           823:                printf("(remote-directory) ");
        !           824:                (void) gets(&line[strlen(line)]);
        !           825:                makeargv();
        !           826:                argc = margc;
        !           827:                argv = margv;
        !           828:        }
        !           829:        if (argc < 2) {
        !           830:                printf("usage:%s remote-directory\n", argv[0]);
        !           831:                code = -1;
        !           832:                return;
        !           833:        }
        !           834:        (void) command("CWD %s", argv[1]);
        !           835: }
        !           836: 
        !           837: /*
        !           838:  * Set current working directory
        !           839:  * on local machine.
        !           840:  */
        !           841: lcd(argc, argv)
        !           842:        char *argv[];
        !           843: {
        !           844:        char buf[MAXPATHLEN];
        !           845: 
        !           846:        if (argc < 2)
        !           847:                argc++, argv[1] = home;
        !           848:        if (argc != 2) {
        !           849:                printf("usage:%s local-directory\n", argv[0]);
        !           850:                code = -1;
        !           851:                return;
        !           852:        }
        !           853:        if (!globulize(&argv[1])) {
        !           854:                code = -1;
        !           855:                return;
        !           856:        }
        !           857:        if (chdir(argv[1]) < 0) {
        !           858:                perror(argv[1]);
        !           859:                code = -1;
        !           860:                return;
        !           861:        }
        !           862:        printf("Local directory now %s\n", getwd(buf));
        !           863:        code = 0;
        !           864: }
        !           865: 
        !           866: /*
        !           867:  * Delete a single file.
        !           868:  */
        !           869: delete(argc, argv)
        !           870:        char *argv[];
        !           871: {
        !           872: 
        !           873:        if (argc < 2) {
        !           874:                (void) strcat(line, " ");
        !           875:                printf("(remote-file) ");
        !           876:                (void) gets(&line[strlen(line)]);
        !           877:                makeargv();
        !           878:                argc = margc;
        !           879:                argv = margv;
        !           880:        }
        !           881:        if (argc < 2) {
        !           882:                printf("usage:%s remote-file\n", argv[0]);
        !           883:                code = -1;
        !           884:                return;
        !           885:        }
        !           886:        (void) command("DELE %s", argv[1]);
        !           887: }
        !           888: 
        !           889: /*
        !           890:  * Delete multiple files.
        !           891:  */
        !           892: mdelete(argc, argv)
        !           893:        char *argv[];
        !           894: {
        !           895:        char *cp;
        !           896:        int ointer, (*oldintr)(), mabort();
        !           897:        extern jmp_buf jabort;
        !           898: 
        !           899:        if (argc < 2) {
        !           900:                (void) strcat(line, " ");
        !           901:                printf("(remote-files) ");
        !           902:                (void) gets(&line[strlen(line)]);
        !           903:                makeargv();
        !           904:                argc = margc;
        !           905:                argv = margv;
        !           906:        }
        !           907:        if (argc < 2) {
        !           908:                printf("usage:%s remote-files\n", argv[0]);
        !           909:                code = -1;
        !           910:                return;
        !           911:        }
        !           912:        mname = argv[0];
        !           913:        mflag = 1;
        !           914:        oldintr = signal(SIGINT, mabort);
        !           915:        (void) setjmp(jabort);
        !           916:        while ((cp = remglob(argv,0)) != NULL) {
        !           917:                if (*cp == '\0') {
        !           918:                        mflag = 0;
        !           919:                        continue;
        !           920:                }
        !           921:                if (mflag && confirm(argv[0], cp)) {
        !           922:                        (void) command("DELE %s", cp);
        !           923:                        if (!mflag && fromatty) {
        !           924:                                ointer = interactive;
        !           925:                                interactive = 1;
        !           926:                                if (confirm("Continue with", "mdelete")) {
        !           927:                                        mflag++;
        !           928:                                }
        !           929:                                interactive = ointer;
        !           930:                        }
        !           931:                }
        !           932:        }
        !           933:        (void) signal(SIGINT, oldintr);
        !           934:        mflag = 0;
        !           935: }
        !           936: 
        !           937: /*
        !           938:  * Rename a remote file.
        !           939:  */
        !           940: renamefile(argc, argv)
        !           941:        char *argv[];
        !           942: {
        !           943: 
        !           944:        if (argc < 2) {
        !           945:                (void) strcat(line, " ");
        !           946:                printf("(from-name) ");
        !           947:                (void) gets(&line[strlen(line)]);
        !           948:                makeargv();
        !           949:                argc = margc;
        !           950:                argv = margv;
        !           951:        }
        !           952:        if (argc < 2) {
        !           953: usage:
        !           954:                printf("%s from-name to-name\n", argv[0]);
        !           955:                code = -1;
        !           956:                return;
        !           957:        }
        !           958:        if (argc < 3) {
        !           959:                (void) strcat(line, " ");
        !           960:                printf("(to-name) ");
        !           961:                (void) gets(&line[strlen(line)]);
        !           962:                makeargv();
        !           963:                argc = margc;
        !           964:                argv = margv;
        !           965:        }
        !           966:        if (argc < 3) 
        !           967:                goto usage;
        !           968:        if (command("RNFR %s", argv[1]) == CONTINUE)
        !           969:                (void) command("RNTO %s", argv[2]);
        !           970: }
        !           971: 
        !           972: /*
        !           973:  * Get a directory listing
        !           974:  * of remote files.
        !           975:  */
        !           976: ls(argc, argv)
        !           977:        char *argv[];
        !           978: {
        !           979:        char *cmd;
        !           980: 
        !           981:        if (argc < 2)
        !           982:                argc++, argv[1] = NULL;
        !           983:        if (argc < 3)
        !           984:                argc++, argv[2] = "-";
        !           985:        if (argc > 3) {
        !           986:                printf("usage: %s remote-directory local-file\n", argv[0]);
        !           987:                code = -1;
        !           988:                return;
        !           989:        }
        !           990:        cmd = argv[0][0] == 'l' ? "NLST" : "LIST";
        !           991:        if (strcmp(argv[2], "-") && !globulize(&argv[2])) {
        !           992:                code = -1;
        !           993:                return;
        !           994:        }
        !           995:        recvrequest(cmd, argv[2], argv[1], "w");
        !           996: }
        !           997: 
        !           998: /*
        !           999:  * Get a directory listing
        !          1000:  * of multiple remote files.
        !          1001:  */
        !          1002: mls(argc, argv)
        !          1003:        char *argv[];
        !          1004: {
        !          1005:        char *cmd, mode[1], *dest;
        !          1006:        int ointer, i, (*oldintr)(), mabort();
        !          1007:        extern jmp_buf jabort;
        !          1008: 
        !          1009:        if (argc < 2) {
        !          1010:                (void) strcat(line, " ");
        !          1011:                printf("(remote-files) ");
        !          1012:                (void) gets(&line[strlen(line)]);
        !          1013:                makeargv();
        !          1014:                argc = margc;
        !          1015:                argv = margv;
        !          1016:        }
        !          1017:        if (argc < 3) {
        !          1018:                (void) strcat(line, " ");
        !          1019:                printf("(local-file) ");
        !          1020:                (void) gets(&line[strlen(line)]);
        !          1021:                makeargv();
        !          1022:                argc = margc;
        !          1023:                argv = margv;
        !          1024:        }
        !          1025:        if (argc < 3) {
        !          1026:                printf("usage:%s remote-files local-file\n", argv[0]);
        !          1027:                code = -1;
        !          1028:                return;
        !          1029:        }
        !          1030:        dest = argv[argc - 1];
        !          1031:        argv[argc - 1] = NULL;
        !          1032:        if (strcmp(dest, "-") && *dest != '|')
        !          1033:                if (!globulize(&dest) || !confirm("output to local-file:", dest)) {
        !          1034:                        code = -1;
        !          1035:                        return;
        !          1036:        }
        !          1037:        cmd = argv[0][1] == 'l' ? "NLST" : "LIST";
        !          1038:        mname = argv[0];
        !          1039:        mflag = 1;
        !          1040:        oldintr = signal(SIGINT, mabort);
        !          1041:        (void) setjmp(jabort);
        !          1042:        for (i = 1; mflag && i < argc-1; ++i) {
        !          1043:                *mode = (i == 1) ? 'w' : 'a';
        !          1044:                recvrequest(cmd, dest, argv[i], mode);
        !          1045:                if (!mflag && fromatty) {
        !          1046:                        ointer = interactive;
        !          1047:                        interactive = 1;
        !          1048:                        if (confirm("Continue with", argv[0])) {
        !          1049:                                mflag ++;
        !          1050:                        }
        !          1051:                        interactive = ointer;
        !          1052:                }
        !          1053:        }
        !          1054:        (void) signal(SIGINT, oldintr);
        !          1055:        mflag = 0;
        !          1056: }
        !          1057: 
        !          1058: /*
        !          1059:  * Do a shell escape
        !          1060:  */
        !          1061: /*ARGSUSED*/
        !          1062: shell(argc, argv)
        !          1063:        char *argv[];
        !          1064: {
        !          1065:        int pid, (*old1)(), (*old2)();
        !          1066:        char shellnam[40], *shell, *namep; 
        !          1067:        union wait status;
        !          1068: 
        !          1069:        old1 = signal (SIGINT, SIG_IGN);
        !          1070:        old2 = signal (SIGQUIT, SIG_IGN);
        !          1071:        if ((pid = fork()) == 0) {
        !          1072:                for (pid = 3; pid < 20; pid++)
        !          1073:                        (void) close(pid);
        !          1074:                (void) signal(SIGINT, SIG_DFL);
        !          1075:                (void) signal(SIGQUIT, SIG_DFL);
        !          1076:                shell = getenv("SHELL");
        !          1077:                if (shell == NULL)
        !          1078:                        shell = "/bin/sh";
        !          1079:                namep = rindex(shell,'/');
        !          1080:                if (namep == NULL)
        !          1081:                        namep = shell;
        !          1082:                (void) strcpy(shellnam,"-");
        !          1083:                (void) strcat(shellnam, ++namep);
        !          1084:                if (strcmp(namep, "sh") != 0)
        !          1085:                        shellnam[0] = '+';
        !          1086:                if (debug) {
        !          1087:                        printf ("%s\n", shell);
        !          1088:                        (void) fflush (stdout);
        !          1089:                }
        !          1090:                if (argc > 1) {
        !          1091:                        execl(shell,shellnam,"-c",altarg,(char *)0);
        !          1092:                }
        !          1093:                else {
        !          1094:                        execl(shell,shellnam,(char *)0);
        !          1095:                }
        !          1096:                perror(shell);
        !          1097:                code = -1;
        !          1098:                exit(1);
        !          1099:                }
        !          1100:        if (pid > 0)
        !          1101:                while (wait(&status) != pid)
        !          1102:                        ;
        !          1103:        (void) signal(SIGINT, old1);
        !          1104:        (void) signal(SIGQUIT, old2);
        !          1105:        if (pid == -1) {
        !          1106:                perror("Try again later");
        !          1107:                code = -1;
        !          1108:        }
        !          1109:        else {
        !          1110:                code = 0;
        !          1111:        }
        !          1112:        return (0);
        !          1113: }
        !          1114: 
        !          1115: /*
        !          1116:  * Send new user information (re-login)
        !          1117:  */
        !          1118: user(argc, argv)
        !          1119:        int argc;
        !          1120:        char **argv;
        !          1121: {
        !          1122:        char acct[80], *mygetpass();
        !          1123:        int n, aflag = 0;
        !          1124: 
        !          1125:        if (argc < 2) {
        !          1126:                (void) strcat(line, " ");
        !          1127:                printf("(username) ");
        !          1128:                (void) gets(&line[strlen(line)]);
        !          1129:                makeargv();
        !          1130:                argc = margc;
        !          1131:                argv = margv;
        !          1132:        }
        !          1133:        if (argc > 4) {
        !          1134:                printf("usage: %s username [password] [account]\n", argv[0]);
        !          1135:                code = -1;
        !          1136:                return (0);
        !          1137:        }
        !          1138:        n = command("USER %s", argv[1]);
        !          1139:        if (n == CONTINUE) {
        !          1140:                if (argc < 3 )
        !          1141:                        argv[2] = mygetpass("Password: "), argc++;
        !          1142:                n = command("PASS %s", argv[2]);
        !          1143:        }
        !          1144:        if (n == CONTINUE) {
        !          1145:                if (argc < 4) {
        !          1146:                        printf("Account: "); (void) fflush(stdout);
        !          1147:                        (void) fgets(acct, sizeof(acct) - 1, stdin);
        !          1148:                        acct[strlen(acct) - 1] = '\0';
        !          1149:                        argv[3] = acct; argc++;
        !          1150:                }
        !          1151:                n = command("ACCT %s", argv[3]);
        !          1152:                aflag++;
        !          1153:        }
        !          1154:        if (n != COMPLETE) {
        !          1155:                fprintf(stdout, "Login failed.\n");
        !          1156:                return (0);
        !          1157:        }
        !          1158:        if (!aflag && argc == 4) {
        !          1159:                (void) command("ACCT %s", argv[3]);
        !          1160:        }
        !          1161:        return (1);
        !          1162: }
        !          1163: 
        !          1164: /*
        !          1165:  * Print working directory.
        !          1166:  */
        !          1167: /*VARARGS*/
        !          1168: pwd()
        !          1169: {
        !          1170: 
        !          1171:        (void) command("PWD");
        !          1172: }
        !          1173: 
        !          1174: /*
        !          1175:  * Make a directory.
        !          1176:  */
        !          1177: makedir(argc, argv)
        !          1178:        char *argv[];
        !          1179: {
        !          1180: 
        !          1181:        if (argc < 2) {
        !          1182:                (void) strcat(line, " ");
        !          1183:                printf("(directory-name) ");
        !          1184:                (void) gets(&line[strlen(line)]);
        !          1185:                makeargv();
        !          1186:                argc = margc;
        !          1187:                argv = margv;
        !          1188:        }
        !          1189:        if (argc < 2) {
        !          1190:                printf("usage: %s directory-name\n", argv[0]);
        !          1191:                code = -1;
        !          1192:                return;
        !          1193:        }
        !          1194:        (void) command("MKD %s", argv[1]);
        !          1195: }
        !          1196: 
        !          1197: /*
        !          1198:  * Remove a directory.
        !          1199:  */
        !          1200: removedir(argc, argv)
        !          1201:        char *argv[];
        !          1202: {
        !          1203: 
        !          1204:        if (argc < 2) {
        !          1205:                (void) strcat(line, " ");
        !          1206:                printf("(directory-name) ");
        !          1207:                (void) gets(&line[strlen(line)]);
        !          1208:                makeargv();
        !          1209:                argc = margc;
        !          1210:                argv = margv;
        !          1211:        }
        !          1212:        if (argc < 2) {
        !          1213:                printf("usage: %s directory-name\n", argv[0]);
        !          1214:                code = -1;
        !          1215:                return;
        !          1216:        }
        !          1217:        (void) command("RMD %s", argv[1]);
        !          1218: }
        !          1219: 
        !          1220: /*
        !          1221:  * Send a line, verbatim, to the remote machine.
        !          1222:  */
        !          1223: quote(argc, argv)
        !          1224:        char *argv[];
        !          1225: {
        !          1226:        int i;
        !          1227:        char buf[BUFSIZ];
        !          1228: 
        !          1229:        if (argc < 2) {
        !          1230:                (void) strcat(line, " ");
        !          1231:                printf("(command line to send) ");
        !          1232:                (void) gets(&line[strlen(line)]);
        !          1233:                makeargv();
        !          1234:                argc = margc;
        !          1235:                argv = margv;
        !          1236:        }
        !          1237:        if (argc < 2) {
        !          1238:                printf("usage: %s line-to-send\n", argv[0]);
        !          1239:                code = -1;
        !          1240:                return;
        !          1241:        }
        !          1242:        (void) strcpy(buf, argv[1]);
        !          1243:        for (i = 2; i < argc; i++) {
        !          1244:                (void) strcat(buf, " ");
        !          1245:                (void) strcat(buf, argv[i]);
        !          1246:        }
        !          1247:        if (command(buf) == PRELIM) {
        !          1248:                while (getreply(0) == PRELIM);
        !          1249:        }
        !          1250: }
        !          1251: 
        !          1252: /*
        !          1253:  * Ask the other side for help.
        !          1254:  */
        !          1255: rmthelp(argc, argv)
        !          1256:        char *argv[];
        !          1257: {
        !          1258:        int oldverbose = verbose;
        !          1259: 
        !          1260:        verbose = 1;
        !          1261:        (void) command(argc == 1 ? "HELP" : "HELP %s", argv[1]);
        !          1262:        verbose = oldverbose;
        !          1263: }
        !          1264: 
        !          1265: /*
        !          1266:  * Terminate session and exit.
        !          1267:  */
        !          1268: /*VARARGS*/
        !          1269: quit()
        !          1270: {
        !          1271: 
        !          1272:        if (connected)
        !          1273:                disconnect();
        !          1274:        pswitch(1);
        !          1275:        if (connected) {
        !          1276:                disconnect();
        !          1277:        }
        !          1278:        exit(0);
        !          1279: }
        !          1280: 
        !          1281: /*
        !          1282:  * Terminate session, but don't exit.
        !          1283:  */
        !          1284: disconnect()
        !          1285: {
        !          1286:        extern FILE *cout;
        !          1287:        extern int data;
        !          1288: 
        !          1289:        if (!connected)
        !          1290:                return;
        !          1291:        (void) command("QUIT");
        !          1292:        if (cout) {
        !          1293:                (void) fclose(cout);
        !          1294:        }
        !          1295:        cout = NULL;
        !          1296:        connected = 0;
        !          1297:        data = -1;
        !          1298:        if (!proxy) {
        !          1299:                macnum = 0;
        !          1300:        }
        !          1301: }
        !          1302: 
        !          1303: confirm(cmd, file)
        !          1304:        char *cmd, *file;
        !          1305: {
        !          1306:        char line[BUFSIZ];
        !          1307: 
        !          1308:        if (!interactive)
        !          1309:                return (1);
        !          1310:        printf("%s %s? ", cmd, file);
        !          1311:        (void) fflush(stdout);
        !          1312:        (void) gets(line);
        !          1313:        return (*line != 'n' && *line != 'N');
        !          1314: }
        !          1315: 
        !          1316: fatal(msg)
        !          1317:        char *msg;
        !          1318: {
        !          1319: 
        !          1320:        fprintf(stderr, "ftp: %s\n", msg);
        !          1321:        exit(1);
        !          1322: }
        !          1323: 
        !          1324: /*
        !          1325:  * Glob a local file name specification with
        !          1326:  * the expectation of a single return value.
        !          1327:  * Can't control multiple values being expanded
        !          1328:  * from the expression, we return only the first.
        !          1329:  */
        !          1330: globulize(cpp)
        !          1331:        char **cpp;
        !          1332: {
        !          1333:        char **globbed;
        !          1334: 
        !          1335:        if (!doglob)
        !          1336:                return (1);
        !          1337:        globbed = glob(*cpp);
        !          1338:        if (globerr != NULL) {
        !          1339:                printf("%s: %s\n", *cpp, globerr);
        !          1340:                if (globbed)
        !          1341:                        blkfree(globbed);
        !          1342:                return (0);
        !          1343:        }
        !          1344:        if (globbed) {
        !          1345:                *cpp = *globbed++;
        !          1346:                /* don't waste too much memory */
        !          1347:                if (*globbed)
        !          1348:                        blkfree(globbed);
        !          1349:        }
        !          1350:        return (1);
        !          1351: }
        !          1352: 
        !          1353: account(argc,argv)
        !          1354: 
        !          1355:        int argc;
        !          1356:        char **argv;
        !          1357: {
        !          1358:        char acct[50], *mygetpass(), *ap;
        !          1359: 
        !          1360:        if (argc > 1) {
        !          1361:                ++argv;
        !          1362:                --argc;
        !          1363:                (void) strncpy(acct,*argv,49);
        !          1364:                acct[50] = '\0';
        !          1365:                while (argc > 1) {
        !          1366:                        --argc;
        !          1367:                        ++argv;
        !          1368:                        (void) strncat(acct,*argv, 49-strlen(acct));
        !          1369:                }
        !          1370:                ap = acct;
        !          1371:        }
        !          1372:        else {
        !          1373:                ap = mygetpass("Account:");
        !          1374:        }
        !          1375:        (void) command("ACCT %s", ap);
        !          1376: }
        !          1377: 
        !          1378: jmp_buf abortprox;
        !          1379: 
        !          1380: proxabort()
        !          1381: {
        !          1382:        extern int proxy;
        !          1383: 
        !          1384:        if (!proxy) {
        !          1385:                pswitch(1);
        !          1386:        }
        !          1387:        if (connected) {
        !          1388:                proxflag = 1;
        !          1389:        }
        !          1390:        else {
        !          1391:                proxflag = 0;
        !          1392:        }
        !          1393:        pswitch(0);
        !          1394:        longjmp(abortprox,1);
        !          1395: }
        !          1396: 
        !          1397: doproxy(argc,argv)
        !          1398:        int argc;
        !          1399:        char *argv[];
        !          1400: {
        !          1401:        int (*oldintr)(), proxabort();
        !          1402:        register struct cmd *c;
        !          1403:        struct cmd *getcmd();
        !          1404:        extern struct cmd cmdtab[];
        !          1405:        extern jmp_buf abortprox;
        !          1406: 
        !          1407:        if (argc < 2) {
        !          1408:                (void) strcat(line, " ");
        !          1409:                printf("(command) ");
        !          1410:                (void) gets(&line[strlen(line)]);
        !          1411:                makeargv();
        !          1412:                argc = margc;
        !          1413:                argv = margv;
        !          1414:        }
        !          1415:        if (argc < 2) {
        !          1416:                printf("usage:%s command\n", argv[0]);
        !          1417:                code = -1;
        !          1418:                return;
        !          1419:        }
        !          1420:        c = getcmd(argv[1]);
        !          1421:        if (c == (struct cmd *) -1) {
        !          1422:                printf("?Ambiguous command\n");
        !          1423:                (void) fflush(stdout);
        !          1424:                code = -1;
        !          1425:                return;
        !          1426:        }
        !          1427:        if (c == 0) {
        !          1428:                printf("?Invalid command\n");
        !          1429:                (void) fflush(stdout);
        !          1430:                code = -1;
        !          1431:                return;
        !          1432:        }
        !          1433:        if (!c->c_proxy) {
        !          1434:                printf("?Invalid proxy command\n");
        !          1435:                (void) fflush(stdout);
        !          1436:                code = -1;
        !          1437:                return;
        !          1438:        }
        !          1439:        if (setjmp(abortprox)) {
        !          1440:                code = -1;
        !          1441:                return;
        !          1442:        }
        !          1443:        oldintr = signal(SIGINT, proxabort);
        !          1444:        pswitch(1);
        !          1445:        if (c->c_conn && !connected) {
        !          1446:                printf("Not connected\n");
        !          1447:                (void) fflush(stdout);
        !          1448:                pswitch(0);
        !          1449:                (void) signal(SIGINT, oldintr);
        !          1450:                code = -1;
        !          1451:                return;
        !          1452:        }
        !          1453:        (*c->c_handler)(argc-1, argv+1);
        !          1454:        if (connected) {
        !          1455:                proxflag = 1;
        !          1456:        }
        !          1457:        else {
        !          1458:                proxflag = 0;
        !          1459:        }
        !          1460:        pswitch(0);
        !          1461:        (void) signal(SIGINT, oldintr);
        !          1462: }
        !          1463: 
        !          1464: setcase()
        !          1465: {
        !          1466:        mcase = !mcase;
        !          1467:        printf("Case mapping %s.\n", onoff(mcase));
        !          1468:        code = mcase;
        !          1469: }
        !          1470: 
        !          1471: setcr()
        !          1472: {
        !          1473:        crflag = !crflag;
        !          1474:        printf("Carriage Return stripping %s.\n", onoff(crflag));
        !          1475:        code = crflag;
        !          1476: }
        !          1477: 
        !          1478: setntrans(argc,argv)
        !          1479:        int argc;
        !          1480:        char *argv[];
        !          1481: {
        !          1482:        if (argc == 1) {
        !          1483:                ntflag = 0;
        !          1484:                printf("Ntrans off.\n");
        !          1485:                code = ntflag;
        !          1486:                return;
        !          1487:        }
        !          1488:        ntflag++;
        !          1489:        code = ntflag;
        !          1490:        (void) strncpy(ntin, argv[1], 16);
        !          1491:        ntin[16] = '\0';
        !          1492:        if (argc == 2) {
        !          1493:                ntout[0] = '\0';
        !          1494:                return;
        !          1495:        }
        !          1496:        (void) strncpy(ntout, argv[2], 16);
        !          1497:        ntout[16] = '\0';
        !          1498: }
        !          1499: 
        !          1500: char *
        !          1501: dotrans(name)
        !          1502:        char *name;
        !          1503: {
        !          1504:        static char new[MAXPATHLEN];
        !          1505:        char *cp1, *cp2 = new;
        !          1506:        register int i, ostop, found;
        !          1507: 
        !          1508:        for (ostop = 0; *(ntout + ostop) && ostop < 16; ostop++);
        !          1509:        for (cp1 = name; *cp1; cp1++) {
        !          1510:                found = 0;
        !          1511:                for (i = 0; *(ntin + i) && i < 16; i++) {
        !          1512:                        if (*cp1 == *(ntin + i)) {
        !          1513:                                found++;
        !          1514:                                if (i < ostop) {
        !          1515:                                        *cp2++ = *(ntout + i);
        !          1516:                                }
        !          1517:                                break;
        !          1518:                        }
        !          1519:                }
        !          1520:                if (!found) {
        !          1521:                        *cp2++ = *cp1;
        !          1522:                }
        !          1523:        }
        !          1524:        *cp2 = '\0';
        !          1525:        return(new);
        !          1526: }
        !          1527: 
        !          1528: setnmap(argc, argv)
        !          1529:        int argc;
        !          1530:        char *argv[];
        !          1531: {
        !          1532:        char *cp;
        !          1533: 
        !          1534:        if (argc == 1) {
        !          1535:                mapflag = 0;
        !          1536:                printf("Nmap off.\n");
        !          1537:                code = mapflag;
        !          1538:                return;
        !          1539:        }
        !          1540:        if (argc < 3) {
        !          1541:                (void) strcat(line, " ");
        !          1542:                printf("(mapout) ");
        !          1543:                (void) gets(&line[strlen(line)]);
        !          1544:                makeargv();
        !          1545:                argc = margc;
        !          1546:                argv = margv;
        !          1547:        }
        !          1548:        if (argc < 3) {
        !          1549:                printf("Usage: %s [mapin mapout]\n",argv[0]);
        !          1550:                code = -1;
        !          1551:                return;
        !          1552:        }
        !          1553:        mapflag = 1;
        !          1554:        code = 1;
        !          1555:        cp = index(altarg, ' ');
        !          1556:        if (proxy) {
        !          1557:                while(*++cp == ' ');
        !          1558:                altarg = cp;
        !          1559:                cp = index(altarg, ' ');
        !          1560:        }
        !          1561:        *cp = '\0';
        !          1562:        (void) strncpy(mapin, altarg, MAXPATHLEN - 1);
        !          1563:        while (*++cp == ' ');
        !          1564:        (void) strncpy(mapout, cp, MAXPATHLEN - 1);
        !          1565: }
        !          1566: 
        !          1567: char *
        !          1568: domap(name)
        !          1569:        char *name;
        !          1570: {
        !          1571:        static char new[MAXPATHLEN];
        !          1572:        register char *cp1 = name, *cp2 = mapin;
        !          1573:        char *tp[9], *te[9];
        !          1574:        int i, toks[9], toknum, match = 1;
        !          1575: 
        !          1576:        for (i=0; i < 9; ++i) {
        !          1577:                toks[i] = 0;
        !          1578:        }
        !          1579:        while (match && *cp1 && *cp2) {
        !          1580:                switch (*cp2) {
        !          1581:                        case '\\':
        !          1582:                                if (*++cp2 != *cp1) {
        !          1583:                                        match = 0;
        !          1584:                                }
        !          1585:                                break;
        !          1586:                        case '$':
        !          1587:                                if (*(cp2+1) >= '1' && (*cp2+1) <= '9') {
        !          1588:                                        if (*cp1 != *(++cp2+1)) {
        !          1589:                                                toks[toknum = *cp2 - '1']++;
        !          1590:                                                tp[toknum] = cp1;
        !          1591:                                                while (*++cp1 && *(cp2+1)
        !          1592:                                                        != *cp1);
        !          1593:                                                te[toknum] = cp1;
        !          1594:                                        }
        !          1595:                                        cp2++;
        !          1596:                                        break;
        !          1597:                                }
        !          1598:                                /* intentional drop through */
        !          1599:                        default:
        !          1600:                                if (*cp2 != *cp1) {
        !          1601:                                        match = 0;
        !          1602:                                }
        !          1603:                                break;
        !          1604:                }
        !          1605:                if (*cp1) {
        !          1606:                        cp1++;
        !          1607:                }
        !          1608:                if (*cp2) {
        !          1609:                        cp2++;
        !          1610:                }
        !          1611:        }
        !          1612:        cp1 = new;
        !          1613:        *cp1 = '\0';
        !          1614:        cp2 = mapout;
        !          1615:        while (*cp2) {
        !          1616:                match = 0;
        !          1617:                switch (*cp2) {
        !          1618:                        case '\\':
        !          1619:                                if (*(cp2 + 1)) {
        !          1620:                                        *cp1++ = *++cp2;
        !          1621:                                }
        !          1622:                                break;
        !          1623:                        case '[':
        !          1624: LOOP:
        !          1625:                                if (*++cp2 == '$' && isdigit(*(cp2+1))) { 
        !          1626:                                        if (*++cp2 == '0') {
        !          1627:                                                char *cp3 = name;
        !          1628: 
        !          1629:                                                while (*cp3) {
        !          1630:                                                        *cp1++ = *cp3++;
        !          1631:                                                }
        !          1632:                                                match = 1;
        !          1633:                                        }
        !          1634:                                        else if (toks[toknum = *cp2 - '1']) {
        !          1635:                                                char *cp3 = tp[toknum];
        !          1636: 
        !          1637:                                                while (cp3 != te[toknum]) {
        !          1638:                                                        *cp1++ = *cp3++;
        !          1639:                                                }
        !          1640:                                                match = 1;
        !          1641:                                        }
        !          1642:                                }
        !          1643:                                else {
        !          1644:                                        while (*cp2 && *cp2 != ',' && 
        !          1645:                                            *cp2 != ']') {
        !          1646:                                                if (*cp2 == '\\') {
        !          1647:                                                        cp2++;
        !          1648:                                                }
        !          1649:                                                else if (*cp2 == '$' &&
        !          1650:                                                        isdigit(*(cp2+1))) {
        !          1651:                                                        if (*++cp2 == '0') {
        !          1652:                                                           char *cp3 = name;
        !          1653: 
        !          1654:                                                           while (*cp3) {
        !          1655:                                                                *cp1++ = *cp3++;
        !          1656:                                                           }
        !          1657:                                                        }
        !          1658:                                                        else if (toks[toknum =
        !          1659:                                                            *cp2 - '1']) {
        !          1660:                                                           char *cp3=tp[toknum];
        !          1661: 
        !          1662:                                                           while (cp3 !=
        !          1663:                                                                  te[toknum]) {
        !          1664:                                                                *cp1++ = *cp3++;
        !          1665:                                                           }
        !          1666:                                                        }
        !          1667:                                                }
        !          1668:                                                else if (*cp2) {
        !          1669:                                                        *cp1++ = *cp2++;
        !          1670:                                                }
        !          1671:                                        }
        !          1672:                                        if (!*cp2) {
        !          1673:                                                printf("nmap: unbalanced brackets\n");
        !          1674:                                                return(name);
        !          1675:                                        }
        !          1676:                                        match = 1;
        !          1677:                                        cp2--;
        !          1678:                                }
        !          1679:                                if (match) {
        !          1680:                                        while (*++cp2 && *cp2 != ']') {
        !          1681:                                              if (*cp2 == '\\' && *(cp2 + 1)) {
        !          1682:                                                        cp2++;
        !          1683:                                              }
        !          1684:                                        }
        !          1685:                                        if (!*cp2) {
        !          1686:                                                printf("nmap: unbalanced brackets\n");
        !          1687:                                                return(name);
        !          1688:                                        }
        !          1689:                                        break;
        !          1690:                                }
        !          1691:                                switch (*++cp2) {
        !          1692:                                        case ',':
        !          1693:                                                goto LOOP;
        !          1694:                                        case ']':
        !          1695:                                                break;
        !          1696:                                        default:
        !          1697:                                                cp2--;
        !          1698:                                                goto LOOP;
        !          1699:                                }
        !          1700:                                break;
        !          1701:                        case '$':
        !          1702:                                if (isdigit(*(cp2 + 1))) {
        !          1703:                                        if (*++cp2 == '0') {
        !          1704:                                                char *cp3 = name;
        !          1705: 
        !          1706:                                                while (*cp3) {
        !          1707:                                                        *cp1++ = *cp3++;
        !          1708:                                                }
        !          1709:                                        }
        !          1710:                                        else if (toks[toknum = *cp2 - '1']) {
        !          1711:                                                char *cp3 = tp[toknum];
        !          1712: 
        !          1713:                                                while (cp3 != te[toknum]) {
        !          1714:                                                        *cp1++ = *cp3++;
        !          1715:                                                }
        !          1716:                                        }
        !          1717:                                        break;
        !          1718:                                }
        !          1719:                                /* intentional drop through */
        !          1720:                        default:
        !          1721:                                *cp1++ = *cp2;
        !          1722:                                break;
        !          1723:                }
        !          1724:                cp2++;
        !          1725:        }
        !          1726:        *cp1 = '\0';
        !          1727:        if (!*new) {
        !          1728:                return(name);
        !          1729:        }
        !          1730:        return(new);
        !          1731: }
        !          1732: 
        !          1733: setsunique()
        !          1734: {
        !          1735:        sunique = !sunique;
        !          1736:        printf("Store unique %s.\n", onoff(sunique));
        !          1737:        code = sunique;
        !          1738: }
        !          1739: 
        !          1740: setrunique()
        !          1741: {
        !          1742:        runique = !runique;
        !          1743:        printf("Receive unique %s.\n", onoff(runique));
        !          1744:        code = runique;
        !          1745: }
        !          1746: 
        !          1747: /* change directory to perent directory */
        !          1748: cdup()
        !          1749: {
        !          1750:        (void) command("CDUP");
        !          1751: }
        !          1752: 
        !          1753: macdef(argc, argv)
        !          1754:        int argc;
        !          1755:        char *argv[];
        !          1756: {
        !          1757:        char *tmp;
        !          1758:        int c;
        !          1759: 
        !          1760:        if (macnum == 16) {
        !          1761:                printf("Limit of 16 macros have already been defined\n");
        !          1762:                code = -1;
        !          1763:                return;
        !          1764:        }
        !          1765:        if (argc < 2) {
        !          1766:                (void) strcat(line, " ");
        !          1767:                printf("(macro name) ");
        !          1768:                (void) gets(&line[strlen(line)]);
        !          1769:                makeargv();
        !          1770:                argc = margc;
        !          1771:                argv = margv;
        !          1772:        }
        !          1773:        if (argc != 2) {
        !          1774:                printf("Usage: %s macro_name\n",argv[0]);
        !          1775:                code = -1;
        !          1776:                return;
        !          1777:        }
        !          1778:        if (interactive) {
        !          1779:                printf("Enter macro line by line, terminating it with a null line\n");
        !          1780:        }
        !          1781:        (void) strncpy(macros[macnum].mac_name, argv[1], 8);
        !          1782:        if (macnum == 0) {
        !          1783:                macros[macnum].mac_start = macbuf;
        !          1784:        }
        !          1785:        else {
        !          1786:                macros[macnum].mac_start = macros[macnum - 1].mac_end + 1;
        !          1787:        }
        !          1788:        tmp = macros[macnum].mac_start;
        !          1789:        while (tmp != macbuf+4096) {
        !          1790:                if ((c = getchar()) == EOF) {
        !          1791:                        printf("macdef:end of file encountered\n");
        !          1792:                        code = -1;
        !          1793:                        return;
        !          1794:                }
        !          1795:                if ((*tmp = c) == '\n') {
        !          1796:                        if (tmp == macros[macnum].mac_start) {
        !          1797:                                macros[macnum++].mac_end = tmp;
        !          1798:                                code = 0;
        !          1799:                                return;
        !          1800:                        }
        !          1801:                        if (*(tmp-1) == '\0') {
        !          1802:                                macros[macnum++].mac_end = tmp - 1;
        !          1803:                                code = 0;
        !          1804:                                return;
        !          1805:                        }
        !          1806:                        *tmp = '\0';
        !          1807:                }
        !          1808:                tmp++;
        !          1809:        }
        !          1810:        while (1) {
        !          1811:                while ((c = getchar()) != '\n' && c != EOF);
        !          1812:                if (c == EOF || getchar() == '\n') {
        !          1813:                        printf("Macro not defined - 4k buffer exceeded\n");
        !          1814:                        code = -1;
        !          1815:                        return;
        !          1816:                }
        !          1817:        }
        !          1818: }

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