![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vtpm.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / vt|
Return to vtpm.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / vt |
1.1 root 1: /* vtpm.c - VTPM: FSM */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/vt/RCS/vtpm.c,v 7.0 89/11/23 22:31:57 mrose Rel $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/vt/RCS/vtpm.c,v 7.0 89/11/23 22:31:57 mrose Rel $
9: *
10: *
11: * $Log: vtpm.c,v $
12: * Revision 7.0 89/11/23 22:31:57 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 "vtpm.h"
29: #include "eventmsg.h"
30: #include "sector1.h"
31:
32: #undef PEPYPARM
33: #define PEPYPARM int *
34:
35: int cmode;
36: extern int sd; /*Session descriptor for this association*/
37: extern int debug;
38:
39: struct SSAPref sfs;
40: struct SSAPref *sf;
41: struct PSAPaddr *pa;
42: struct AcSAPconnect accs;
43: struct AcSAPconnect *acc;
44: struct AcSAPrelease acrs;
45: struct AcSAPrelease *acr;
46: struct AcSAPindication acis;
47: struct AcSAPindication *aci;
48: struct AcSAPabort *aca;
49: AEI aei;
50: OID ctx,
51: pci;
52:
53: struct AcSAPstart acss;
54: struct AcSAPstart *acs;
55: struct PSAPstart *ps;
56: struct PSAPindication pi;
57: struct PSAPdata px;
58: struct PSAPfinish *pf;
59:
60: /****************************************************************************/
61: /* GET EVENT - attempt to read a PDU from the presentation connection */
62: /* designated by "sd", determine */
63: /* which imcoming event has ocurred, */
64: /* and process the event with "do_event" */
65: /* */
66: /* A non-blocking read is done and OK is returned if there */
67: /* is nothing to read. */
68: /* */
69: /* PARAMETERS - */
70: /* FD - the presentation ID for the connection to read from */
71: /* */
72: /* PE - a pointer to the presentation element that is read */
73: /* (note that what is passed is a pointer to a pointer to */
74: /* data structure so that the address of the PE */
75: /* that is read can be returned in this parameter) */
76: /* */
77: /* RETURNS - the number of the incoming event associated with reading */
78: /* this PE from the network */
79: /****************************************************************************/
80:
81: int
82: get_event(dd, pe)
83: int dd;
84: PE *pe;
85: {
86: int result, event;
87: PE nullpe;
88:
89: result = PReadRequest(dd, &px, OK, &pi);
90: switch (result) {
91: case NOTOK:
92: if (debug)
93: advise(LLOG_EXCEPTIONS,NULLCP, "P-READ REQUEST returned NOTOK");
94: return(NOTOK);
95: case DONE:
96: if (pi.pi_type == PI_FINISH) {
97: pf = &pi.pi_finish;
98: event = RLQ;
99: nullpe = NULLPE;
100: pe = &nullpe;
101: }
102: else if(pi.pi_type == PI_SYNC)
103: {
104: return( pn_ind(dd, &pi.pi_sync)) ;
105: }
106: else
107: adios(NULLCP, "PReadRequest returned DONE, but event unknown (%d)",pi.pi_type);
108: break;
109: case OK:
110: if (px.px_ninfo > 1)
111: adios(NULLCP, "read more than one PE from network!\n");
112: pe = &(px.px_info[0]);
113:
114: /* we are assuming here that you can only get one PDU per P-DATA.
115: */
116: PLOG (vt_log, print_VT_PDUs, *pe, NULLCP, 1);
117: if ((*pe)->pe_class != PE_CLASS_CONT)
118: adios(NULLCP,"read pe of class %d", (*pe)->pe_class);
119: switch((*pe)->pe_id) {
120: case (ASQ_PDU):
121: {
122: if (debug)
123: advise(LLOG_DEBUG,NULLCP, "got ASQ_PDU");
124:
125: event = ASQ;
126: }
127: case ASR_PDU:
128: {
129: if (debug)
130: advise(LLOG_DEBUG,NULLCP, "got ASR_PDU");
131:
132: event = ASR;
133: }
134: case AUQ_PDU:
135: if (debug)
136: advise(LLOG_DEBUG,NULLCP, "got AUQ_PDU");
137: event = AUQ;
138: break;
139: case DAQ_PDU:
140: if (debug)
141: advise(LLOG_DEBUG,NULLCP, "got DAQ_PDU");
142: event = DAQ;
143: break;
144: case DLQ_PDU:
145: if (debug)
146: advise(LLOG_DEBUG,NULLCP, "got DLQ_PDU");
147:
148: event = DLQ;
149: break;
150:
151: case NDQ_PDU:
152: {
153: if (debug)
154: advise(LLOG_DEBUG,NULLCP, "got NDQ_PDU");
155:
156: event = NDQ_tr; /*See comment below*/
157:
158: /* We're supposed to find out if the NDQ contains an
159: update to a triggered control object or not to determine
160: what kind of event we have. Right now we'll assume that
161: we do have such an update in all cases. Note that this may
162: be a problem if we use quarantine delivery control in the
163: future.
164:
165: for each update, find out if the update is for a display object
166: or for a control object. if it's a control object get the name
167: of it and find out if it has a trigger
168:
169: */
170: break;
171: }
172:
173: case UDQ_PDU:
174: {
175: event = UDQ;
176: break;
177: }
178:
179: case HDQ_PDU:
180: {
181: if(debug) advise(LLOG_NOTICE,NULLCP,"Got HDQ");
182: event = HDQ;
183: break;
184: }
185:
186: case RLR_PDU:
187: event = RLR;
188: break;
189:
190: default:
191: adios(NULLCP,"unknown PDU type %d", (*pe)->pe_id);
192: }
193: }
194: return(do_event(event,*pe));
195: }
196:
197:
198:
199: #define SECTORS 6
200:
201: /* number of states in each sector */
202:
203: unsigned max_state[SECTORS] = { 0, 13, 0, 0, 0, 10};
204:
205: int (*s0[])() = {
206: NULL
207: };
208:
209: int (*s1[])() = {
210: s1_01, /* states in the first sector */
211: s1_02B,
212: s1_02S,
213: s1_03B,
214: s1_03S,
215: s1_10B,
216: s1_10N,
217: s1_10T,
218: s1_50B,
219: s1_51Q,
220: s1_51R,
221: s1_51N,
222: s1_51T
223: };
224:
225: int (*s2[])() = {
226: NULL
227: };
228:
229: int (*s3[])() = {
230: NULL
231: };
232:
233: int (*s4[])() = {
234: NULL
235: };
236:
237: int (*s5[])() = {
238: s5_400B,
239: s5_402B,
240: s5_420B,
241: s5_422B,
242: s5_40N,
243: s5_40T,
244: s5_42N,
245: s5_42T,
246: s5_61,
247: s5_62
248: };
249:
250: int ((**sectors[])()) = {s0, s1, s2, s3, s4, s5};
251:
252:
253: unsigned state = 0,
254: sector = 1;
255:
256: do_event(event, pe)
257: int event;
258: PE pe;
259: {
260: if (debug)
261: advise(LLOG_DEBUG,NULLCP,
262: "in do_event, sector is %d, state is %d, event is %d (%s)",
263: sector, state, event,
264: event >= 0
265: && event < sizeof eventname/sizeof eventname[0]
266: ? eventname[event] : "INVALID");
267: if (sector >= SECTORS || state >= max_state[sector])
268: return(NOTOK);
269: return(sectors[sector][state](event, pe));
270: }
271:
272: /* ARGSUSED */
273: pn_ind(dd, psync) /* sync indications */
274: int dd;
275: struct PSAPsync *psync;
276: {
277: switch(psync->pn_type)
278: {
279: case SN_MAJORIND:
280: advise(LLOG_DEBUG,NULLCP, "vt: got SN_MAJORIND");
281: break;
282: case SN_MAJORCNF:
283: advise(LLOG_DEBUG,NULLCP, "vt: got SN_MAJORCNF");
284: break;
285: case SN_MINORIND:
286: advise(LLOG_DEBUG,NULLCP, "vt: got SN_MINORIND");
287: break;
288: case SN_MINORCNF:
289: advise(LLOG_DEBUG,NULLCP, "vt: got SN_MINORCNF");
290: break;
291: case SN_RESETIND:
292: /* advise(LLOG_DEBUG,NULLCP, "vt: resetind: SN_RESETIND"); */
293: if(psync->pn_options != SYNC_RESTART)
294: adios(NULLCP,"resetind: bad options params");
295: if(psync->pn_ninfo > 0)
296: return( do_event(BKQ,psync->pn_info[0]));
297: else return( do_event(BKQ,NULLPE));
298: case SN_RESETCNF:
299: /* advise(LLOG_DEBUG,NULLCP, "vt: got SN_RESETCNF\n"); */
300: if(psync->pn_options != SYNC_RESTART)
301: adios(NULLCP,"resetind: bad options params");
302: if(psync->pn_ninfo > 0)
303: return( do_event(BKR,psync->pn_info[0]));
304: else return( do_event(BKR,NULLPE));
305: default:
306: adios(NULLCP,"received bad sync type");
307: }
308: PNFREE(psync);
309: return(NOTOK);
310: }
311:
312:
313:
314:
315: /*****************************************************************************/
316: /* P_DATA - send a PDU via PDataRequest */
317: /* */
318: /* RETURNS - OK or exits on error */
319: /* */
320: /* PARAMETERS - */
321: /* PDU - a PE containing the PDU to be sent */
322: /* */
323: /* CLASSIFICATION - utility function for VTPM (used only in processing */
324: /* outgoing events that are mapped to P_DATA) */
325: /* */
326: /*****************************************************************************/
327:
328: p_data(pdu)
329: PE pdu;
330: {
331:
332: PLOG (vt_log, print_VT_PDUs, pdu, NULLCP, 0);
333:
334: if (PDataRequest(sd, &pdu, 1, &pi) != OK)
335: ps_adios (&pi.pi_abort, "P-DATA.REQUEST");
336: pe_free(pdu);
337: return(OK);
338: }
339:
340:
341: /****************************************************************************/
342: /* P_MAJOR_SYNC.REQUEST - send a PDU via PMajSyncRequest */
343: /* */
344: /* RETURNS - OK or exits on error */
345: /* */
346: /* PARAMETERS - */
347: /* PDU - a PE containing the PDU to be sent */
348: /* */
349: /* CLASSIFICATION - utility function for VTPM (used only in processing */
350: /* outgoing events that are mapped to P_MAJOR_SYNC.REQUEST) */
351: /* */
352: /****************************************************************************/
353:
354: p_maj_sync_req(pdu)
355: PE pdu;
356: {
357: long ssn;
358:
359: PLOG (vt_log, print_VT_PDUs, pdu, NULLCP, 0);
360:
361: if (PMajSyncRequest(sd, &ssn, &pdu, 1, &pi) != OK)
362: ps_adios (&pi.pi_abort, "P-MAJOR-SYNC.REQUEST");
363: return(OK);
364: }
365:
366:
367: /****************************************************************************/
368: /* P_MAJOR_SYNC.RESPONSE - send a PDU via PMajSyncResponse */
369: /* */
370: /* RETURNS - OK or exits on error */
371: /* */
372: /* PARAMETERS - */
373: /* PDU - a PE containing the PDU to be sent */
374: /* */
375: /* CLASSIFICATION - utility function for VTPM (used only in processing */
376: /* outgoing events that are mapped to P_MAJOR_SYNC.RESPONSE)*/
377: /* */
378: /****************************************************************************/
379:
380: p_maj_sync_resp(pdu)
381: PE pdu;
382: {
383: PLOG (vt_log, print_VT_PDUs, pdu, NULLCP, 0);
384:
385: if (PMajSyncResponse(sd, &pdu, 1, &pi) != OK)
386: ps_adios (&pi.pi_abort, "P-MAJOR-SYNC.RESPONSE");
387: return(OK);
388: }
389:
390:
391: /***************************************************************************/
392: /* P_TYPED_DATA - send a PDU via PTypedRequest */
393: /* */
394: /* RETURNS - OK or exits on error */
395: /* */
396: /* PARAMETERS - */
397: /* PDU - a PE containing the PDU to be sent */
398: /* */
399: /* CLASSIFICATION - utility function for VTPM (used only in processing */
400: /* outgoing events that are mapped to P_TYPED_DATA) */
401: /* */
402: /***************************************************************************/
403:
404: p_typed_data(pdu)
405: PE pdu;
406: {
407:
408: PLOG (vt_log, print_VT_PDUs, pdu, NULLCP, 0);
409:
410: if (PTypedRequest(sd, &pdu, 1, &pi) != OK)
411: ps_adios (&pi.pi_abort, "P-TYPED-DATA.REQUEST");
412: return(OK);
413: }
414:
415: /*****************************************************************************/
416: /* P_RESYNCHRONIZE.REQUEST - send a PDU via PReSyncRequest */
417: /* */
418: /* RETURNS - OK or exits on error */
419: /* */
420: /* PARAMETERS - */
421: /* PDU - a PE containing the (break) PDU to be sent */
422: /* */
423: /* CLASSIFICATION - utility function for VTPM (used only in processing */
424: /* outgoing events that are mapped to P_RESYNC.REQUEST) */
425: /*****************************************************************************/
426:
427: p_resync_req(pdu,type)
428: PE pdu;
429: int type;
430: {
431:
432: long ssn = 0; /* should be made a global at some time */
433: int settings = ST_INIT_VALUE;
434:
435: #define VTKP_REQ 0x00 /* setting values, see ssap.h */
436: #define VTKP_ACC 0x15
437: #define VTKP_CHO 0x2a
438:
439: PLOG (vt_log, print_VT_PDUs, pdu, NULLCP, 0);
440:
441: if (PReSyncRequest(sd, type, ssn, settings, &pdu, 1, &pi) != OK)
442: /* if (PReSyncRequest(sd, type, 0, 0, (PE *)NULL, 0, &pi) != OK) */
443: ps_adios (&pi.pi_abort, "P-RESYNCHRONIZE.REQUEST");
444: return(OK);
445: }
446:
447:
448: /****************************************************************************/
449: /* P_RESYNC.RESPONSE - send a PDU via PReSyncResponse */
450: /* */
451: /* RETURNS - OK or exits on error */
452: /* */
453: /* PARAMETERS - */
454: /* PDU - a PE containing the PDU to be sent */
455: /* */
456: /* CLASSIFICATION - utility function for VTPM (used only in processing */
457: /* outgoing events that are mapped to P_RESYNC.RESPONSE) */
458: /* */
459: /****************************************************************************/
460:
461: p_resync_resp(pdu)
462: PE pdu;
463: {
464:
465: long ssn = 0; /* should be made a global at some time */
466: int settings = ST_INIT_VALUE;
467: PLOG (vt_log, print_VT_PDUs, pdu, NULLCP, 0);
468:
469: if (PReSyncResponse(sd, ssn, settings, &pdu, 1, &pi) != OK)
470: ps_adios (&pi.pi_abort, "P-RESYNCHRONIZE.RESPONSE");
471: return(OK);
472: }
473:
474:
475:
476: /****************************************************************************/
477: /* ASR - generate an ASR event. (that is send an ASR PDU which is */
478: /* passed in as a parameter as user data on the AcAssocResponse.)*/
479: /* */
480: /* PARAMETERS: PE - a vt ASR PDU */
481: /* status (SUCCESS or FAILURE) */
482: /* */
483: /* RETURNS: OK */
484: /****************************************************************************/
485:
486: asr(pe,status)
487: PE pe;
488: int status;
489: {
490:
491: /* include "pe" as user data on the AcAssocResponse
492: */
493: struct PSAPctxlist *pl = &ps->ps_ctxlist;
494: int s_requirements;
495: long isn;
496: int reason, i;
497:
498: if (debug > 2) {
499: for(i=0; i<pl->pc_nctx; i++)
500: advise(LLOG_DEBUG,NULLCP," ctx %d: %d %s %d",
501: i,pl->pc_ctx[i].pc_id,sprintoid(pl->pc_ctx[i].pc_asn),
502: pl->pc_ctx[i].pc_result);
503:
504: }
505: if (debug) {
506: advise(LLOG_DEBUG,NULLCP, "in asr.\n");
507: advise(LLOG_DEBUG,NULLCP, "about to call AcAssocResp, sd is %d, pe->pe_id is %d\n", sd, pe->pe_id);
508: }
509:
510: if(status == SUCCESS)
511: {
512: status = ACS_ACCEPT;
513: reason = ACS_USER_NULL;
514: }
515: else
516: {
517: status = ACS_PERMANENT;
518: reason = ACS_USER_NOREASON;
519: }
520: s_requirements = SR_DUPLEX | SR_RESYNC | SR_TYPEDATA;
521: isn = 0;
522: pe -> pe_context = 1;
523: if (AcAssocResponse (sd, status, reason, NULLOID, NULLAEI,
524: NULLPA,
525: &ps->ps_ctxlist,
526: ps->ps_defctxresult, ps->ps_prequirements, s_requirements,isn,
527: ps->ps_settings, &ps->ps_connect, &pe, 1, aci) == NOTOK)
528: acs_adios (aca, "A-ASSOCIATE.RESPONSE");
529:
530: if (debug)
531: advise(LLOG_DEBUG,NULLCP, "sent AcAssociate Response\n");
532: return(OK);
533: }
534:
535:
536:
537: send_bad_asr(reason) /*Compose and send ASR with result = failure. Encode
538: ASR-FailureReason using the reason parameter
539: (0 means no reason).
540: */
541:
542: int reason;
543: {
544:
545: PE asr_pe;
546: ASR_MSG ud;
547:
548: bzero ((char *) &ud, sizeof ud);
549: if(reason)
550: {
551: ud.valid_reason = 1;
552: ud.reason.type = 1;
553: ud.reason.provider_reason = reason;
554: }
555: else ud.valid_reason = 0;
556: ud.result = 0; /*Failure code*/
557: ud.valid_imp = 0;
558: ud.valid_coll = 0;
559: ud.valid_arg_list = 0;
560: ud.version.bitstring = 0x00;
561: ud.version.bitcount = 5;
562: if(build_ASRPDU_ASRpdu(&asr_pe,1,NULL,NULLCP,(PEPYPARM)&ud) == NOTOK)
563: adios (NULLCP, "ASR build failure (%s)", PY_pepy);
564:
565: return(asr(asr_pe,FAILURE)); /*Send the PDU thru Association control*/
566: }
567:
568:
569: send_rlr(pe) /*Send RLR (Release Response) PDU to peer. The RLR is
570: built by vrelrsp(). It is sent by a call to Association
571: Control.
572: */
573: PE pe;
574: {
575: pe -> pe_context = 1;
576: if(AcRelResponse(sd,ACS_ACCEPT,ACR_NORMAL,&pe,1,aci) == NOTOK)
577: acs_adios (&aci->aci_abort, "A-RELEASE.RESPONSE");
578: }
579:
580:
581: clear_vte() /*Clear VT Environment. */
582: {
583:
584: /*Nothing to do for now since we have no formalized environment
585: and we exit VTP when association ends.
586: */
587: }
588:
589:
590: vgvt_ind() /*Indication to User that peer has given the token*/
591: {
592:
593: /*Don't know how to indicate this to user yet*/
594: }
595:
596:
597: vrtq_ind() /*Indicate to User that peer has requested token*/
598: {
599:
600: /*Don't know how to give indication to user.
601: Synchronous? Asynch interrupt??? */
602: }
603:
604:
605: give_token() /*Transfer Token to peer. For VTP, all tokens are given
606: at once so no need to discriminate between them.
607: */
608: {
609:
610: int vt_tokens;
611: struct PSAPindication vt_pi;
612:
613: vt_tokens = ST_RLS_TOKEN;
614:
615: if(PGTokenRequest(sd,vt_tokens,&vt_pi) == NOTOK
616: && vt_pi.pi_abort.pa_reason != PC_OPERATION)
617: ps_adios (&vt_pi.pi_abort, "P-GIVE-TOKENS.REQUEST");
618: }
619:
620:
621: request_token() /*Request Tokens from peer*/
622: {
623:
624: int vt_tokens;
625: struct PSAPindication vt_pi;
626:
627: vt_tokens = ST_RLS_TOKEN;
628:
629: if(PPTokenRequest(sd,vt_tokens,NULLPEP,0,&vt_pi) == NOTOK
630: && vt_pi.pi_abort.pa_reason != PC_OPERATION)
631: ps_adios (&vt_pi.pi_abort, "P-PLEASE-TOKENS.REQUEST");
632: }
633:
634: send_all() /*TEMP -- Should be supplied by Sector 5 actions*/
635: {
636: advise(LLOG_DEBUG,NULLCP, "send_all dummy routine");
637: }
638:
639: /* */
640:
641: void acs_adios (aa, event)
642: register struct AcSAPabort *aa;
643: char *event;
644: {
645: acs_advise (aa, event);
646:
647: finalbye ();
648:
649: _exit (1);
650: }
651:
652:
653: static void acs_advise (aa, event)
654: register struct AcSAPabort *aa;
655: char *event;
656: {
657: char buffer[BUFSIZ];
658:
659: if (aa -> aca_cc > 0)
660: (void) sprintf (buffer, "[%s] %*.*s",
661: AcErrString (aa -> aca_reason),
662: aa -> aca_cc, aa -> aca_cc, aa -> aca_data);
663: else
664: (void) sprintf (buffer, "[%s]", AcErrString (aa -> aca_reason));
665:
666: advise (LLOG_NOTICE,NULLCP, "%s: %s (source %d)", event, buffer,
667: aa -> aca_source);
668: }
669:
670:
671: static void ps_adios (pab, event)
672: register struct PSAPabort *pab;
673: char *event;
674: {
675: ps_advise (pab, event);
676:
677: finalbye ();
678:
679: _exit (1);
680: }
681:
682:
683: static void ps_advise (pab, event)
684: register struct PSAPabort *pab;
685: char *event;
686: {
687: char buffer[BUFSIZ];
688:
689: if (pab -> pa_cc > 0)
690: (void) sprintf (buffer, "[%s] %*.*s",
691: PErrString (pab -> pa_reason),
692: pab -> pa_cc, pab -> pa_cc, pab -> pa_data);
693: else
694: (void) sprintf (buffer, "[%s]", PErrString (pab -> pa_reason));
695:
696: advise (LLOG_NOTICE,NULLCP, "%s: %s%s", event, buffer,
697: pab -> pa_peer ? " (peer initiated)" : "");
698: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.