Return to ftamd.c CVS log

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

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

1.1     ! root        1: /* ftamd.c - FTAM -- responder */
        !             2: 
        !             3: #ifndef        lint
        !             4: static char *rcsid = "$Header: /f/osi/ftam2/RCS/ftamd.c,v 7.0 89/11/23 21:54:36 mrose Rel $";
        !             5: #endif
        !             6: 
        !             7: /* 
        !             8:  * $Header: /f/osi/ftam2/RCS/ftamd.c,v 7.0 89/11/23 21:54:36 mrose Rel $
        !             9:  *
        !            10:  *
        !            11:  * $Log:       ftamd.c,v $
        !            12:  * Revision 7.0  89/11/23  21:54:36  mrose
        !            13:  * Release 6.0
        !            14:  * 
        !            15:  */
        !            16: 
        !            17: /*
        !            18:  *                               NOTICE
        !            19:  *
        !            20:  *    Acquisition, use, and distribution of this module and related
        !            21:  *    materials are subject to the restrictions of a license agreement.
        !            22:  *    Consult the Preface in the User's Manual for the full terms of
        !            23:  *    this agreement.
        !            24:  *
        !            25:  */
        !            26: 
        !            27: 
        !            28: #include <stdio.h>
        !            29: #include <varargs.h>
        !            30: #include "ftamsystem.h"
        !            31: 
        !            32: /*    DATA */
        !            33: 
        !            34: int    ftamfd = NOTOK;
        !            35: 
        !            36: int    cflag = 0;
        !            37: int    debug = 0;
        !            38: char   *myname = "ftamd";
        !            39: 
        !            40: /*    MAIN */
        !            41: 
        !            42: #define        SMASK   "\020\01UNCONS\02MANAGE\03TRANSFER\04TM\05ACCESS"
        !            43: 
        !            44: #define        UMASK   "\020\01READ\02WRITE\03ACCESS\04LIMITED\05ENHANCED\06GROUPING\
        !            45: \07FADULOCK\08RECOVERY\00RESTART"
        !            46: 
        !            47: #define        AMASK   "\020\01STORAGE\02SECURITY\03PRIVATE"
        !            48: 
        !            49: /* ARGSUSED */
        !            50: 
        !            51: main (argc, argv, envp)
        !            52: int    argc;
        !            53: char  **argv,
        !            54:       **envp;
        !            55: {
        !            56:     int     result;
        !            57:     char   *ap;
        !            58:     struct FTAMstart    ftss;
        !            59:     register struct FTAMstart  *fts = &ftss;
        !            60:     struct FTAMindication   ftis;
        !            61:     register struct FTAMindication *fti = &ftis;
        !            62: 
        !            63:     if (myname = rindex (argv[0], '/'))
        !            64:        myname++;
        !            65:     if (myname == NULL || *myname == NULL)
        !            66:        myname = argv[0];
        !            67: 
        !            68:     isodetailor (myname, 0);
        !            69:     if (debug == 0 && !(debug = isatty (fileno (stderr)))) {
        !            70:        ftam_log -> ll_stat &= ~LLOGCLS;
        !            71:        ll_hdinit (ftam_log, myname);
        !            72:     }
        !            73:     else
        !            74:        ll_dbinit (ftam_log, myname);
        !            75: 
        !            76:     advise (LLOG_NOTICE, NULLCP, "starting");
        !            77: 
        !            78:     if (FInit (argc, argv, fts, debug ? FTraceHook : NULLIFP, fti) == NOTOK)
        !            79:        ftam_adios (&fti -> fti_abort, "initialization");
        !            80:     advise (LLOG_NOTICE, NULLCP,
        !            81:            "F-INITIALIZE.INDICATION: <%d, %s, %s, %s, %s>",
        !            82:            fts -> fts_sd, oid2ode (fts -> fts_context),
        !            83:            sprintb (fts -> fts_class, SMASK),
        !            84:            fts -> fts_initiator ? fts -> fts_initiator : "",
        !            85:            fts -> fts_account ? fts -> fts_account : "");
        !            86: #ifdef DEBUG
        !            87:     {
        !            88:        register int    i;
        !            89:        register struct FTAMcontent *fx;
        !            90: 
        !            91:        advise (LLOG_DEBUG, NULLCP,
        !            92:                " called AE title: %s, called PSAP address: %s",
        !            93:                sprintaei (&fts -> fts_calledtitle),
        !            94:                paddr2str (&fts -> fts_calledaddr, NULLNA));
        !            95:        advise (LLOG_DEBUG, NULLCP,
        !            96:                " calling AE title: %s, calling PSAP address: %s",
        !            97:                sprintaei (&fts -> fts_callingtitle),
        !            98:                paddr2str (&fts -> fts_callingaddr, NULLNA));
        !            99: 
        !           100:        advise (LLOG_DEBUG, NULLCP, " manage: %d, ftam-QoS: %d",
        !           101:                fts -> fts_manage, fts -> fts_fqos);
        !           102:        advise (LLOG_DEBUG, NULLCP, " units: %s",
        !           103:                sprintb (fts -> fts_units, UMASK));
        !           104:        advise (LLOG_DEBUG, NULLCP, " attrs: %s",
        !           105:                sprintb (fts -> fts_attrs, AMASK));
        !           106: 
        !           107:        for (fx = fts -> fts_contents.fc_contents, i = 0;
        !           108:                i < fts -> fts_contents.fc_ncontent;
        !           109:                fx++, i++)
        !           110:            advise (LLOG_DEBUG, NULLCP, " cnt %d: %s %d %d",
        !           111:                i, sprintoid (fx -> fc_dtn), fx -> fc_id, fx -> fc_result);
        !           112:     }
        !           113: #endif
        !           114: 
        !           115:     for (argv++; ap = *argv; argv++)
        !           116:        if (*ap == '-')
        !           117:            while (*++ap)
        !           118:                switch (*ap) {
        !           119:                    case 'c':
        !           120:                        cflag++;
        !           121:                        break;
        !           122: 
        !           123:                    case 'd':
        !           124:                        debug++;
        !           125:                        ll_dbinit (ftam_log, myname);
        !           126:                        (void) FHookRequest (fts -> fts_sd, FTraceHook, fti);
        !           127:                        break;
        !           128: 
        !           129:                    default:
        !           130:                        adios (NULLCP, "unknown switch -%c", *ap);
        !           131:                }
        !           132:        else
        !           133:            advise (LLOG_NOTICE, NULLCP, "unknown argument \"%s\"", ap);    
        !           134: 
        !           135:     ftam_start (fts);
        !           136: 
        !           137:     FTSFREE (fts);
        !           138: 
        !           139:     for (;;)
        !           140:        switch (result = FWaitRequest (ftamfd, NOTOK, fti)) {
        !           141:            case NOTOK: 
        !           142:            case OK: 
        !           143:            case DONE: 
        !           144:                ftam_indication (fti);
        !           145:                break;
        !           146: 
        !           147:            default: 
        !           148:                adios (NULLCP, "unknown return from FWaitRequest=%d", result);
        !           149:        }
        !           150: }
        !           151: 
        !           152: /*  */
        !           153: 
        !           154: void   ftam_adios (fta, event)
        !           155: struct FTAMabort *fta;
        !           156: char   *event;
        !           157: {
        !           158:     struct FTAMindication   ftis;
        !           159: 
        !           160:     ftam_advise (fta, event);
        !           161: 
        !           162:     if (fta -> fta_action != FACTION_PERM && ftamfd != NOTOK)
        !           163:        (void) FUAbortRequest (ftamfd, FACTION_PERM,
        !           164:                (struct FTAMdiagnostic *) 0, 0, &ftis);
        !           165: 
        !           166:     closewtmp ();
        !           167: 
        !           168:     _exit (1);
        !           169: }
        !           170: 
        !           171: 
        !           172: void   ftam_advise (fta, event)
        !           173: register struct FTAMabort *fta;
        !           174: char   *event;
        !           175: {
        !           176:     advise (LLOG_NOTICE, NULLCP, "%s: failed", event);
        !           177:     ftam_diag (fta -> fta_diags, fta -> fta_ndiag);
        !           178: 
        !           179:     if (fta -> fta_action == FACTION_PERM) {
        !           180:        closewtmp ();
        !           181: 
        !           182:        _exit (1);
        !           183:     }
        !           184: }
        !           185: 
        !           186: /*  */
        !           187: 
        !           188: static char *entity[] = {
        !           189:     "UNK", "IFSU", "IFPM", "VFS", "RFPM", "RFSU"
        !           190: };
        !           191: 
        !           192: 
        !           193: void   ftam_diag (diag, ndiag)
        !           194: struct FTAMdiagnostic diag[];
        !           195: int    ndiag;
        !           196: {
        !           197:     register int    i;
        !           198:     register char  *cp;
        !           199:     char    buffer[BUFSIZ];
        !           200:     register struct FTAMdiagnostic *dp;
        !           201: 
        !           202:     for (dp = diag, i = ndiag - 1; i >= 0; dp++, i--) {
        !           203:        cp = buffer;
        !           204:        (void) sprintf (cp, "%s", FErrString (dp -> ftd_identifier));
        !           205: 
        !           206:        if (dp -> ftd_cc > 0) {
        !           207:            cp += strlen (cp);
        !           208:            (void) sprintf (cp, ": %*.*s", dp -> ftd_cc, dp -> ftd_cc,
        !           209:                    dp -> ftd_data);
        !           210:        }
        !           211: 
        !           212:        advise (LLOG_NOTICE, NULLCP, "%s", buffer);
        !           213: 
        !           214:        cp = buffer;
        !           215:        (void) sprintf (cp, "    type ");
        !           216:        cp += strlen (cp);
        !           217: 
        !           218:        switch (dp -> ftd_type) {
        !           219:            case DIAG_INFORM: 
        !           220:                (void) sprintf (cp, "informative");
        !           221:                break;
        !           222: 
        !           223:            case DIAG_TRANS: 
        !           224:                (void) sprintf (cp, "transient");
        !           225:                break;
        !           226: 
        !           227:            case DIAG_PERM: 
        !           228:                (void) sprintf (cp, "permanent");
        !           229:                break;
        !           230: 
        !           231:            default: 
        !           232:                (void) sprintf (cp, "%d", dp -> ftd_type);
        !           233:                break;
        !           234:        }
        !           235:        cp += strlen (cp);
        !           236: 
        !           237:        (void) sprintf (cp, ", observer ");
        !           238:        cp += strlen (cp);
        !           239: 
        !           240:        switch (dp -> ftd_observer) {
        !           241:            case EREF_IFSU: 
        !           242:            case EREF_IFPM: 
        !           243:            case EREF_RFPM: 
        !           244:            case EREF_RFSU: 
        !           245:                (void) sprintf (cp, "%s", entity[dp -> ftd_observer]);
        !           246:                break;
        !           247: 
        !           248:            default: 
        !           249:                (void) sprintf (cp, "%d", dp -> ftd_observer);
        !           250:                break;
        !           251:        }
        !           252:        cp += strlen (cp);
        !           253: 
        !           254:        (void) sprintf (cp, ", source ");
        !           255:        cp += strlen (cp);
        !           256: 
        !           257:        switch (dp -> ftd_source) {
        !           258:            case EREF_NONE: 
        !           259:            case EREF_IFSU: 
        !           260:            case EREF_IFPM: 
        !           261:            case EREF_SERV: 
        !           262:            case EREF_RFPM: 
        !           263:            case EREF_RFSU: 
        !           264:                (void) sprintf (cp, "%s", entity[dp -> ftd_source]);
        !           265:                break;
        !           266: 
        !           267:            default: 
        !           268:                (void) sprintf (cp, "%d", dp -> ftd_source);
        !           269:                break;
        !           270:        }
        !           271: 
        !           272:        if (dp -> ftd_delay != DIAG_NODELAY) {
        !           273:            cp += strlen (cp);
        !           274:            (void) sprintf (cp, ", suggested-delay %d", dp -> ftd_delay);
        !           275:        }
        !           276: 
        !           277:        advise (LLOG_NOTICE, NULLCP, "%s", buffer);
        !           278:     }
        !           279: }
        !           280: 
        !           281: /*  */
        !           282: 
        !           283: #ifndef        lint
        !           284: void   adios (va_alist)
        !           285: va_dcl
        !           286: {
        !           287:     struct FTAMindication   ftis;
        !           288:     va_list ap;
        !           289: 
        !           290:     va_start (ap);
        !           291: 
        !           292:     (void) _ll_log (ftam_log, LLOG_FATAL, ap);
        !           293: 
        !           294:     va_end (ap);
        !           295: 
        !           296:     if (ftamfd != NOTOK)
        !           297:        (void) FUAbortRequest (ftamfd, FACTION_PERM,
        !           298:                (struct FTAMdiagnostic *) 0, 0, &ftis);
        !           299: 
        !           300:     closewtmp ();
        !           301: 
        !           302:     _exit (1);
        !           303: }
        !           304: #else
        !           305: /* VARARGS */
        !           306: 
        !           307: void   adios (what, fmt)
        !           308: char   *what,
        !           309:        *fmt;
        !           310: {
        !           311:     adios (what, fmt);
        !           312: }
        !           313: #endif
        !           314: 
        !           315: 
        !           316: #ifndef        lint
        !           317: void   advise (va_alist)
        !           318: va_dcl
        !           319: {
        !           320:     int            code;
        !           321:     va_list ap;
        !           322: 
        !           323:     va_start (ap);
        !           324: 
        !           325:     code = va_arg (ap, int);
        !           326: 
        !           327:     (void) _ll_log (ftam_log, code, ap);
        !           328: 
        !           329:     va_end (ap);
        !           330: }
        !           331: #else
        !           332: /* VARARGS */
        !           333: 
        !           334: void   advise (code, what, fmt)
        !           335: char   *what,
        !           336:        *fmt;
        !           337: int    code;
        !           338: {
        !           339:     advise (code, what, fmt);
        !           340: }
        !           341: #endif

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