Return to text2spkt.c CVS log

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

Annotation of 43BSDReno/contrib/isode-beta/ssap/text2spkt.c, revision 1.1

1.1     ! root        1: /* text2spkt.c - read/write a SPDU thru a debug filter */
        !             2: 
        !             3: #ifndef        lint
        !             4: static char *rcsid = "$Header: /f/osi/ssap/RCS/text2spkt.c,v 7.0 89/11/23 22:25:54 mrose Rel $";
        !             5: #endif
        !             6: 
        !             7: /* 
        !             8:  * $Header: /f/osi/ssap/RCS/text2spkt.c,v 7.0 89/11/23 22:25:54 mrose Rel $
        !             9:  *
        !            10:  *
        !            11:  * $Log:       text2spkt.c,v $
        !            12:  * Revision 7.0  89/11/23  22:25:54  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: /* LINTLIBRARY */
        !            29: 
        !            30: #include <stdio.h>
        !            31: #include "spkt.h"
        !            32: #include "logger.h"
        !            33: 
        !            34: 
        !            35: #define        sprintc(v,b)    sprintb ((int) (v), (b))
        !            36: 
        !            37: /*  */
        !            38: 
        !            39: #define        SPDU_TYPE(e)    (void) ll_printf (lp, "%sCODE/ %s\n", rw, e)
        !            40: 
        !            41: #define        DMASK   "\020\01RELEASE\02USER\03PROTOCOL\04UNKNOWN"
        !            42: #define        EMASK   "\020\01BEGIN\02END"
        !            43: #define        OMASK   "\020\01EXTD"
        !            44: #define        RMASK \
        !            45:     "\020\01HALFDUPLEX\02DUPLEX\03EXPEDITED\04MINORSYNC\05MAJORSYNC\06RESYNC\07ACTIVITY\010NEGOTIATED\011CAPABILITY\012EXCEPTIONS\013TYPEDATA"
        !            46: #define        SMASK   "\020\01NOEND"
        !            47: #define        TMASK   "\020\01DATA\03SYNC\05ACTIVITY\07RELEASE"
        !            48: #define        YMASK   "\020\01NOEXPLICIT"
        !            49: 
        !            50: 
        !            51: 
        !            52: void   spkt2text (lp, s, read)
        !            53: register LLog *lp;
        !            54: register struct ssapkt *s;
        !            55: int    read;
        !            56: {
        !            57:     char   *rw = read ? "<--- " : "---> ";
        !            58: 
        !            59:     LLOG (lp, LLOG_ALL,
        !            60:          ("dump of SPDU 0x%x, errno=0x%x mask=0x%x%s",
        !            61:           s, s -> s_errno, s -> s_mask,
        !            62:           s -> s_mask & SMASK_SPDU_EXPD ? " (expedited)" : ""));
        !            63:     (void) ll_printf (lp, "%s(\n", rw);
        !            64: 
        !            65:     (void) ll_printf (lp, "%sLI/ %d\n", rw, s -> s_li);
        !            66: 
        !            67:     switch (s -> s_code) {
        !            68:        case SPDU_CN: 
        !            69:        case SPDU_AC: 
        !            70:            SPDU_TYPE (s -> s_code == SPDU_CN ? "CONNECT" : "ACCEPT");
        !            71:            if (s -> s_mask & SMASK_CN_REF)
        !            72:                type_ref (lp, rw, &s -> s_cn_reference);
        !            73:            if (s -> s_mask & SMASK_CN_OPT)
        !            74:                type_bits (lp, rw, "OPTIONS", s -> s_options, CR_OPT_MASK,
        !            75:                        OMASK);
        !            76:            if (s -> s_mask & SMASK_CN_TSDU)
        !            77:                type_tsdu (lp, rw, s -> s_tsdu_init, s -> s_tsdu_resp);
        !            78:            if (s -> s_mask & SMASK_CN_VRSN)
        !            79:                type_vrsn (lp, rw, s -> s_cn_version);
        !            80:            if (s -> s_mask & SMASK_CN_ISN)
        !            81:                type_ssn (lp, rw, "ISN", s -> s_isn);
        !            82:            if (s -> s_mask & SMASK_CN_SET)
        !            83:                type_settings (lp, rw, s -> s_settings);
        !            84:            if (s -> s_code == SPDU_AC && (s -> s_mask & SMASK_AC_TOKEN))
        !            85:                type_bits (lp, rw, "TOKENS", s -> s_ac_token, -1, TMASK);
        !            86:            if (s -> s_mask & SMASK_CN_REQ)
        !            87:                type_bits (lp, rw, "REQUIREMENTS", s -> s_cn_require,
        !            88:                        -1, RMASK);
        !            89:            if (s -> s_mask & SMASK_CN_CALLING)
        !            90:                type_id (lp, "CALLING", rw, s -> s_calling, s -> s_callinglen);
        !            91:            if (s -> s_mask & SMASK_CN_CALLED)
        !            92:                type_id (lp, "CALLED", rw, s -> s_called, s -> s_calledlen);
        !            93:            break;
        !            94: 
        !            95:        case SPDU_RF: 
        !            96:            SPDU_TYPE ("REFUSE");
        !            97:            if (s -> s_mask & SMASK_RF_REF)
        !            98:                type_ref (lp, rw, &s -> s_rf_reference);
        !            99:            if (s -> s_mask & SMASK_RF_DISC)
        !           100:                type_bits (lp, rw, "DISCONNECT", s -> s_rf_disconnect,
        !           101:                        RF_DISC_MASK, DMASK);
        !           102:            if (s -> s_mask & SMASK_RF_REQ)
        !           103:                type_bits (lp, rw, "REQUIREMENTS", s -> s_rf_require,
        !           104:                        -1, RMASK);
        !           105:            if (s -> s_mask & SMASK_RF_VRSN)
        !           106:                type_vrsn (lp, rw, s -> s_rf_version);
        !           107:            if (s -> s_rlen > 0) {
        !           108:                type_reason (lp, rw, *s -> s_rdata & 0xff);
        !           109:                if (s -> s_rlen > 1)
        !           110:                    type_data (lp, "REASON", rw, s -> s_rlen - 1,
        !           111:                            s -> s_rdata + 1);
        !           112:            }
        !           113:            break;
        !           114: 
        !           115:        case SPDU_FN: 
        !           116:            SPDU_TYPE ("FINISH");
        !           117:            if (s -> s_mask & SMASK_FN_DISC)
        !           118:                type_bits (lp, rw, "DISCONNECT", s -> s_fn_disconnect,
        !           119:                        FN_DISC_MASK, DMASK);
        !           120:            break;
        !           121: 
        !           122:        case SPDU_DN: 
        !           123:            SPDU_TYPE ("DISCONNECT");
        !           124:            break;
        !           125: 
        !           126:        case SPDU_NF: 
        !           127:            SPDU_TYPE ("NOT FINISHED");
        !           128:            break;
        !           129: 
        !           130:        case SPDU_AB: 
        !           131: #ifdef notdef
        !           132:        case SPDU_AI:           /* aka SPDU_AB */
        !           133: #endif
        !           134:            if (s -> s_mask & SMASK_SPDU_AB) {
        !           135:                SPDU_TYPE ("ABORT");
        !           136:                if (s -> s_mask & SMASK_AB_DISC)
        !           137:                    type_bits (lp, rw, "DISCONNECT", s -> s_ab_disconnect,
        !           138:                            AB_DISC_MASK, DMASK);
        !           139:                if (s -> s_mask & SMASK_AB_REFL)
        !           140:                    type_data (lp, "REFLECT", rw, sizeof s -> s_reflect,
        !           141:                            (char *) s -> s_reflect);
        !           142:                break;
        !           143:            }
        !           144:            SPDU_TYPE ("ACTIVITY INTERRUPT");
        !           145:            if (s -> s_mask & SMASK_AI_REASON)
        !           146:                type_error (lp, rw, s -> s_ai_reason);
        !           147:            break;
        !           148: 
        !           149:        case SPDU_AA: 
        !           150: #ifdef notdef
        !           151:        case SPDU_AIA:          /* aka SPDU_AA */
        !           152: #endif
        !           153:            if (s -> s_mask & SMASK_SPDU_AA)
        !           154:                SPDU_TYPE ("ABORT ACCEPT");
        !           155:            else
        !           156:                SPDU_TYPE ("ACTIVITY INTERRUPT ACK");
        !           157:            break;
        !           158: 
        !           159:        case SPDU_GT: 
        !           160: #ifdef notdef
        !           161:        case SPDU_DT:           /* aka SPDU_GT */
        !           162: #endif
        !           163:            if (s -> s_mask & SMASK_SPDU_GT) {
        !           164:                SPDU_TYPE ("GIVE TOKENS");
        !           165:                if (s -> s_mask & SMASK_GT_TOKEN)
        !           166:                    type_bits (lp, rw, "TOKENS", s -> s_gt_token, -1, TMASK);
        !           167:            }
        !           168:            else
        !           169:                SPDU_TYPE ("DATA TRANSFER");
        !           170:            break;
        !           171: 
        !           172:        case SPDU_EX: 
        !           173:            SPDU_TYPE ("EXPEDITED");
        !           174:            break;
        !           175: 
        !           176:        case SPDU_TD: 
        !           177:            SPDU_TYPE ("TYPED DATA");
        !           178:            break;
        !           179: 
        !           180:        case SPDU_CD: 
        !           181:            SPDU_TYPE ("CAPABILITY DATA");
        !           182:            break;
        !           183: 
        !           184:        case SPDU_CDA: 
        !           185:            SPDU_TYPE ("CAPABILITY DATA ACK");
        !           186:            break;
        !           187: 
        !           188:        case SPDU_PT: 
        !           189:            SPDU_TYPE ("PLEASE TOKENS");
        !           190:            if (s -> s_mask & SMASK_PT_TOKEN)
        !           191:                type_bits (lp, rw, "TOKENS", s -> s_pt_token, -1, TMASK);
        !           192:            break;
        !           193: 
        !           194:        case SPDU_GTC: 
        !           195:            SPDU_TYPE ("GIVE TOKENS CONFIRM");
        !           196:            break;
        !           197: 
        !           198:        case SPDU_GTA: 
        !           199:            SPDU_TYPE ("GIVE TOKENS ACK");
        !           200:            break;
        !           201: 
        !           202:        case SPDU_MIP: 
        !           203:            SPDU_TYPE ("MINOR SYNCHRONIZATION POINT");
        !           204:            if (s -> s_mask & SMASK_MIP_SYNC)
        !           205:                type_bits (lp, rw, "SYNC", s -> s_mip_sync, MIP_SYNC_MASK,
        !           206:                        YMASK);
        !           207:            if (s -> s_mask & SMASK_MIP_SERIAL)
        !           208:                type_ssn (lp, rw, "SSN", s -> s_mip_serial);
        !           209:            break;
        !           210: 
        !           211:        case SPDU_MIA: 
        !           212:            SPDU_TYPE ("MINOR SYNC ACK");
        !           213:            if (s -> s_mask & SMASK_MIA_SERIAL)
        !           214:                type_ssn (lp, rw, "SSN", s -> s_mia_serial);
        !           215:            break;
        !           216: 
        !           217:        case SPDU_MAP: 
        !           218: #ifdef notdef
        !           219:        case SPDU_AE:           /* aka SPDU_MAP */
        !           220: #endif
        !           221:            if ((s -> s_mask & SMASK_MAP_SYNC)
        !           222:                    && (s -> s_map_sync & MAP_SYNC_NOEND)) {
        !           223:                SPDU_TYPE ("MAJOR SYNCHRONIZATION POINT");
        !           224:                type_bits (lp, rw, "SYNC", s -> s_map_sync, MAP_SYNC_MASK,
        !           225:                        SMASK);
        !           226:            }
        !           227:            else
        !           228:                SPDU_TYPE ("ACTIVITY END");
        !           229:            if (s -> s_mask & SMASK_MAP_SERIAL)
        !           230:                type_ssn (lp, rw, "SSN", s -> s_map_serial);
        !           231:            break;
        !           232: 
        !           233:        case SPDU_MAA: 
        !           234: #ifdef notdef
        !           235:        case SPDU_AEA:          /* aka SPDU_MAA */
        !           236: #endif
        !           237:            SPDU_TYPE ("MAJOR SYNC/ACTIVITY END ACK");
        !           238:            if (s -> s_mask & SMASK_MAA_SERIAL)
        !           239:                type_ssn (lp, rw, "SSN", s -> s_maa_serial);
        !           240:            break;
        !           241: 
        !           242:        case SPDU_RS: 
        !           243:            SPDU_TYPE ("RESYNCHRONIZE");
        !           244:            if (s -> s_mask & SMASK_RS_SET)
        !           245:                type_settings (lp, rw, s -> s_rs_settings);
        !           246:            if (s -> s_mask & SMASK_RS_TYPE)
        !           247:                type_resync (lp, rw, s -> s_rs_type);
        !           248:            if (s -> s_mask & SMASK_RS_SSN)
        !           249:                type_ssn (lp, rw, "RSN", s -> s_rs_serial);
        !           250:            break;
        !           251: 
        !           252:        case SPDU_RA: 
        !           253:            SPDU_TYPE ("RESYNCHRONIZE ACK");
        !           254:            if (s -> s_mask & SMASK_RA_SET)
        !           255:                type_settings (lp, rw, s -> s_ra_settings);
        !           256:            if (s -> s_mask & SMASK_RA_SSN)
        !           257:                type_ssn (lp, rw, "RSN", s -> s_ra_serial);
        !           258:            break;
        !           259: 
        !           260:        case SPDU_PR: 
        !           261:            SPDU_TYPE ("PREPARE");
        !           262:            type_prepare (lp, rw, s -> s_pr_type);
        !           263:            break;
        !           264: 
        !           265:        case SPDU_ER: 
        !           266:            SPDU_TYPE ("EXCEPTION REPORT");
        !           267:            break;
        !           268: 
        !           269:        case SPDU_ED: 
        !           270:            SPDU_TYPE ("EXCEPTION DATA");
        !           271:            if (s -> s_mask & SMASK_ED_REASON)
        !           272:                type_error (lp, rw, s -> s_ed_reason);
        !           273:            break;
        !           274: 
        !           275:        case SPDU_AS: 
        !           276:            SPDU_TYPE ("ACTIVITY START");
        !           277:            if (s -> s_mask & SMASK_AS_ID) {
        !           278:                (void) ll_printf (lp, "%s", rw);
        !           279:                type_info (lp, "ID/ %d", (int) s -> s_as_id.sd_len,
        !           280:                        s -> s_as_id.sd_data);
        !           281:                (void) ll_printf (lp, "\n");
        !           282:            }
        !           283:            break;
        !           284: 
        !           285:        case SPDU_AR: 
        !           286:            SPDU_TYPE ("ACTIVITY RESUME");
        !           287:            if (s -> s_mask & SMASK_AR_REF)
        !           288:                type_ref (lp, rw, &s -> s_ar_reference);
        !           289:            if (s -> s_mask & SMASK_AR_OID) {
        !           290:                (void) ll_printf (lp, "%s", rw);
        !           291:                type_info (lp, "OLD ID/ %d", (int) s -> s_ar_oid.sd_len,
        !           292:                        s -> s_ar_oid.sd_data);
        !           293:                (void) ll_printf (lp, "\n");
        !           294:            }
        !           295:            if (s -> s_mask & SMASK_AR_SSN)
        !           296:                type_ssn (lp, rw, "SSN", s -> s_ar_serial);
        !           297:            if (s -> s_mask & SMASK_AR_ID) {
        !           298:                (void) ll_printf (lp, "%s", rw);
        !           299:                type_info (lp, "ID/ %d", (int) s -> s_ar_id.sd_len,
        !           300:                        s -> s_ar_id.sd_data);
        !           301:                (void) ll_printf (lp, "\n");
        !           302:            }
        !           303:            break;
        !           304: 
        !           305:        case SPDU_AD: 
        !           306:            SPDU_TYPE ("ACTIVITY DISCARD");
        !           307:            if (s -> s_mask & SMASK_AD_REASON)
        !           308:                type_error (lp, rw, s -> s_ad_reason);
        !           309:            break;
        !           310: 
        !           311:        case SPDU_ADA: 
        !           312:            SPDU_TYPE ("ACTIVITY DISCARD ACK");
        !           313:            break;
        !           314: 
        !           315:        default: 
        !           316:            (void) ll_printf (lp, "%sCODE/ 0x%x\n", rw, s -> s_code);
        !           317:            break;
        !           318:     }
        !           319: 
        !           320:     if (s -> s_mask & SMASK_ENCLOSE)
        !           321:        type_bits (lp, rw, "ENCLOSURE", s -> s_enclose, ENCL_MASK, EMASK);
        !           322: 
        !           323:     if (s -> s_udata)
        !           324:        if (s -> s_code == SPDU_ER)
        !           325:            type_data (lp, "REFLECT", rw, s -> s_ulen, s -> s_udata);
        !           326:        else
        !           327:            if (s -> s_mask & SMASK_UDATA_PGI)
        !           328:                type_data (lp, "USER", rw, s -> s_ulen, s -> s_udata);
        !           329:            else {
        !           330:                (void) ll_printf (lp, "%sUSER INFO/ ", rw);
        !           331:                type_info (lp, "%d", s -> s_ulen, s -> s_udata);
        !           332:                (void) ll_printf (lp, "\n");
        !           333:            }
        !           334:     (void) ll_printf (lp, "%s)\n", rw);
        !           335: 
        !           336:     (void) ll_sync (lp);
        !           337: }
        !           338: 
        !           339: /*  */
        !           340: 
        !           341: static type_id (lp, type, rw, selector, len)
        !           342: LLog   *lp;
        !           343: char   *type,
        !           344:        *rw;
        !           345: char   *selector;
        !           346: int    len;
        !           347: {
        !           348:     char    buffer[BUFSIZ];
        !           349: 
        !           350:     buffer[explode (buffer, (u_char *) selector, len)] = NULL;
        !           351: 
        !           352:     (void) ll_printf (lp, "%s%s/ %d/\"%s\"\n", rw, type, len, buffer);
        !           353: }
        !           354: 
        !           355: 
        !           356: static type_ssn (lp, rw, what, ssn)
        !           357: LLog   *lp;
        !           358: char   *rw,
        !           359:        *what;
        !           360: u_long ssn;
        !           361: {
        !           362:     (void) ll_printf (lp, "%s%s/ %d\n", rw, what, ssn);
        !           363: }
        !           364: 
        !           365: 
        !           366: static type_bits (lp, rw, s, bits, mask, t)
        !           367: LLog   *lp;
        !           368: char   *rw,
        !           369:        *s,
        !           370:        *t;
        !           371: u_char  bits,
        !           372:        mask;
        !           373: {
        !           374:     (void) ll_printf (lp, "%s%s/ %s", rw, s, sprintc (bits & mask, t));
        !           375:     if (bits & ~mask)
        !           376:        (void) ll_printf (lp, ": illegal use of %s", sprintc (bits & ~mask, t));
        !           377:     (void) ll_printf (lp, "\n");
        !           378: }
        !           379: 
        !           380: 
        !           381: #define dotoken(requires,shift,bit,type) \
        !           382: { \
        !           383:     token = (settings >> shift) & ST_MASK; \
        !           384:     (void) ll_printf (lp, " %s:%s", type, token == ST_INIT_VALUE ? "initiator" \
        !           385:        : token == ST_RESP_VALUE ? "responder" \
        !           386:        : token == ST_CALL_VALUE ? "choice" \
        !           387:        : "reserved"); \
        !           388: }
        !           389: 
        !           390: static type_settings (lp, rw, settings)
        !           391: LLog   *lp;
        !           392: char   *rw;
        !           393: u_char  settings;
        !           394: {
        !           395:     int     token;
        !           396: 
        !           397:     (void) ll_printf (lp, "%sSETTINGS/", rw);
        !           398:     dotokens ();
        !           399:     (void) ll_printf (lp, "\n");
        !           400: }
        !           401: 
        !           402: #undef dotoken
        !           403: 
        !           404: 
        !           405: static type_tsdu (lp, rw, init, resp)
        !           406: LLog   *lp;
        !           407: char   *rw;
        !           408: u_short        init,
        !           409:        resp;
        !           410: {
        !           411:     (void) ll_printf (lp, "%sTSDU/ INITIATOR: %d, RESPONDER: %d\n",
        !           412:            rw, init, resp);
        !           413: }
        !           414: 
        !           415: 
        !           416: static type_ref (lp, rw, ref)
        !           417: LLog   *lp;
        !           418: char   *rw;
        !           419: struct SSAPref *ref;
        !           420: {
        !           421:     (void) ll_printf (lp, "%sREFERENCE/", rw);
        !           422:     if (ref -> sr_vlen)
        !           423:        type_info (lp, "<CALLING %d", (int) ref -> sr_calling_len,
        !           424:                ref -> sr_calling);
        !           425:     else
        !           426:        type_info (lp, " <USER %d", (int) ref -> sr_ulen, ref -> sr_udata);
        !           427:     type_info (lp, ", COMMON %d", (int) ref -> sr_clen, ref -> sr_cdata);
        !           428:     type_info (lp, ", ADDITIONAL %d", (int) ref -> sr_alen, ref -> sr_adata);
        !           429:     if (ref -> sr_vlen)
        !           430:        type_info (lp, ", CALLED %d", (int) ref -> sr_called_len,
        !           431:                ref -> sr_called);
        !           432:     (void) ll_printf (lp, ">\n");
        !           433: }
        !           434: 
        !           435: 
        !           436: static type_vrsn (lp, rw, version)
        !           437: LLog   *lp;
        !           438: char   *rw;
        !           439: u_char version;
        !           440: {
        !           441:     (void) ll_printf (lp, "%sVERSION/ 0x%x\n", rw, version);
        !           442: }
        !           443: 
        !           444: 
        !           445: static type_reason (lp, rw, reason)
        !           446: LLog   *lp;
        !           447: char   *rw;
        !           448: int    reason;
        !           449: {
        !           450:     (void) ll_printf (lp, "%sREASON/ 0x%x: %s\n", rw, reason,
        !           451:            SErrString ((int) reason));
        !           452: }
        !           453: 
        !           454: 
        !           455: static type_prepare (lp, rw, type)
        !           456: LLog   *lp;
        !           457: char   *rw;
        !           458: u_char  type;
        !           459: {
        !           460:     (void) ll_printf (lp, "%sTYPE/ ", rw);
        !           461:     switch (type) {
        !           462:        case PR_MAA: 
        !           463:            (void) ll_printf (lp, "MAA");
        !           464:            break;
        !           465:        case PR_RS: 
        !           466:            (void) ll_printf (lp, "RS");
        !           467:            break;
        !           468:        case PR_RA: 
        !           469:            (void) ll_printf (lp, "RA");
        !           470:            break;
        !           471:        case PR_AB: 
        !           472:            (void) ll_printf (lp, "AB");
        !           473:            break;
        !           474:        default: 
        !           475:            (void) ll_printf (lp, "%d: illegal value", type);
        !           476:            break;
        !           477:     }
        !           478:     (void) ll_printf (lp, "\n");
        !           479: }
        !           480: 
        !           481: 
        !           482: static type_error (lp, rw, reason)
        !           483: LLog   *lp;
        !           484: char   *rw;
        !           485: u_char  reason;
        !           486: {
        !           487:     (void) ll_printf (lp, "%sREASON/ ", rw);
        !           488:     switch (reason) {
        !           489:        case SP_NOREASON: 
        !           490:            (void) ll_printf (lp, "No specific reason stated");
        !           491:            break;
        !           492:        case SP_JEOPARDY: 
        !           493:            (void) ll_printf (lp, "User receiving ability jeopardized");
        !           494:            break;
        !           495:        case SP_SEQUENCE: 
        !           496:            (void) ll_printf (lp, "User sequence error");
        !           497:            break;
        !           498:        case SP_LOCAL: 
        !           499:            (void) ll_printf (lp, "Local SS-user error");
        !           500:            break;
        !           501:        case SP_PROCEDURAL: 
        !           502:            (void) ll_printf (lp, "Unrecoverable procedural error");
        !           503:            break;
        !           504:        case SP_DEMAND: 
        !           505:            (void) ll_printf (lp, "Demand data token");
        !           506:            break;
        !           507:        default: 
        !           508:            (void) ll_printf (lp, "%d: illegal value", reason);
        !           509:            break;
        !           510:     }
        !           511:     (void) ll_printf (lp, "\n");
        !           512: }
        !           513: 
        !           514: 
        !           515: static type_resync (lp, rw, type)
        !           516: LLog   *lp;
        !           517: char   *rw;
        !           518: u_char  type;
        !           519: {
        !           520:     (void) ll_printf (lp, "%sTYPE/ ", rw);
        !           521:     switch (type) {
        !           522:        case SYNC_RESTART: 
        !           523:            (void) ll_printf (lp, "restart");
        !           524:            break;
        !           525:        case SYNC_ABANDON: 
        !           526:            (void) ll_printf (lp, "abandon");
        !           527:            break;
        !           528:        case SYNC_SET: 
        !           529:            (void) ll_printf (lp, "set");
        !           530:            break;
        !           531:        default: 
        !           532:            (void) ll_printf (lp, "%d: illegal value", type);
        !           533:            break;
        !           534:     }
        !           535:     (void) ll_printf (lp, "\n");
        !           536: }
        !           537: 
        !           538: 
        !           539: static type_data (lp, type, rw, len, data)
        !           540: LLog   *lp;
        !           541: char   *type,
        !           542:        *rw,
        !           543:        *data;
        !           544: int    len;
        !           545: {
        !           546:     (void) ll_printf (lp, "%s%s DATA/ ", rw, type);
        !           547:     type_info (lp, "%d", len, data);
        !           548:     (void) ll_printf (lp, "\n");
        !           549: }
        !           550: 
        !           551: 
        !           552: static type_info (lp, fmt, len, data)
        !           553: LLog   *lp;
        !           554: char   *fmt,
        !           555:        *data;
        !           556: int    len;
        !           557: {
        !           558:     char    buffer[BUFSIZ];
        !           559: 
        !           560:     (void) ll_printf (lp, fmt, len);
        !           561:     if (0 < len && len < sizeof buffer / 2) {
        !           562:        buffer[explode (buffer, (u_char *) data, len)] = NULL;
        !           563:        (void) ll_printf (lp, " %s", buffer);
        !           564:     }
        !           565: }
        !           566: 
        !           567: /*  */
        !           568: 
        !           569: /* ARGSUSED */
        !           570: 
        !           571: void   text2spkt (s)
        !           572: struct ssapkt *s;
        !           573: {
        !           574:     /* NOT YET IMPLEMENTED */
        !           575: }

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