Return to ftam.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / ftam2

Annotation of 43BSDReno/contrib/isode-beta/ftam2/ftam.c, revision 1.1

1.1     ! root        1: /* ftam.c - interactive FTAM initiator */
        !             2: 
        !             3: #ifndef        lint
        !             4: static char *rcsid = "$Header: /f/osi/ftam2/RCS/ftam.c,v 7.1 90/07/09 14:37:18 mrose Exp $";
        !             5: #endif
        !             6: 
        !             7: /* 
        !             8:  * $Header: /f/osi/ftam2/RCS/ftam.c,v 7.1 90/07/09 14:37:18 mrose Exp $
        !             9:  *
        !            10:  *
        !            11:  * $Log:       ftam.c,v $
        !            12:  * Revision 7.1  90/07/09  14:37:18  mrose
        !            13:  * sync
        !            14:  * 
        !            15:  * Revision 7.0  89/11/23  21:54:27  mrose
        !            16:  * Release 6.0
        !            17:  * 
        !            18:  */
        !            19: 
        !            20: /*
        !            21:  *                               NOTICE
        !            22:  *
        !            23:  *    Acquisition, use, and distribution of this module and related
        !            24:  *    materials are subject to the restrictions of a license agreement.
        !            25:  *    Consult the Preface in the User's Manual for the full terms of
        !            26:  *    this agreement.
        !            27:  *
        !            28:  */
        !            29: 
        !            30: 
        !            31: #include <ctype.h>
        !            32: #include <setjmp.h>
        !            33: #include <signal.h>
        !            34: #include <stdio.h>
        !            35: #include <varargs.h>
        !            36: #include "ftamuser.h"
        !            37: #include "tailor.h"
        !            38: 
        !            39: /*    DATA */
        !            40: 
        !            41: #ifndef        BRIDGE
        !            42: static char *myname = "ftam";
        !            43: 
        !            44: static char **op = NULL;
        !            45: 
        !            46: static char *aflag = NULL;
        !            47: static char *oflag = NULL;
        !            48: static int   fflag = 0;
        !            49: static char *hflag = NULL;
        !            50: static char *uflag = NULL;
        !            51: 
        !            52: 
        !            53: static char ringring = 0x07;
        !            54: 
        !            55: int    ontty;
        !            56: 
        !            57: static int     armed;
        !            58: static jmp_buf intrenv;
        !            59: #endif
        !            60: int    interrupted;
        !            61: 
        !            62: 
        !            63: void   adios (), advise ();
        !            64: #ifndef        BRIDGE
        !            65: SFD    intrser ();
        !            66: #endif
        !            67: 
        !            68: /*    MAIN */
        !            69: 
        !            70: /* ARGSUSED */
        !            71: 
        !            72: #ifndef        BRIDGE
        !            73: main (argc, argv, envp)
        !            74: int    argc;
        !            75: char  **argv,
        !            76:       **envp;
        !            77: {
        !            78:     int     eof,
        !            79:            status,
        !            80:             vecp;
        !            81:     SFP            istat;
        !            82:     char   *bp,
        !            83:            buffer[BUFSIZ],
        !            84:            *vec[NVEC + 1];
        !            85:     FILE   *fp;
        !            86: 
        !            87:     arginit (argv);
        !            88: 
        !            89:     runcom = 1;
        !            90:     
        !            91:     rcinit ();
        !            92:     (void) sprintf (buffer, "%s/.ftamrc", myhome);
        !            93: 
        !            94:     if (!fflag && (fp = fopen (buffer, "r"))) {
        !            95:        while (fgets (buffer, sizeof buffer, fp)) {
        !            96:            if (bp = index (buffer, '\n'))
        !            97:                *bp = NULL;
        !            98: 
        !            99:            bzero ((char *) vec, sizeof vec);
        !           100:            if ((vecp = str2vec (buffer, vec)) < 1)
        !           101:                continue;
        !           102: 
        !           103:            if (ftamloop (vec, NOTOK) != OK && op)
        !           104:                exit (1);
        !           105:        }
        !           106:     
        !           107:        (void) fclose (fp);
        !           108:     }
        !           109:        
        !           110:     if (hflag) {
        !           111:        vecp = 0;
        !           112:        vec[vecp++] = "open";
        !           113:        vec[vecp++] = hflag;
        !           114:        if (uflag)
        !           115:            vec[vecp++] = uflag;
        !           116:        if (aflag)
        !           117:            vec[vecp++] = aflag;
        !           118:        vec[vecp] = NULL;
        !           119: 
        !           120:        if (ftamloop (vec, NOTOK) != OK && op)
        !           121:            exit (1);
        !           122:     }
        !           123:     else {
        !           124:        if (uflag)
        !           125:            user = strdup (uflag);
        !           126:        if (aflag)
        !           127:            account = strdup (aflag);
        !           128:     }
        !           129: 
        !           130:     if (oflag) {
        !           131:        vecp = 0;
        !           132:        vec[vecp++] = "set";
        !           133:        vec[vecp++] = "override";
        !           134:        vec[vecp++] = oflag;
        !           135:        vec[vecp] = NULL;
        !           136: 
        !           137:        if (ftamloop (vec, NOTOK) != OK && op)
        !           138:            exit (1);
        !           139:     }
        !           140:        
        !           141:     runcom = 0;
        !           142: 
        !           143:     if (op) {
        !           144:        for (vecp = 0; *op; op++)
        !           145:            vec[vecp++] = *op;
        !           146:        vec[vecp] = NULL;
        !           147: 
        !           148:        status = ftamfd != NOTOK ? 1 : 0;
        !           149:        switch (ftamloop (vec, NOTOK)) {
        !           150:            case NOTOK: 
        !           151:                status = 1;
        !           152:                break;
        !           153: 
        !           154:            case OK: 
        !           155:            case DONE: 
        !           156:            default:
        !           157:                if (ftamfd != NOTOK)
        !           158:                    status = 0;
        !           159:                break;
        !           160:        }
        !           161:     }
        !           162:     else {
        !           163:        istat = signal (SIGINT, intrser);
        !           164: 
        !           165:        eof = 0;
        !           166:        for (interrupted = 0;; interrupted = 0) {
        !           167:            if (hash && marks >= BUFSIZ) {
        !           168:                marks = 0;
        !           169:                printf ("\n");
        !           170:            }
        !           171: 
        !           172:            if (getline ("%s> ", buffer) == NOTOK) {
        !           173:                if (eof)
        !           174:                    break;
        !           175: 
        !           176:                eof = 1;
        !           177:                continue;
        !           178:            }
        !           179:            eof = 0;
        !           180: 
        !           181:            bzero ((char *) vec, sizeof vec);
        !           182:            if ((vecp = str2vec (buffer, vec)) < 1)
        !           183:                continue;
        !           184: 
        !           185:            switch (ftamloop (vec, OK)) {
        !           186:                case NOTOK: 
        !           187:                    status = 1;
        !           188:                    break;
        !           189: 
        !           190:                case OK: 
        !           191:                default: 
        !           192:                    if (bell)
        !           193:                        (void) putchar (ringring);
        !           194:                    continue;
        !           195: 
        !           196:                case DONE: 
        !           197:                    status = 0;
        !           198:                    break;
        !           199:            }
        !           200:            break;
        !           201:        }
        !           202: 
        !           203:        (void) signal (SIGINT, istat);
        !           204:     }
        !           205: 
        !           206:     if (ftamfd != NOTOK) {
        !           207:        vecp = 0;
        !           208:        vec[vecp++] = "close";
        !           209:        vec[vecp] = NULL;
        !           210:        
        !           211:        (void) ftamloop (vec, NOTOK);
        !           212:     }
        !           213: 
        !           214:     exit (status);             /* NOTREACHED */
        !           215: }
        !           216: #endif
        !           217: 
        !           218: /*  */
        !           219: 
        !           220: #ifndef        BRIDGE
        !           221: static ftamloop (vec, error)
        !           222: char  **vec;
        !           223: int    error;
        !           224: {
        !           225:     register struct dispatch   *ds;
        !           226: 
        !           227:     if ((ds = getds (strcmp (*vec, "?") ? *vec : "help")) == NULL)
        !           228:        return error;
        !           229: 
        !           230:     if (ftamfd == NOTOK) {
        !           231:        if (ds -> ds_flags & DS_OPEN) {
        !           232:            advise (NULLCP, "not associated with virtual filestore");
        !           233:            return error;
        !           234:        }
        !           235:     }
        !           236:     else
        !           237:        if (ds -> ds_flags & DS_CLOSE) {
        !           238:            advise (NULLCP, "already associated with virtual filestore");
        !           239:            return error;
        !           240:        }
        !           241: 
        !           242:     if (ds -> ds_flags & DS_MODES) {
        !           243:        switch (ds -> ds_class) {
        !           244:            case FCLASS_TRANSFER:
        !           245:                if (class != FCLASS_TRANSFER && class != FCLASS_TM) {
        !           246:                    advise (NULLCP, "need transfer service class");
        !           247:                    return error;
        !           248:                }
        !           249:                break;
        !           250: 
        !           251:            case FCLASS_MANAGE:
        !           252:                if (class != FCLASS_MANAGE && class != FCLASS_TM) {
        !           253:                    advise (NULLCP, "need management service class");
        !           254:                    return error;
        !           255:                }
        !           256:                break;
        !           257: 
        !           258:            default:
        !           259:                break;
        !           260:        }
        !           261: 
        !           262:        if ((ds -> ds_units & units) != ds -> ds_units) {
        !           263:            advise (NULLCP, "need %s functional units",
        !           264:                    sprintb (ds -> ds_units & ~units, UMASK));
        !           265:            return error;
        !           266:        }
        !           267:     }
        !           268: 
        !           269:     switch ((*ds -> ds_fnx) (vec)) {
        !           270:        case NOTOK: 
        !           271:            return error;
        !           272: 
        !           273:        case OK: 
        !           274:        default: 
        !           275:            return OK;
        !           276: 
        !           277:        case DONE: 
        !           278:            return DONE;
        !           279:     }
        !           280: }
        !           281: #endif
        !           282: 
        !           283: /*    ARGINIT */
        !           284: 
        !           285: #ifndef        BRIDGE
        !           286: static arginit (vec)
        !           287: char  **vec;
        !           288: {
        !           289:     register char  *ap,
        !           290:                    *pp;
        !           291: 
        !           292:     if (myname = rindex (*vec, '/'))
        !           293:        myname++;
        !           294:     if (myname == NULL || *myname == NULL)
        !           295:        myname = *vec;
        !           296: 
        !           297:     isodetailor (myname, 1);
        !           298:     ftam_log -> ll_file = strdup ("./ftam.log");
        !           299:     ll_hdinit (ftam_log, myname);
        !           300: 
        !           301:     storename = strdup ("filestore");
        !           302:     if (ontty = isatty (fileno (stdin)))
        !           303:        verbose++;
        !           304: 
        !           305:     for (vec++; ap = *vec; vec++) {
        !           306:        if (*ap == '-') {
        !           307:            while (*++ap)
        !           308:                switch (*ap) {
        !           309:                    case 'a': 
        !           310:                        if ((pp = *++vec) == NULL || *pp == NULL)
        !           311:                            adios (NULLCP, "usage: %s -a acct", myname);
        !           312:                        aflag = pp;
        !           313:                        break;
        !           314: 
        !           315:                    case 'd': 
        !           316:                        debug++;
        !           317:                        break;
        !           318: 
        !           319:                    case 'f':
        !           320:                        fflag++;
        !           321:                        break;
        !           322: 
        !           323:                    case 'h': 
        !           324:                        hash++;
        !           325:                        break;
        !           326: 
        !           327:                    case 'o': 
        !           328:                        if ((pp = *++vec) == NULL || *pp == NULL)
        !           329:                            adios (NULLCP, "usage: %s -o mode", myname);
        !           330:                        oflag = pp;
        !           331:                        break;
        !           332: 
        !           333:                    case 't': 
        !           334:                        trace++;
        !           335:                        break;
        !           336: 
        !           337:                    case 'u': 
        !           338:                        if ((pp = *++vec) == NULL || *pp == NULL)
        !           339:                            adios (NULLCP, "usage: %s -u user", myname);
        !           340:                        uflag = pp;
        !           341:                        break;
        !           342: 
        !           343:                    case 'v': 
        !           344:                        verbose = 1;
        !           345:                        break;
        !           346: 
        !           347:                    case 'w': 
        !           348:                        watch++;
        !           349:                        break;
        !           350: 
        !           351:                    default: 
        !           352:                        adios (NULLCP, "unknown switch -%c", *ap);
        !           353:                }
        !           354:            continue;
        !           355:        }
        !           356: 
        !           357:        if (hflag == NULL)
        !           358:            hflag = ap;
        !           359:        else
        !           360:            if (op == NULL) {
        !           361:                op = vec;
        !           362:                break;
        !           363:            }
        !           364:     }
        !           365: }
        !           366: #endif
        !           367: 
        !           368: /*    INTERACTIVE */
        !           369: 
        !           370: #ifndef        BRIDGE
        !           371: int    getline (prompt, buffer)
        !           372: char   *prompt,
        !           373:        *buffer;
        !           374: {
        !           375:     register int    i;
        !           376:     register char  *cp,
        !           377:                    *ep;
        !           378:     static int  sticky = 0;
        !           379: 
        !           380:     if (interrupted) {
        !           381:        interrupted = 0;
        !           382:        return NOTOK;
        !           383:     }
        !           384: 
        !           385:     if (sticky) {
        !           386:        sticky = 0;
        !           387:        return NOTOK;
        !           388:     }
        !           389: 
        !           390:     switch (setjmp (intrenv)) {
        !           391:        case OK:
        !           392:            armed++;
        !           393:            break;
        !           394: 
        !           395:        case NOTOK:
        !           396:            if (ontty)
        !           397:                printf ("\n");  /* and fall */
        !           398:        default:
        !           399:            armed = 0;
        !           400:            return NOTOK;
        !           401:     }
        !           402:        
        !           403:     if (ontty) {
        !           404:        printf (prompt, ftamfd != NOTOK ? host : myname);
        !           405:        (void) fflush (stdout);
        !           406:     }
        !           407: 
        !           408:     for (ep = (cp = buffer) + BUFSIZ - 1; (i = getchar ()) != '\n';) {
        !           409:        if (i == EOF) {
        !           410:            if (ontty)
        !           411:                printf ("\n");
        !           412:            clearerr (stdin);
        !           413:            if (cp == buffer)
        !           414:                longjmp (intrenv, DONE);
        !           415: 
        !           416:            sticky++;
        !           417:            break;
        !           418:        }
        !           419: 
        !           420:        if (cp < ep)
        !           421:            *cp++ = i;
        !           422:     }
        !           423:     *cp = NULL;
        !           424: 
        !           425:     armed = 0;
        !           426:     
        !           427:     return OK;
        !           428: }
        !           429: #endif
        !           430: 
        !           431: /*  */
        !           432: 
        !           433: #ifndef        BRIDGE
        !           434: 
        !           435: /* ARGSUSED */
        !           436: 
        !           437: static SFD intrser (sig)
        !           438: int    sig;
        !           439: {
        !           440: #ifndef        BSDSIGS
        !           441:     (void) signal (SIGINT, intrser);
        !           442: #endif
        !           443: 
        !           444:     if (armed)
        !           445:        longjmp (intrenv, NOTOK);
        !           446: 
        !           447:     interrupted++;
        !           448: }
        !           449: #endif
        !           450: 
        !           451: /*  */
        !           452: 
        !           453: #ifndef        BRIDGE
        !           454: #ifndef        lint
        !           455: int    ask (va_alist)
        !           456: va_dcl
        !           457: {
        !           458:     int     x,
        !           459:             y,
        !           460:             result;
        !           461:     char    buffer[BUFSIZ];
        !           462:     va_list ap;
        !           463: 
        !           464:     if (interrupted) {
        !           465:        interrupted = 0;
        !           466:        return NOTOK;
        !           467:     }
        !           468: 
        !           469:     if (!ontty)
        !           470:        return OK;
        !           471: 
        !           472:     switch (setjmp (intrenv)) {
        !           473:        case OK: 
        !           474:            armed++;
        !           475:            break;
        !           476: 
        !           477:        case NOTOK: 
        !           478:        default: 
        !           479:            printf ("\n");
        !           480:            armed = 0;
        !           481:            return DONE;
        !           482:     }
        !           483:     if (bell)
        !           484:        (void) putchar (ringring);
        !           485: 
        !           486:     va_start (ap);
        !           487: 
        !           488:     _asprintf (buffer, NULLCP, ap);
        !           489: 
        !           490:     va_end (ap);
        !           491:     
        !           492: again: ;
        !           493:     printf ("%s? (y)es, (n)o: ", buffer);
        !           494: 
        !           495:     x = y = getchar ();
        !           496:     while (y != '\n' && y != EOF)
        !           497:        y = getchar ();
        !           498: 
        !           499:     switch (x) {
        !           500:        case 'y': 
        !           501:        case '\n':
        !           502:            result = OK;
        !           503:            break;
        !           504: 
        !           505:        case 'n': 
        !           506:            result = NOTOK;
        !           507:            break;
        !           508: 
        !           509:        case EOF: 
        !           510:            result = DONE;
        !           511:            break;
        !           512: 
        !           513:        default: 
        !           514:            goto again;
        !           515:     }
        !           516: 
        !           517:     armed = 0;
        !           518: 
        !           519:     return result;
        !           520: }
        !           521: #else
        !           522: /* VARARGS */
        !           523: 
        !           524: int    ask (fmt)
        !           525: char   *fmt;
        !           526: {
        !           527:     return ask (fmt);
        !           528: }
        !           529: #endif
        !           530: #endif
        !           531: 
        !           532: /*    ERRORS */
        !           533: 
        !           534: #ifndef        lint
        !           535: void   _advise ();
        !           536: 
        !           537: 
        !           538: void   adios (va_alist)
        !           539: va_dcl
        !           540: {
        !           541:     struct FTAMindication   ftis;
        !           542:     va_list ap;
        !           543: 
        !           544:     va_start (ap);
        !           545: 
        !           546:     _advise (ap);
        !           547: 
        !           548:     va_end (ap);
        !           549: 
        !           550:     if (ftamfd != NOTOK)
        !           551:        (void) FUAbortRequest (ftamfd, FACTION_PERM,
        !           552:                (struct FTAMdiagnostic *) 0, 0, &ftis);
        !           553: 
        !           554: #ifdef BRIDGE
        !           555:     reply (550, ftam_error);
        !           556:     exit (1);
        !           557: #else
        !           558:     _exit (1);
        !           559: #endif
        !           560: }
        !           561: #else
        !           562: /* VARARGS */
        !           563: 
        !           564: void   adios (what, fmt)
        !           565: char   *what,
        !           566:        *fmt;
        !           567: {
        !           568:     adios (what, fmt);
        !           569: }
        !           570: #endif
        !           571: 
        !           572: 
        !           573: #ifndef        lint
        !           574: void   advise (va_alist)
        !           575: va_dcl
        !           576: {
        !           577:     va_list ap;
        !           578: 
        !           579:     va_start (ap);
        !           580: 
        !           581:     _advise (ap);
        !           582: 
        !           583:     va_end (ap);
        !           584: }
        !           585: 
        !           586: 
        !           587: static void  _advise (ap)
        !           588: va_list        ap;
        !           589: {
        !           590:     char    buffer[BUFSIZ];
        !           591: 
        !           592:     asprintf (buffer, ap);
        !           593: 
        !           594: #ifndef        BRIDGE
        !           595:     if (hash && marks >= BUFSIZ) {
        !           596:        marks = 0;
        !           597:        printf ("\n");
        !           598:     }
        !           599: 
        !           600:     (void) fflush (stdout);
        !           601: 
        !           602:     fprintf (stderr, "%s: ", myname);
        !           603:     (void) fputs (buffer, stderr);
        !           604:     (void) fputc ('\n', stderr);
        !           605: 
        !           606:     (void) fflush (stderr);
        !           607: #else
        !           608:     (void) ll_log (ftam_log, LLOG_NOTICE, NULLCP, "%s", buffer);
        !           609:     (void) strcpy (ftam_error, buffer);
        !           610: #endif
        !           611: }
        !           612: #else
        !           613: /* VARARGS */
        !           614: 
        !           615: void   advise (what, fmt)
        !           616: char   *what,
        !           617:        *fmt;
        !           618: {
        !           619:     advise (what, fmt);
        !           620: }
        !           621: #endif
        !           622: 
        !           623: /*    MISCELLANY */
        !           624: 
        !           625: #ifndef        lint
        !           626: char   *strdup (s)
        !           627: char   *s;
        !           628: {
        !           629:     char    *p;
        !           630: 
        !           631:     if ((p = malloc((unsigned) (strlen (s) + 1))) == NULL)
        !           632:        adios (NULLCP, "out of memory");
        !           633: 
        !           634:     (void) strcpy (p, s);
        !           635: 
        !           636:     return p;
        !           637: }
        !           638: #endif

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