![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dse-c.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 / acsap|
Return to dse-c.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / acsap |
1.1 root 1: /* dse-c.c - DSE wrapper for pepsy */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/acsap/RCS/dse-c.c,v 7.2 90/07/27 08:41:47 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/acsap/RCS/dse-c.c,v 7.2 90/07/27 08:41:47 mrose Exp $
9: *
10: *
11: * $Log: dse-c.c,v $
12: * Revision 7.2 90/07/27 08:41:47 mrose
13: * update
14: *
15: * Revision 7.1 90/07/09 14:31:01 mrose
16: * sync
17: *
18: * Revision 7.0 90/07/01 19:51:16 mrose
19: * *** empty log message ***
20: *
21: */
22:
23: /*
24: * NOTICE
25: *
26: * Acquisition, use, and distribution of this module and related
27: * materials are subject to the restrictions of a license agreement.
28: * Consult the Preface in the User's Manual for the full terms of
29: * this agreement.
30: *
31: */
32:
33: /* LINTLIBRARY */
34:
35:
36: #include <stdio.h>
37: #include "psap.h"
38: #include "isoaddrs.h"
39: #include "tailor.h"
40: #include "DSE-types.h"
41:
42:
43: #define advise PY_advise
44:
45:
46: extern struct type_DSE_PSAPaddr *psap2dse ();
47:
48: /* */
49:
50: int build_DSE_PSAPaddr (pe, explicit, len, buffer, parm)
51: PE *pe;
52: int explicit;
53: int len;
54: char *buffer;
55: char *parm;
56: {
57: int result;
58: register struct PSAPaddr *pa = (struct PSAPaddr *) parm;
59: struct type_DSE_PSAPaddr *dse;
60:
61: if ((dse = psap2dse (pa)) == NULL)
62: return NOTOK;
63:
64: result = encode_DSE_PSAPaddr (pe, explicit, len, buffer, (char *) dse);
65:
66: free_DSE_PSAPaddr (dse);
67:
68: return result;
69: }
70:
71: /* */
72:
73: static struct type_DSE_PSAPaddr *psap2dse (pa)
74: register struct PSAPaddr *pa;
75: {
76: register int n;
77: register struct type_DSE_PSAPaddr *dse;
78: register struct SSAPaddr *sa = &pa -> pa_addr;
79: register struct TSAPaddr *ta = &sa -> sa_addr;
80: register struct NSAPaddr *na;
81: register struct member_DSE_0 *nDSE,
82: **oDSE;
83:
84: if ((dse = (struct type_DSE_PSAPaddr *) calloc (1, sizeof *dse)) == NULL) {
85: advise (NULLCP, "psap2dse: out of memory");
86: return NULL;
87: }
88:
89: if (pa -> pa_selectlen > 0)
90: dse -> pSelector = str2qb (pa -> pa_selector, pa -> pa_selectlen, 1);
91:
92: if (sa -> sa_selectlen > 0)
93: dse -> sSelector = str2qb (sa -> sa_selector, sa -> sa_selectlen, 1);
94:
95: if (ta -> ta_selectlen > 0)
96: dse -> tSelector = str2qb (ta -> ta_selector, ta -> ta_selectlen, 1);
97:
98: oDSE = &dse -> nAddress;
99: for (na = ta -> ta_addrs, n = ta -> ta_naddr; n > 0; na++, n--) {
100: register struct NSAPaddr *ca;
101:
102: if ((nDSE = (struct member_DSE_0 *) calloc (1, sizeof *nDSE))
103: == NULL) {
104: advise (NULLCP, "psap2dse: out of memory");
105: losing: ;
106: free_DSE_PSAPaddr (dse);
107: return NULL;
108: }
109: *oDSE = nDSE;
110: oDSE = &nDSE -> next;
111:
112: if ((ca = na2norm (na)) == NULLNA) {
113: advise (NULLCP, "unable to normalize address");
114: goto losing;
115: }
116:
117: nDSE -> member_DSE_1 = str2qb (ca -> na_address, ca -> na_addrlen, 1);
118: }
119:
120: return dse;
121: }
122:
123: /* */
124:
125: int parse_DSE_PSAPaddr (pe, explicit, len, buffer, parm)
126: register PE pe;
127: int explicit;
128: int *len;
129: char **buffer;
130: char *parm;
131: {
132: int result;
133: register struct PSAPaddr *pa = (struct PSAPaddr *) parm;
134: struct type_DSE_PSAPaddr *dse;
135:
136: if (decode_DSE_PSAPaddr (pe, explicit, len, buffer, &dse) == NOTOK)
137: return NOTOK;
138:
139: result = dse2psap (dse, pa);
140:
141: free_DSE_PSAPaddr (dse);
142:
143: return result;
144: }
145:
146: /* */
147:
148: static int dse2psap (dse, pa)
149: register struct type_DSE_PSAPaddr *dse;
150: register struct PSAPaddr *pa;
151: {
152: register struct SSAPaddr *sa = &pa -> pa_addr;
153: register struct TSAPaddr *ta = &sa -> sa_addr;
154: register struct member_DSE_0 *nDSE;
155:
156: bzero ((char *) pa, sizeof *pa);
157:
158: pa -> pa_selectlen = gstring (pa -> pa_selector,
159: sizeof pa -> pa_selector,
160: dse -> pSelector, "psap selector");
161:
162: sa -> sa_selectlen = gstring (sa -> sa_selector, sizeof sa -> sa_selector,
163: dse -> sSelector, "ssap selector");
164:
165: ta -> ta_selectlen = gstring (ta -> ta_selector, sizeof ta -> ta_selector,
166: dse -> tSelector, "tsap selector");
167:
168: for (nDSE = dse -> nAddress; nDSE; nDSE = nDSE -> next) {
169: char *p;
170:
171: if (ta -> ta_naddr >= NTADDR) {
172: advise (NULLCP, "too many network addresses");
173: return NOTOK;
174: }
175:
176: p = qb2str (nDSE->member_DSE_1);
177: if (str2nsap (p, nDSE -> member_DSE_1 -> qb_len,
178: &ta -> ta_addrs[ta -> ta_naddr++]) == NOTOK)
179: return NOTOK;
180: free (p);
181: }
182:
183: return OK;
184: }
185:
186: /* */
187:
188: static int gstring (buf, buflen, qb, w)
189: char *buf;
190: int buflen;
191: struct qbuf *qb;
192: char *w;
193: {
194: char *p;
195:
196: if (qb == NULL || qb -> qb_len <= 0)
197: return 0;
198:
199: if (qb -> qb_len > buflen) {
200: advise (NULLCP, "%s too long", w);
201: return 0;
202: }
203:
204: p = qb2str (qb);
205: bcopy (p, buf, qb -> qb_len);
206: free (p);
207:
208: return qb -> qb_len;
209: }
210:
211: /* */
212:
213: static int str2nsap (p, len, na)
214: char *p;
215: int len;
216: struct NSAPaddr *na;
217: {
218: na -> na_stack = NA_NSAP;
219:
220: if ((len == 8) && ((p[0] == 0x36) || (p[0] == 0x37))) {
221: int xlen; /* SEK - X121 form */
222: register char *cp,
223: *cp2,
224: *dp;
225: char nsap[14];
226:
227: dp = nsap;
228: for (cp2 = (cp = p + 1) + 7; cp < cp2; cp++) {
229: register int j;
230:
231: if ((j = ((*cp & 0xf0) >> 4)) > 9)
232: goto concrete;
233: *dp++ = j + '0';
234:
235: if ((j = (*cp & 0x0f)) > 9) {
236: if (j != 0x0f)
237: goto concrete;
238: }
239: else
240: *dp++ = j + '0';
241: }
242:
243: for (cp = nsap, xlen = 14; *cp == '0'; cp++, xlen--)
244: continue;
245: na -> na_dtelen = xlen;
246: for (cp2 = na -> na_dte; xlen-- > 0; )
247: *cp2++ = *cp++;
248: *cp2 = NULL;
249: #ifdef BRIDGE_X25
250: na -> na_stack = bridgediscrim (na) ? NA_BRG : NA_X25;
251: #else
252: na -> na_stack = NA_X25;
253: #endif
254: na -> na_community = SUBNET_INT_X25;
255: }
256: else {
257: register struct ts_interim *ts,
258: *tp;
259:
260: tp = NULL;
261: for (ts = ts_interim; ts -> ts_name; ts++)
262: if (len > ts -> ts_length
263: && (tp == NULL || ts -> ts_length > tp -> ts_length)
264: && bcmp (p, ts -> ts_prefix, ts -> ts_length) == 0)
265: tp = ts;
266: if (tp) {
267: int i,
268: ilen,
269: rlen;
270: register char *cp,
271: *dp,
272: *ep;
273: char nsap[NASIZE * 2 + 1];
274:
275: dp = nsap;
276: for (cp = p + tp -> ts_length, ep = p + len;
277: cp < ep;
278: cp++) {
279: register int j;
280:
281: if ((j = ((*cp & 0xf0) >> 4)) > 9) {
282: concrete: ;
283: LLOG (addr_log, LLOG_EXCEPTIONS,
284: ("invalid concrete encoding"));
285: goto realNS;
286: }
287: *dp++ = j + '0';
288:
289: if ((j = (*cp & 0x0f)) > 9) {
290: if (j != 0x0f)
291: goto concrete;
292: }
293: else
294: *dp++ = j + '0';
295: }
296: *dp = NULL;
297:
298: cp = nsap;
299: na -> na_community = tp -> ts_subnet;
300: switch (na -> na_stack = tp -> ts_syntax) {
301: case NA_NSAP:
302: goto unrealNS;
303:
304: case NA_X25:
305: if (strlen (cp) < 1) {
306: LLOG (addr_log, LLOG_EXCEPTIONS,
307: ("missing DTE+CUDF indicator: %s", nsap));
308: goto realNS;
309: }
310: (void) sscanf (cp, "%1d", &i);
311: cp += 1;
312: switch (i) {
313: case 0: /* DTE only */
314: break;
315:
316: case 1: /* DTE+PID */
317: case 2: /* DTE+CUDF */
318: if (strlen (cp) < 1) {
319: LLOG (addr_log, LLOG_EXCEPTIONS,
320: ("missing DTE+CUDF indicator: %s",
321: nsap));
322: goto realNS;
323: }
324: (void) sscanf (cp, "%1d", &ilen);
325: cp += 1;
326: rlen = ilen * 3;
327: if (strlen (cp) < rlen) {
328: LLOG (addr_log, LLOG_EXCEPTIONS,
329: ("bad DTE+CUDF length: %s", nsap));
330: goto realNS;
331: }
332: if (i == 1) {
333: if (ilen > NPSIZE) {
334: LLOG (addr_log, LLOG_EXCEPTIONS,
335: ("PID too long: %s", nsap));
336: goto realNS;
337: }
338: dp = na -> na_pid;
339: na -> na_pidlen = ilen;
340: }
341: else {
342: if (ilen > CUDFSIZE) {
343: LLOG (addr_log, LLOG_EXCEPTIONS,
344: ("CUDF too long: %s", nsap));
345: goto realNS;
346: }
347: dp = na -> na_cudf;
348: na -> na_cudflen = ilen;
349: }
350: for (; rlen > 0; rlen -= 3) {
351: (void) sscanf (cp, "%3d", &i);
352: cp += 3;
353:
354: if (i > 255) {
355: LLOG (addr_log, LLOG_EXCEPTIONS,
356: ("invalid PID/CUDF: %s", nsap));
357: goto realNS;
358: }
359: *dp++ = i & 0xff;
360: }
361: break;
362:
363: default:
364: LLOG (addr_log, LLOG_EXCEPTIONS,
365: ("invalid DTE+CUDF indicator: %s", nsap));
366: goto realNS;
367: }
368: (void) strcpy (na -> na_dte, cp);
369: na -> na_dtelen = strlen (na -> na_dte);
370:
371: #ifdef BRIDGE_X25
372: if (bridgediscrim (na))
373: na -> na_stack = NA_BRG;
374: #endif
375: break;
376:
377: case NA_TCP:
378: if (strlen (cp) < 12) {
379: LLOG (addr_log, LLOG_EXCEPTIONS,
380: ("missing IP address: %s", nsap));
381: goto realNS;
382: }
383: {
384: int q[4];
385:
386: (void) sscanf (cp, "%3d%3d%3d%3d", q, q + 1, q + 2,
387: q + 3);
388: (void) sprintf (na -> na_domain,
389: "%d.%d.%d.%d", q[0], q[1], q[2], q[3]);
390: }
391: cp += 12;
392:
393: if (*cp) {
394: if (strlen (cp) < 5) {
395: LLOG (addr_log, LLOG_EXCEPTIONS,
396: ("missing port: %s", nsap));
397: goto realNS;
398: }
399: (void) sscanf (cp, "%5d", &i);
400: cp += 5;
401: na -> na_port = htons ((u_short) i);
402:
403: if (*cp) {
404: if (strlen (cp) < 5) {
405: LLOG (addr_log, LLOG_EXCEPTIONS,
406: ("missing tset: %s", nsap));
407: goto realNS;
408: }
409: (void) sscanf (cp, "%5d", &i);
410: cp += 5;
411: na -> na_tset = (u_short) i;
412:
413: if (*cp)
414: LLOG (addr_log, LLOG_EXCEPTIONS,
415: ("extra TCP information: %s", nsap));
416: }
417: }
418: break;
419:
420: default:
421: LLOG (addr_log, LLOG_NOTICE,
422: ("unknown syntax %d for DSP: %s", ts -> ts_syntax,
423: nsap));
424: goto realNS;
425: }
426: }
427: else {
428: realNS: ;
429: na -> na_stack = NA_NSAP;
430: na -> na_community = SUBNET_REALNS;
431: unrealNS: ;
432: if (len > sizeof na -> na_address) {
433: advise (NULLCP, "NSAP address too long");
434: return NOTOK;
435: }
436: bcopy (p, na -> na_address, na -> na_addrlen = len);
437: }
438: }
439:
440: return OK;
441: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.