Return to ryresponder.c CVS log

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

Annotation of 43BSDReno/contrib/isode-beta/others/idist/ryresponder.c, revision 1.1

1.1     ! root        1: /* ryresponder.c - generic idempotent responder */
        !             2: 
        !             3: #ifndef        lint
        !             4: static char *rcsid = "$Header: /f/osi/others/idist/RCS/ryresponder.c,v 7.1 90/07/09 14:39:27 mrose Exp $";
        !             5: #endif
        !             6: 
        !             7: /* 
        !             8:  * $Header: /f/osi/others/idist/RCS/ryresponder.c,v 7.1 90/07/09 14:39:27 mrose Exp $
        !             9:  *
        !            10:  *
        !            11:  * $Log:       ryresponder.c,v $
        !            12:  * Revision 7.1  90/07/09  14:39:27  mrose
        !            13:  * sync
        !            14:  * 
        !            15:  * Revision 7.0  89/11/23  21:58:43  mrose
        !            16:  * Release 6.0
        !            17:  * 
        !            18:  */
        !            19: 
        !            20: #include <stdio.h>
        !            21: #include <setjmp.h>
        !            22: #include <varargs.h>
        !            23: #include "ryresponder.h"
        !            24: #include "tsap.h"              /* for listening */
        !            25: #include "Idist-ops.h"
        !            26: 
        !            27: /*    DATA */
        !            28: 
        !            29: int    debug = 0;
        !            30: 
        !            31: static LLog _pgm_log = {
        !            32:     "responder.log", NULLCP, NULLCP,
        !            33:     LLOG_FATAL | LLOG_EXCEPTIONS | LLOG_NOTICE, LLOG_FATAL, -1,
        !            34:     LLOGCLS | LLOGCRT | LLOGZER, NOTOK
        !            35: };
        !            36: LLog *pgm_log = &_pgm_log;
        !            37: 
        !            38: static char *myname = "ryresponder";
        !            39: 
        !            40: 
        !            41: static jmp_buf toplevel;
        !            42: 
        !            43: 
        !            44: static IFP     startfnx;
        !            45: static IFP     stopfnx;
        !            46: 
        !            47: int    ros_init (), ros_work (), ros_indication (), ros_lose ();
        !            48: 
        !            49: 
        !            50: extern int  errno;
        !            51: 
        !            52: /*    RESPONDER */
        !            53: 
        !            54: int    ryresponder (argc, argv, host, myservice, dispatches, ops, start, stop)
        !            55: int    argc;
        !            56: char  **argv,
        !            57:        *host,
        !            58:        *myservice;
        !            59: struct dispatch *dispatches;
        !            60: struct RyOperation *ops;
        !            61: IFP    start,
        !            62:        stop;
        !            63: {
        !            64:     struct RyOperation *op;
        !            65:     register struct dispatch   *ds;
        !            66:     AEI            aei;
        !            67:     struct TSAPdisconnect   tds;
        !            68:     struct TSAPdisconnect  *td = &tds;
        !            69:     struct RoSAPindication  rois;
        !            70:     register struct RoSAPindication *roi = &rois;
        !            71:     register struct RoSAPpreject   *rop = &roi -> roi_preject;
        !            72: 
        !            73:     if (myname = rindex (argv[0], '/'))
        !            74:        myname++;
        !            75:     if (myname == NULL || *myname == NULL)
        !            76:        myname = argv[0];
        !            77: 
        !            78:     isodetailor (myname, 0);
        !            79: 
        !            80:     if (debug = isatty (fileno (stderr)))
        !            81:         ll_dbinit (pgm_log, myname);
        !            82:     else {
        !            83:         static char  myfile[BUFSIZ];
        !            84: 
        !            85:         (void) sprintf (myfile, "%s.log",
        !            86:                         (strncmp (myname, "ros.", 4)                    
        !            87:                                     && strncmp (myname, "lpp.", 4))
        !            88:                                 || myname[4] == NULL
        !            89:                             ? myname : myname + 4);
        !            90:         pgm_log -> ll_file = myfile;
        !            91:         ll_hdinit (pgm_log, myname);
        !            92:     }
        !            93: 
        !            94:     advise (LLOG_NOTICE, NULLCP, "starting");
        !            95: 
        !            96:     if ((aei = _str2aei (host, myservice, mycontext, 0)) == NULLAEI)
        !            97:        adios (NULLCP, "unable to resolve service: %s", PY_pepy);
        !            98: 
        !            99:     if (op = findopbyop (ops, operation_Idist_transfer))
        !           100:            op -> ryo_arg_free = NULLIFP;
        !           101: 
        !           102:     for (ds = dispatches; ds -> ds_name; ds++)
        !           103:        if (RyDispatch (NOTOK, ops, ds -> ds_operation, ds -> ds_vector, roi)
        !           104:                == NOTOK)
        !           105:            ros_adios (rop, ds -> ds_name);
        !           106: 
        !           107:     startfnx = start;
        !           108:     stopfnx = stop;
        !           109: 
        !           110:     if (isodeserver (argc, argv, aei, ros_init, ros_work, ros_lose, td)
        !           111:            == NOTOK) {
        !           112:        if (td -> td_cc > 0)
        !           113:            adios (NULLCP, "isodeserver: [%s] %*.*s",
        !           114:                    TErrString (td -> td_reason),
        !           115:                    td -> td_cc, td -> td_cc, td -> td_data);
        !           116:        else
        !           117:            adios (NULLCP, "isodeserver: [%s]",
        !           118:                    TErrString (td -> td_reason));
        !           119:     }
        !           120: 
        !           121:     return 0;
        !           122: }
        !           123: 
        !           124: /*  */
        !           125: 
        !           126: static int  ros_init (vecp, vec)
        !           127: int    vecp;
        !           128: char  **vec;
        !           129: {
        !           130:     int            reply,
        !           131:            result,
        !           132:            sd;
        !           133:     struct AcSAPstart   acss;
        !           134:     register struct AcSAPstart *acs = &acss;
        !           135:     struct AcSAPindication  acis;
        !           136:     register struct AcSAPindication *aci = &acis;
        !           137:     register struct AcSAPabort   *aca = &aci -> aci_abort;
        !           138:     register struct PSAPstart *ps = &acs -> acs_start;
        !           139:     struct RoSAPindication  rois;
        !           140:     register struct RoSAPindication *roi = &rois;
        !           141:     register struct RoSAPpreject   *rop = &roi -> roi_preject;
        !           142:     PE pe[1];
        !           143: 
        !           144:     if (AcInit (vecp, vec, acs, aci) == NOTOK) {
        !           145:        acs_advise (aca, "initialization fails");
        !           146:        return NOTOK;
        !           147:     }
        !           148:     advise (LLOG_NOTICE, NULLCP,
        !           149:                "A-ASSOCIATE.INDICATION: <%d, %s, %s, %s, %d>",
        !           150:                acs -> acs_sd, oid2ode (acs -> acs_context),
        !           151:                sprintaei (&acs -> acs_callingtitle),
        !           152:                sprintaei (&acs -> acs_calledtitle), acs -> acs_ninfo);
        !           153: 
        !           154:     sd = acs -> acs_sd;
        !           155: 
        !           156:     for (vec++; *vec; vec++)
        !           157:        advise (LLOG_EXCEPTIONS, NULLCP, "unknown argument \"%s\"", *vec);
        !           158: 
        !           159:     reply = startfnx ? (*startfnx) (sd, acs, &pe[0]) : ACS_ACCEPT;
        !           160: 
        !           161:     result = AcAssocResponse (sd, reply, 
        !           162:                reply != ACS_ACCEPT ? ACS_USER_NOREASON : ACS_USER_NULL,
        !           163:                NULLOID, NULLAEI, NULLPA, NULLPC, ps -> ps_defctxresult,
        !           164:                ps -> ps_prequirements, ps -> ps_srequirements, SERIAL_NONE,
        !           165:                ps -> ps_settings, &ps -> ps_connect, pe,
        !           166:                reply != ACS_ACCEPT ? 1 : 0, aci);
        !           167: 
        !           168:     ACSFREE (acs);
        !           169: 
        !           170:     if (result == NOTOK) {
        !           171:        acs_advise (aca, "A-ASSOCIATE.RESPONSE");
        !           172:        return NOTOK;
        !           173:     }
        !           174:     if (reply != ACS_ACCEPT)
        !           175:        return NOTOK;
        !           176: 
        !           177:     if (RoSetService (sd, RoPService, roi) == NOTOK)
        !           178:        ros_adios (rop, "set RO/PS fails");
        !           179: 
        !           180:     return sd;
        !           181: }
        !           182: 
        !           183: /*  */
        !           184: 
        !           185: static int  ros_work (fd)
        !           186: int    fd;
        !           187: {
        !           188:     int            result;
        !           189:     caddr_t out;
        !           190:     struct AcSAPindication  acis;
        !           191:     struct RoSAPindication  rois;
        !           192:     register struct RoSAPindication *roi = &rois;
        !           193:     register struct RoSAPpreject   *rop = &roi -> roi_preject;
        !           194: 
        !           195:     switch (setjmp (toplevel)) {
        !           196:        case OK: 
        !           197:            break;
        !           198: 
        !           199:        default: 
        !           200:            if (stopfnx)
        !           201:                (*stopfnx) (fd, (struct AcSAPfinish *) 0);
        !           202:        case DONE:
        !           203:            (void) AcUAbortRequest (fd, NULLPEP, 0, &acis);
        !           204:            (void) RyLose (fd, roi);
        !           205:            return NOTOK;
        !           206:     }
        !           207: 
        !           208:     switch (result = RyWait (fd, NULLIP, &out, OK, roi)) {
        !           209:        case NOTOK: 
        !           210:            if (rop -> rop_reason == ROS_TIMER)
        !           211:                break;
        !           212:        case OK: 
        !           213:        case DONE: 
        !           214:            ros_indication (fd, roi);
        !           215:            break;
        !           216: 
        !           217:        default: 
        !           218:            adios (NULLCP, "unknown return from RoWaitRequest=%d", result);
        !           219:     }
        !           220: 
        !           221:     return OK;
        !           222: }
        !           223: 
        !           224: /*  */
        !           225: 
        !           226: static int ros_indication (sd, roi)
        !           227: int    sd;
        !           228: register struct RoSAPindication *roi;
        !           229: {
        !           230:     int            reply,
        !           231:            result;
        !           232: 
        !           233:     switch (roi -> roi_type) {
        !           234:        case ROI_INVOKE: 
        !           235:        case ROI_RESULT: 
        !           236:        case ROI_ERROR: 
        !           237:            adios (NULLCP, "unexpected indication type=%d", roi -> roi_type);
        !           238:            break;
        !           239: 
        !           240:        case ROI_UREJECT: 
        !           241:            {
        !           242:                register struct RoSAPureject   *rou = &roi -> roi_ureject;
        !           243: 
        !           244:                if (rou -> rou_noid)
        !           245:                    advise (LLOG_EXCEPTIONS, NULLCP, "RO-REJECT-U.INDICATION/%d: %s",
        !           246:                            sd, RoErrString (rou -> rou_reason));
        !           247:                else
        !           248:                    advise (LLOG_EXCEPTIONS, NULLCP,
        !           249:                            "RO-REJECT-U.INDICATION/%d: %s (id=%d)",
        !           250:                            sd, RoErrString (rou -> rou_reason),
        !           251:                            rou -> rou_id);
        !           252:            }
        !           253:            break;
        !           254: 
        !           255:        case ROI_PREJECT: 
        !           256:            {
        !           257:                register struct RoSAPpreject   *rop = &roi -> roi_preject;
        !           258: 
        !           259:                if (ROS_FATAL (rop -> rop_reason))
        !           260:                    ros_adios (rop, "RO-REJECT-P.INDICATION");
        !           261:                ros_advise (rop, "RO-REJECT-P.INDICATION");
        !           262:            }
        !           263:            break;
        !           264: 
        !           265:        case ROI_FINISH: 
        !           266:            {
        !           267:                register struct AcSAPfinish *acf = &roi -> roi_finish;
        !           268:                struct AcSAPindication  acis;
        !           269:                register struct AcSAPabort *aca = &acis.aci_abort;
        !           270: 
        !           271:                advise (LLOG_NOTICE, NULLCP, "A-RELEASE.INDICATION/%d: %d",
        !           272:                        sd, acf -> acf_reason);
        !           273: 
        !           274:                reply = stopfnx ? (*stopfnx) (sd, acf) : ACS_ACCEPT;
        !           275: 
        !           276:                result = AcRelResponse (sd, reply, ACR_NORMAL, NULLPEP, 0,
        !           277:                            &acis);
        !           278: 
        !           279:                ACFFREE (acf);
        !           280: 
        !           281:                if (result == NOTOK)
        !           282:                    acs_advise (aca, "A-RELEASE.RESPONSE");
        !           283:                else
        !           284:                    if (reply != ACS_ACCEPT)
        !           285:                        break;
        !           286:                longjmp (toplevel, DONE);
        !           287:            }
        !           288:        /* NOTREACHED */
        !           289: 
        !           290:        default: 
        !           291:            adios (NULLCP, "unknown indication type=%d", roi -> roi_type);
        !           292:     }
        !           293: }
        !           294: 
        !           295: /*  */
        !           296: 
        !           297: static int  ros_lose (td)
        !           298: struct TSAPdisconnect *td;
        !           299: {
        !           300:     if (td -> td_cc > 0)
        !           301:        adios (NULLCP, "TNetAccept: [%s] %*.*s",
        !           302:                TErrString (td -> td_reason), td -> td_cc, td -> td_cc,
        !           303:                td -> td_data);
        !           304:     else
        !           305:        adios (NULLCP, "TNetAccept: [%s]", TErrString (td -> td_reason));
        !           306: }
        !           307: 
        !           308: /*    ERRORS */
        !           309: 
        !           310: void   ros_adios (rop, event)
        !           311: register struct RoSAPpreject *rop;
        !           312: char   *event;
        !           313: {
        !           314:     ros_advise (rop, event);
        !           315: 
        !           316:     cleanup ();
        !           317: 
        !           318:     longjmp (toplevel, NOTOK);
        !           319: }
        !           320: 
        !           321: 
        !           322: void   ros_advise (rop, event)
        !           323: register struct RoSAPpreject *rop;
        !           324: char   *event;
        !           325: {
        !           326:     char    buffer[BUFSIZ];
        !           327: 
        !           328:     if (rop -> rop_cc > 0)
        !           329:        (void) sprintf (buffer, "[%s] %*.*s", RoErrString (rop -> rop_reason),
        !           330:                rop -> rop_cc, rop -> rop_cc, rop -> rop_data);
        !           331:     else
        !           332:        (void) sprintf (buffer, "[%s]", RoErrString (rop -> rop_reason));
        !           333: 
        !           334:     advise (LLOG_EXCEPTIONS, NULLCP, "%s: %s", event, buffer);
        !           335: }
        !           336: 
        !           337: /*  */
        !           338: 
        !           339: void   acs_advise (aca, event)
        !           340: register struct AcSAPabort *aca;
        !           341: char   *event;
        !           342: {
        !           343:     char    buffer[BUFSIZ];
        !           344: 
        !           345:     if (aca -> aca_cc > 0)
        !           346:        (void) sprintf (buffer, "[%s] %*.*s",
        !           347:                AcErrString (aca -> aca_reason),
        !           348:                aca -> aca_cc, aca -> aca_cc, aca -> aca_data);
        !           349:     else
        !           350:        (void) sprintf (buffer, "[%s]", AcErrString (aca -> aca_reason));
        !           351: 
        !           352:     advise (LLOG_EXCEPTIONS, NULLCP, "%s: %s (source %d)", event, buffer,
        !           353:                aca -> aca_source);
        !           354: }
        !           355: 
        !           356: /*  */
        !           357: 
        !           358: #ifndef        lint
        !           359: 
        !           360: void   adios (va_alist)
        !           361: va_dcl
        !           362: {
        !           363:     char   *what;
        !           364:     va_list ap;
        !           365: 
        !           366:     va_start (ap);
        !           367: 
        !           368:     _ll_log (pgm_log, LLOG_FATAL, ap);
        !           369: 
        !           370:     va_end (ap);
        !           371: 
        !           372:     cleanup ();
        !           373: 
        !           374:     _exit (1);
        !           375: }
        !           376: #else
        !           377: /* VARARGS2 */
        !           378: 
        !           379: void   adios (what, fmt)
        !           380: char   *what,
        !           381:        *fmt;
        !           382: {
        !           383:     adios (what, fmt);
        !           384: }
        !           385: #endif
        !           386: 
        !           387: 
        !           388: #ifndef        lint
        !           389: void   advise (va_alist)
        !           390: va_dcl
        !           391: {
        !           392:     int            code;
        !           393:     va_list ap;
        !           394: 
        !           395:     va_start (ap);
        !           396: 
        !           397:     code = va_arg (ap, int);
        !           398: 
        !           399:     _ll_log (pgm_log, code, ap);
        !           400: 
        !           401:     va_end (ap);
        !           402: }
        !           403: 
        !           404: #else
        !           405: /* VARARGS */
        !           406: 
        !           407: void   advise (code, what, fmt)
        !           408: char   *what,
        !           409:        *fmt;
        !           410: int    code;
        !           411: {
        !           412:     advise (code, what, fmt);
        !           413: }
        !           414: #endif
        !           415: 
        !           416: 
        !           417: 
        !           418: #ifndef        lint
        !           419: void   ryr_advise (va_alist)
        !           420: va_dcl
        !           421: {
        !           422:     va_list ap;
        !           423: 
        !           424:     va_start (ap);
        !           425: 
        !           426:     _ll_log (pgm_log, LLOG_NOTICE, ap);
        !           427: 
        !           428:     va_end (ap);
        !           429: }
        !           430: #else
        !           431: /* VARARGS2 */
        !           432: void   ryr_advise (what, fmt)
        !           433: char   *what,
        !           434:        *fmt;
        !           435: {
        !           436:     ryr_advise (what, fmt);
        !           437: }
        !           438: #endif
        !           439: 
        !           440: #ifdef lint
        !           441: /* VARARGS1 */
        !           442: note (fmt)
        !           443: char   *fmt;
        !           444: {
        !           445:        note (fmt);
        !           446: }
        !           447: 
        !           448: #else
        !           449: note (va_alist)
        !           450: va_dcl
        !           451: {
        !           452:        char    buffer[BUFSIZ];
        !           453:        struct type_Idist_IA5List **ia5p;
        !           454:        va_list ap;
        !           455: 
        !           456:        va_start (ap);
        !           457: 
        !           458:        _asprintf (buffer, NULLCP, ap);
        !           459: 
        !           460:        addtoia5 (buffer, strlen (buffer));
        !           461: 
        !           462:        va_end (ap);
        !           463: }
        !           464: #endif
        !           465: 
        !           466: #ifdef lint
        !           467: /* VARARGS2 */
        !           468: nadvise (what, fmt)
        !           469: char   *what, *fmt;
        !           470: {
        !           471:        nadvise (what, fmt);
        !           472: }
        !           473: #else
        !           474: nadvise (va_alist)
        !           475: va_dcl
        !           476: {
        !           477:        va_list ap;
        !           478:        char    buf[BUFSIZ], *cp;
        !           479:        extern  char *host;
        !           480: 
        !           481:        va_start (ap);
        !           482: 
        !           483:        (void) sprintf (buf, "%s (%s): ", myname, host);
        !           484:        cp = buf + strlen (buf);
        !           485: 
        !           486:        asprintf (cp, ap);
        !           487: 
        !           488:        addtoia5 (buf, strlen (buf));
        !           489: 
        !           490:        va_end (ap);
        !           491: }
        !           492: #endif

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