![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to psaprelease1.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 / psap2-lpp|
Return to psaprelease1.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / psap2-lpp |
1.1 root 1: /* psaprelease1.c - PPM: initiate release */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/psap2-lpp/RCS/psaprelease1.c,v 7.2 90/07/01 21:05:28 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/psap2-lpp/RCS/psaprelease1.c,v 7.2 90/07/01 21:05:28 mrose Exp $
9: *
10: * Contributed by The Wollongong Group, Inc.
11: *
12: *
13: * $Log: psaprelease1.c,v $
14: * Revision 7.2 90/07/01 21:05:28 mrose
15: * pepsy
16: *
17: * Revision 7.1 89/12/01 08:35:28 mrose
18: * touch-up
19: *
20: * Revision 7.0 89/11/23 22:15:56 mrose
21: * Release 6.0
22: *
23: */
24:
25: /*
26: * NOTICE
27: *
28: * Acquisition, use, and distribution of this module and related
29: * materials are subject to the restrictions of a license agreement.
30: * Consult the Preface in the User's Manual for the full terms of
31: * this agreement.
32: *
33: */
34:
35:
36: /* LINTLIBRARY */
37:
38: #include <stdio.h>
39: #include <signal.h>
40: #define LPP
41: #include "PS-types.h"
42: #include "ppkt.h"
43: #include "tailor.h"
44:
45: /* P-RELEASE.REQUEST */
46:
47: int PRelRequest (sd, data, ndata, secs, pr, pi)
48: int sd;
49: PE *data;
50: int ndata;
51: int secs;
52: struct PSAPrelease *pr;
53: struct PSAPindication *pi;
54: {
55: SBV smask;
56: int result;
57: register struct psapblk *pb;
58:
59: if (data == NULL || ndata <= 0 || data[0] == NULLPE || ndata > NPDATA_PS)
60: return psaplose (pi, PC_PARAMETER, NULLCP, "bad release user data");
61: if (data[0] -> pe_context != PCI_ACSE)
62: return psaplose (pi, PC_PARAMETER, NULLCP,
63: "wrong context for release user data");
64: if (secs != NOTOK)
65: return psaplose (pi, PC_PARAMETER, NULLCP,
66: "asynchronous release not supported");
67: missingP (pr);
68: missingP (pi);
69:
70: smask = sigioblock ();
71:
72: psapPsig (pb, sd);
73:
74: if ((result = PRelRequestAux (pb, data[0], pr, pi)) == DONE)
75: result = OK;
76: else
77: freepblk (pb);
78:
79: (void) sigiomask (smask);
80:
81: return result;
82: }
83:
84: /* */
85:
86: static int PRelRequestAux (pb, data, pr, pi)
87: register struct psapblk *pb;
88: PE data;
89: struct PSAPrelease *pr;
90: struct PSAPindication *pi;
91: {
92: int result;
93: PE pe;
94: PS ps;
95: struct type_PS_PDUs *pdu;
96: register struct type_PS_ReleaseRequest__PDU *rr;
97:
98: pdu = NULL;
99: if ((rr = (struct type_PS_ReleaseRequest__PDU *) malloc (sizeof *rr))
100: == NULL) {
101: result = psaplose (pi, PC_CONGEST, NULLCP, "out of memory");
102: goto out;
103: }
104: rr -> reference = pb -> pb_reliability == LOW_QUALITY ? pb -> pb_reference
105: : NULLRF;
106: rr -> user__data = data;
107:
108: result = encode_PS_ReleaseRequest__PDU (&pb -> pb_retry, 1, 0, NULLCP, rr);
109:
110: rr -> reference = NULL;
111: rr -> user__data = NULLPE;
112: free_PS_ReleaseRequest__PDU (rr);
113: rr = NULL;
114:
115: if (result == NOTOK) {
116: (void) psaplose (pi, PC_CONGEST, NULLCP, "error encoding PDU: %s",
117: PY_pepy);
118: goto out;
119: }
120:
121: switch (pb -> pb_reliability) {
122: case HIGH_QUALITY:
123: default:
124: PLOGP (psap2_log,PS_PDUs, pb -> pb_retry,
125: "ReleaseRequest-PDU", 0);
126:
127: result = pe2ps (ps = pb -> pb_stream, pb -> pb_retry);
128:
129: pe_free (pb -> pb_retry);
130: pb -> pb_retry = NULLPE;
131:
132: if (result == NOTOK
133: || (pb -> pb_response = ps2pe (ps)) == NULLPE) {
134: result = pslose (pi, ps -> ps_errno);
135: goto out;
136: }
137: break;
138:
139: case LOW_QUALITY:
140: pb -> pb_tries = pb -> pb_maxtries;
141:
142: again: ;
143: for (;;) {
144: switch ((*pb -> pb_retryfnx) (pb, PC_SESSION, pi)) {
145: case NOTOK:
146: result = NOTOK;
147: goto out;
148:
149: case OK:
150: continue;
151:
152: case DONE:
153: default:
154: break;
155: }
156: break;
157: }
158:
159: pdu = NULL;
160: break;
161: }
162:
163: result = decode_PS_PDUs (pb -> pb_response, 1, NULLIP, NULLVP, &pdu);
164:
165: #ifdef DEBUG
166: if (result == OK && (psap2_log -> ll_events & LLOG_PDUS))
167: pvpdu (psap2_log, print_PS_PDUs_P, pb -> pb_response, "PDU", 1);
168: #endif
169:
170: if (result == NOTOK) {
171: if (pb -> pb_reliability == LOW_QUALITY)
172: goto bad_ref;
173:
174: (void) ppktlose (pb, pi, PC_UNRECOGNIZED, NULLRF, NULLCP,
175: "error decoding PDU: %s", PY_pepy);
176: goto out;
177: }
178:
179: switch (pdu -> offset) {
180: case type_PS_PDUs_releaseResponse:
181: {
182: register struct type_PS_ReleaseResponse__PDU *rp =
183: pdu -> un.releaseResponse;
184:
185: if (pb -> pb_reliability == LOW_QUALITY
186: && refcmp (pb -> pb_reference, rp -> reference)) {
187: (void) ppktlose (pb, pi, PC_SESSION, rp -> reference,
188: NULLCP, "reference mismatch");
189:
190: bad_ref: ;
191: if (pdu)
192: free_PS_PDUs (pdu);
193: goto again;
194: }
195:
196: pe = rp -> user__data, rp -> user__data = NULLPE;
197:
198: pr -> pr_affirmative = 1;
199: (pr -> pr_info[0] = pe) -> pe_context = PCI_ACSE;
200: pr -> pr_ninfo = 1;
201:
202: result = OK;
203: }
204: break;
205:
206: case type_PS_PDUs_abort:
207: {
208: register struct PSAPabort *pa = &pi -> pi_abort;
209: register struct type_PS_Abort__PDU *ab = pdu -> un.abort;
210:
211: if (pb -> pb_reliability == LOW_QUALITY
212: && refcmp (pb -> pb_reference, ab -> reference))
213: goto bad_ref;
214:
215: if (ab -> reason) {
216: switch (ab -> reason -> parm) {
217: case int_PS_Abort__reason_reason__not__specified:
218: default:
219: result = PC_NOTSPECIFIED;
220: break;
221:
222: case int_PS_Abort__reason_unrecognized__ppdu:
223: case int_PS_Abort__reason_unexpected__ppdu:
224: case int_PS_Abort__reason_unrecognized__ppdu__parameter:
225: result = PC_UNRECOGNIZED
226: + (ab -> reason -> parm
227: - int_PS_Abort__reason_unrecognized__ppdu);
228: break;
229:
230: case int_PS_Abort__reason_invalid__ppdu__parameter:
231: result = PC_INVALID;
232: break;
233:
234: case int_PS_Abort__reason_reference__mismatch:
235: result = PC_SESSION;
236: break;
237: }
238: result = psaplose (pi, result, NULLCP, NULLCP);
239: break;
240: }
241: pe = ab -> user__data, ab -> user__data = NULLPE;
242:
243: pi -> pi_type = PI_ABORT;
244: bzero ((char *) pa, sizeof *pa);
245:
246: pa -> pa_peer = 1;
247: pa -> pa_reason = PC_ABORTED;
248: (pa -> pa_info[0] = pe) -> pe_context = PCI_ACSE;
249: pa -> pa_ninfo = 1;
250:
251: result = NOTOK;
252: }
253: break;
254:
255: default:
256: /* this works 'cause the "reference" is always the FIRST element */
257: result = ppktlose (pb, pi, PC_SESSION,
258: pdu -> un.connectResponse -> reference, NULLCP,
259: "unexpected PDU %d", pdu -> offset);
260: break;
261: }
262:
263: out: ;
264: if (pdu)
265: free_PS_PDUs (pdu);
266: if (rr)
267: free_PS_ReleaseRequest__PDU (rr);
268:
269: return result;
270: }
271:
272: /* */
273:
274: /* ARGSUSED */
275:
276: int PRelRetryRequest (sd, secs, pr, pi)
277: int sd;
278: int secs;
279: struct PSAPrelease *pr;
280: struct PSAPindication *pi;
281: {
282: return psaplose (pi, PC_OPERATION, "release not in progress");
283: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.