![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to support.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 / rtsap / test|
Return to support.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / rtsap / test |
1.1 root 1: #include <stdio.h>
2: #include <ctype.h>
3: #include <isode/rtsap.h>
4:
5: #include "support.h"
6:
7: /*
8: * General routines useful for supporting the tests of rtsap library routines
9: */
10:
11: extern int fnx_s(), fnx_r();
12: extern FILE *errfp; /* where to send our error messages */
13:
14: #define TIMEOUT 40 /* seconds to wait for a transfer */
15:
16: #define PE_SIZE 3 /* size to build pe's for testing transfer */
17: /*
18: * perform the given operation
19: */
20: oper(sd, operation)
21: int sd;
22: int operation; /* to be performed */
23: {
24: struct RtSAPindication rtis;
25: struct AcSAPrelease acr;
26: PE data;
27:
28: fprintf(errfp, "oper %d\n", operation);
29: switch (operation) {
30: case SIMP_SEND:
31: data = mkpelist(PE_SIZE);
32: if (RtTransferRequest(sd, data, TIMEOUT, &rtis) == NOTOK) {
33: fprintf(errfp, "SIMP_SEND:RT-TRANSFER.REQUEST: %s\n",
34: RtErrString (rtis.rti_abort.rta_reason));
35: exit(1);
36: }
37: pe_free(data);
38: break;
39:
40: case CPLX_SEND:
41: if (RtSetDownTrans(sd, fnx_s, &rtis) == NOTOK) {
42: fprintf(errfp, "CPLX_SEND:RtSetDown: %s\n", /* Can never happen */
43: RtErrString (rtis.rti_abort.rta_reason));
44: exit(3);
45: }
46: if (RtTransferRequest(sd, NULLPE, TIMEOUT, &rtis) == NOTOK) {
47: fprintf(errfp, "CPLX_SEND:failed: %s\n",
48: RtErrString (rtis.rti_abort.rta_reason));
49: exit(1);
50: }
51: fprintf(errfp, "CPLX_SEND:done\n");
52: break;
53:
54: case CPLX_RCV:
55: if (RtSetUpTrans(sd, fnx_r, &rtis) == NOTOK) {
56: fprintf(errfp, "CPLX_RCV:RtSetDown: %s\n", /* Can never happen */
57: RtErrString (rtis.rti_abort.rta_reason));
58: exit(3);
59: }
60: do {
61: if (RtWaitRequest(sd, TIMEOUT, &rtis) == NOTOK) {
62: fprintf(errfp, "CPLX_RCV:failed: %s\n",
63: RtErrString (rtis.rti_abort.rta_reason));
64: exit(1);
65: }
66: if (rtis.rti_type == RTI_CLOSE || rtis.rti_type == RTI_FINISH
67: || rtis.rti_type == RTI_ABORT) {
68: fprintf(errfp, "Unexpected end\n");
69: exit(3);
70: }
71:
72: } while (rtis.rti_type != RTI_TRANSFER);
73: fprintf(errfp, "CPLX_RCV:done\n");
74: break;
75:
76: case SIMP_RCV:
77: case RCV_PLS:
78: case RCV_GIVE:
79: case RCV_ABRT:
80: case RCV_FINISH:
81: case RCV_CLOSE:
82: fprintf(errfp, "RtWaitRequest\n");
83: if (RtWaitRequest(sd, TIMEOUT, &rtis) == NOTOK) {
84: fprintf(errfp, "RtWaitRequest: %s\n",
85: RtErrString (rtis.rti_abort.rta_reason));
86: exit(1);
87: }
88: switch (rtis.rti_type) {
89: case RTI_TURN:
90: if (operation != RCV_GIVE && operation != RCV_PLS)
91: break;
92: if (rtis.rti_turn.rtu_please && operation != RCV_PLS) {
93: fprintf(errfp, "Unexpected RT-TURN-GIVE.INDICATION\n");
94: exit(4);
95: }
96: if (!rtis.rti_turn.rtu_please && operation == RCV_PLS) {
97: fprintf(errfp, "Unexpected RT-TURN-PLEASE.INDICATION\n");
98: exit(5);
99: }
100: return;
101:
102: case RTI_TRANSFER:
103: if (operation != SIMP_RCV)
104: break;
105: data = mkpelist(PE_SIZE);
106: if (pe_cmp(data, rtis.rti_transfer.rtt_data))
107: fprintf(errfp, "oper:RTI_TRANSFER: data does not match\n");
108: RTTFREE(&rtis.rti_transfer);
109: pe_free(data);
110: return;
111:
112: case RTI_ABORT:
113: if (operation != RCV_ABRT || operation != RCV_CLOSE)
114: break;
115: if (rtis.rti_abort.rta_peer)
116: fprintf(errfp, "RT-U-ABORT.INDICATION: %s\n",
117: RtErrString (rtis.rti_abort.rta_reason));
118: else
119: fprintf(errfp, "RT-P-ABORT.INDICATION: %s\n",
120: RtErrString (rtis.rti_abort.rta_reason));
121: return;
122:
123: case RTI_CLOSE:
124: break;
125:
126: case RTI_FINISH:
127: if (operation != RCV_CLOSE)
128: break;
129: if (RtCloseResponse(sd, ACR_NORMAL, NULLPE, &rtis) == NOTOK) {
130: fprintf(errfp, "RtWaitRequest:RT-CLOSE.RESPONSE: %s\n",
131: RtErrString (rtis.rti_abort.rta_reason));
132: exit(9);
133: }
134: return;
135: }
136: fprintf(errfp, "RtWaitRequest:unexpected indication %d received\n",
137: rtis.rti_type);
138: break;
139:
140: case SEND_PLS:
141: if (RtPTurnRequest(sd, 0, &rtis) == NOTOK) {
142: fprintf(errfp, "SEND_PLS:RT-PLEASE-TURN.REQUEST: %s\n",
143: RtErrString (rtis.rti_abort.rta_reason));
144: exit(6);
145: }
146: break;
147:
148: case SEND_GIVE:
149: if (RtGTurnRequest(sd, &rtis) == NOTOK) {
150: fprintf(errfp, "SEND_GIVE:RT-GIVE-TURN.REQUEST: %s\n",
151: RtErrString (rtis.rti_abort.rta_reason));
152: exit(7);
153: }
154: break;
155:
156: case SEND_CLOSE:
157: if (RtCloseRequest (sd, ACF_NORMAL, NULLPE, &acr, &rtis) == NOTOK)
158: fprintf (errfp, "RT-CLOSE.REQUEST: %s\n",
159: RtErrString (rtis.rti_abort.rta_reason));
160: return;
161:
162: case SEND_ABRT:
163: data = mkpelist(PE_SIZE);
164: if (RtUAbortRequest(sd, data, &rtis) == NOTOK)
165: fprintf (errfp, "RT-CLOSE.REQUEST: %s\n",
166: RtErrString (rtis.rti_abort.rta_reason));
167: return;
168:
169: default:
170: fprintf(errfp, "oper:unknown operation %d\n", operation);
171:
172: }
173: }
174:
175:
176: #define MKMASK 0x7
177: #define MKSHIFT 6
178: /*
179: * Generate a randomish list of PElement s for use as ANY or SET OF ANY ....
180: */
181: PE
182: mkpelist(i)
183: int i;
184: {
185: PE pe, fpe = NULL;
186:
187: fpe = pe_alloc(PE_CLASS_PRIV, PE_FORM_CONS, i);
188: while (i > 0) {
189: pe = mkpe(i);
190: pe->pe_next = fpe->pe_cons;
191: fpe->pe_cons = pe;
192: i--;
193: }
194: return (fpe);
195: }
196:
197: /*
198: * generate a randomish PElement
199: */
200: PE
201: mkpe(i)
202: {
203: int id, class;
204: PE pe;
205:
206: id = i * i + 1;
207: class = PE_CLASS_PRIV;
208: switch ((i*i >> MKSHIFT) & MKMASK) {
209: case 5:
210: case 0:
211: pe = flag2prim(i & 0x1, class, id);
212: break;
213:
214: case 6:
215: case 1:
216: pe = num2prim(i, class, id);
217: break;
218:
219: case 7:
220: case 2:
221: pe = str2prim("mkpelist:testdata", 17, class, id);
222: break;
223:
224: case 3:
225: pe = strb2bitstr("\021\0245\375\0124", 4, class, id);
226: break;
227:
228: case 4:
229: pe = mkpelist(i - 1);
230: break;
231:
232: default:
233: fprintf(errfp, "mkpe:internal error %d case not handled\n",
234: (i*i >> MKSHIFT) & MKMASK);
235: exit(2);
236: }
237:
238: return (pe);
239: }
240:
241: #define MAXCNT 3 /* How many increments of data to send */
242: #define DATASIZE 1035 /* Size of maximum increment */
243: /*
244: * function which is called to incrementally send data
245: */
246: fnx_s(sd, base, len, size, ack, ssn, rti)
247: int sd;
248: char **base;
249: int *len, size;
250: long ack, ssn;
251: struct RtSAPindication *rti;
252: {
253: static int cnt = MAXCNT;
254:
255: if (base == NULLVP) { /* RT-PLEASE.INDICATION */
256: fprintf(errfp, "fnx_s: RT-PLEASE.INDICATION ignored\n");
257: return (OK);
258: }
259: fprintf(errfp, "fnx_s: cnt = %d size = %d ack = %d ssn = %d\n",
260: cnt, size, ack, ssn);
261: if (cnt > 0) { /* Send some data */
262: if (size < 0) {
263: fprintf(errfp, "fnx_s: bad value for size %d error\n", size);
264: return rtsaplose(rti, RTS_TRANSFER, NULLCP,
265: "fnx_s called with bad value for size");
266: }
267: if (size == 0) { /* Have to do all at once transfer */
268: cnt = MAXCNT;
269: }
270: if (DATASIZE < size)
271: size = DATASIZE;
272: if ((*base = malloc(size)) == NULL) {
273: fprintf(errfp, "fnx_s: malloc failed on size %d\n", size);
274: return rtsaplose(rti, RTS_TRANSFER, NULLCP, "malloc failed");
275: }
276: fill(*base, size);
277: *len = size;
278: cnt--;
279: } else {
280: cnt = MAXCNT;
281: *len = 0;
282: }
283: return (OK);
284: }
285:
286: static char *SSAPact_names[] = {
287: "START.INDICATION", "RESUME.INDICATION", "INTERRUPT.INDICATION",
288: "INTERRUPT.CONFIRMATION", "DISCARD.INDICATION", "DISCARD.CONFIRMATION",
289: "END.INDICATION", "END.CONFIRMATION",
290: };
291:
292: /* Number of entries */
293: #define NENTRIES(x) (sizeof (x)/sizeof ((x)[0]))
294: /*
295: * function called by rtsap library to handle the incremental reception
296: * of data.
297: */
298: fnx_r(sd, event, addr, rti)
299: int sd;
300: int event;
301: caddr_t addr;
302: struct RtSAPindication *rti;
303: {
304: struct qbuf *qb;
305: struct SSAPactivity *pa;
306: int len;
307: char *p;
308: int place;
309:
310: switch (event) {
311: case SI_DATA:
312: qb = (struct qbuf *)addr;
313: len = qb->qb_len;
314: fprintf(errfp, "fnx_r: %d octets of data arrived\n", len);
315: /* just assume it works - doesn't mention error conditions in the manual */
316: p = qb2str(qb);
317: if ((place = chk(p, len)) >= 0)
318: fprintf(errfp, "fnx_r: data failed check at octet %d\n", place);
319: break;
320:
321: case SI_SYNC:
322: fprintf(errfp, "fnx_r: S-MINOR-SYNC.INDICATION ignored\n");
323: break;
324:
325: case SI_ACTIVITY:
326: pa = (struct SSAPactivity *) addr;
327: if (pa->sv_type >= NENTRIES(SSAPact_names) || pa->sv_type < 0)
328: fprintf(errfp, "fnx_r: S-ACTIVITY of unknown type!\n");
329: else
330: fprintf(errfp, "fnx_r: S-ACTIVITY-%s\n", SSAPact_names[pa->sv_type]);
331: break;
332:
333: case SI_REPORT:
334: fprintf(errfp, "fnx_r: S-U-EXCEPTION-REPORT.INDICATION\n");
335: break;
336:
337: default:
338: fprintf(errfp, "fnx_r: unknown event received %d\n", event);
339: return rtsaplose(rti, RTS_TRANSFER, NULLCP, "fnx_r:Unknown event");
340: }
341:
342: return (OK);
343: }
344:
345: /*
346: * Fill a piece of memory with some data which has a pattern
347: */
348: fill(data, len)
349: char *data;
350: int len;
351: {
352: while (len-- > 0) {
353: *data++ = len & 0xff;
354: }
355: }
356:
357: /*
358: * check that data is filled as per fill routine. Return the place where it
359: * fails otherwise -1 if it doesn't
360: */
361: chk(data, len)
362: char *data;
363: int len;
364: {
365: int i;
366:
367: i = 0;
368: while (len-- > 0) {
369: if ((*data++ & 0xff) != (len & 0xff))
370: return (i);
371: i++;
372: }
373: return (-1);
374: }
375:
376: /*
377: * Dump a bunch of hex digits printing out those that are printable
378: * Print out a given length of octets as hex (with the ASCII characters
379: * given if they have any
380: */
381: fpclen(fp, s, len)
382: register FILE *fp;
383: register char *s;
384: register int len;
385: {
386: register int cnt = 0;
387:
388: while (len-- > 0) {
389: if (cnt % 8 == 0)
390: fprintf(fp, "\n%d:", cnt/8 + 1);
391: if (isprint(*s&0x7f))
392: fprintf(fp, "\t%02x(%c)", *s&0xff, *s&0x7f);
393: else
394: fprintf(fp, "\t%02x", *s&0xff);
395: s++;
396: cnt++;
397: }
398: fputc('\n', fp);
399: }
400:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.