![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ftambulk.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 / ftam|
Return to ftambulk.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / ftam |
1.1 root 1: /* ftambulk.c - FPM: bulk data transfer */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/ftam/RCS/ftambulk.c,v 7.0 89/11/23 21:53:26 mrose Rel $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/ftam/RCS/ftambulk.c,v 7.0 89/11/23 21:53:26 mrose Rel $
9: *
10: *
11: * $Log: ftambulk.c,v $
12: * Revision 7.0 89/11/23 21:53:26 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: /* LINTLIBRARY */
29:
30: #include <stdio.h>
31: #include <signal.h>
32: #include "fpkt.h"
33:
34: /* F-DATA.REQUEST */
35:
36: int FDataRequest (sd, fadus, nfadu, fti)
37: int sd;
38: PE fadus[];
39: int nfadu;
40: struct FTAMindication *fti;
41: {
42: SBV smask;
43: int result;
44: register struct ftamblk *fsb;
45:
46: missingP (fti);
47:
48: smask = sigioblock ();
49:
50: ftamPsig (fsb, sd);
51:
52: result = FDataRequestAux (fsb, fadus, nfadu, fti);
53:
54: (void) sigiomask (smask);
55:
56: return result;
57: }
58:
59: /* */
60:
61: static int FDataRequestAux (fsb, fadus, nfadu, fti)
62: register struct ftamblk *fsb;
63: PE fadus[];
64: int nfadu;
65: struct FTAMindication *fti;
66: {
67: register int i;
68: PE pe,
69: *pep;
70: struct PSAPindication pis;
71: struct PSAPindication *pi = &pis;
72: struct PSAPabort *pa = &pi -> pi_abort;
73:
74: switch (fsb -> fsb_state) {
75: case FSB_DATAREAD:
76: if (fsb -> fsb_flags & FSB_INIT)
77: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
78: "not responder");
79: break;
80:
81: case FSB_DATAWRITE:
82: if (!(fsb -> fsb_flags & FSB_INIT))
83: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
84: "not initiator");
85: break;
86:
87: default:
88: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP, "wrong state");
89: }
90:
91: for (pep = fadus, i = nfadu - 1; i >= 0; pep++, i--) {
92: if ((pe = *pep) == NULLPE)
93: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
94: "empty FADU at slot %d", nfadu - i - 1);
95:
96: if (pe -> pe_context == PE_DFLT_CTX)
97: pe -> pe_context = fsb -> fsb_id;
98:
99: if (pe -> pe_context == fsb -> fsb_id)
100: switch (PE_ID (pe -> pe_class, pe -> pe_id)) {
101: case PE_ID (PE_CLASS_APPL, FADU_NODESCR):
102: case PE_ID (PE_CLASS_APPL, FADU_ENTERTREE):
103: case PE_ID (PE_CLASS_APPL, FADU_EXITREE):
104: break;
105:
106: default:
107: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
108: "bad context at slot %d", nfadu - i - 1);
109: }
110: }
111:
112: if (PDataRequest (fsb -> fsb_fd, fadus, nfadu, pi) == NOTOK) {
113: (void) ps2ftamlose (fsb, fti, "PDataRequest", pa);
114: if (PC_FATAL (pa -> pa_reason))
115: freefsblk (fsb);
116:
117: return NOTOK;
118: }
119:
120: return OK;
121: }
122:
123: /* F-DATA-END.REQUEST */
124:
125: int FDataEndRequest (sd, action, diag, ndiag, fti)
126: int sd;
127: int action;
128: struct FTAMdiagnostic diag[];
129: int ndiag;
130: struct FTAMindication *fti;
131: {
132: SBV smask;
133: int result;
134: register struct ftamblk *fsb;
135:
136: switch (action) {
137: case FACTION_SUCCESS:
138: case FACTION_TRANS:
139: case FACTION_PERM:
140: break;
141:
142: default:
143: return ftamlose (fti, FS_GEN_NOREASON, 0, NULLCP,
144: "bad value for action parameter");
145: }
146: toomuchP (diag, ndiag, NFDIAG, "diagnostic");
147: missingP (fti);
148:
149: smask = sigioblock ();
150:
151: ftamPsig (fsb, sd);
152:
153: result = FDataEndRequestAux (fsb, action, diag, ndiag, fti);
154:
155: (void) sigiomask (smask);
156:
157: return result;
158: }
159:
160: /* */
161:
162: static int FDataEndRequestAux (fsb, action, diag, ndiag, fti)
163: register struct ftamblk *fsb;
164: int action;
165: struct FTAMdiagnostic diag[];
166: int ndiag;
167: struct FTAMindication *fti;
168: {
169: int result;
170: PE pe;
171: struct PSAPindication pis;
172: struct PSAPindication *pi = &pis;
173: struct PSAPabort *pa = &pi -> pi_abort;
174: register struct type_FTAM_PDU *pdu;
175: register struct type_FTAM_F__DATA__END__request *req;
176:
177: switch (fsb -> fsb_state) {
178: case FSB_DATAREAD:
179: if (fsb -> fsb_flags & FSB_INIT)
180: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
181: "not responder");
182: break;
183:
184: case FSB_DATAWRITE:
185: if (!(fsb -> fsb_flags & FSB_INIT))
186: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
187: "not initiator");
188: break;
189:
190: default:
191: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP, "wrong state");
192: }
193:
194: pe = NULLPE;
195: if ((pdu = (struct type_FTAM_PDU *) calloc (1, sizeof *pdu)) == NULL) {
196: no_mem: ;
197: (void) ftamlose (fti, FS_GEN (fsb), 1, NULLCP, "out of memory");
198: out: ;
199: if (pe)
200: pe_free (pe);
201: if (pdu)
202: free_FTAM_PDU (pdu);
203: if (fti -> fti_abort.fta_action == FACTION_PERM)
204: freefsblk (fsb);
205: return NOTOK;
206: }
207: pdu -> offset = type_FTAM_PDU_f__data__end__request;
208: if ((req = (struct type_FTAM_F__DATA__END__request *)
209: calloc (1, sizeof *req)) == NULL)
210: goto no_mem;
211: pdu -> un.f__data__end__request = req;
212: if ((req -> action__result =
213: (struct type_FTAM_Action__Result *)
214: calloc (1, sizeof *req -> action__result)) == NULL)
215: goto no_mem;
216: req -> action__result -> parm = action;
217: if (ndiag > 0
218: && (req -> diagnostic = diag2fpm (fsb, 0, diag, ndiag, fti))
219: == NULL)
220: goto out;
221:
222: if (encode_FTAM_PDU (&pe, 1, 0, NULLCP, pdu) == NOTOK) {
223: (void) ftamlose (fti, FS_GEN (fsb), 1, NULLCP,
224: "error encoding PDU: %s", PY_pepy);
225: goto out;
226: }
227:
228: pe -> pe_context = fsb -> fsb_id;
229:
230: fsbtrace (fsb,
231: (fsb -> fsb_fd, "P-DATA.REQUEST", "F-DATA-END-request", pe, 0));
232:
233: result = PDataRequest (fsb -> fsb_fd, &pe, 1, pi);
234:
235: pe_free (pe);
236: pe = NULLPE;
237: free_FTAM_PDU (pdu);
238: pdu = NULL;
239:
240: if (result == NOTOK) {
241: (void) ps2ftamlose (fsb, fti, "PDataRequest", pa);
242: goto out;
243: }
244:
245: fsb -> fsb_state = FSB_DATAFIN1;
246:
247: return OK;
248: }
249:
250: /* F-CANCEL.REQUEST */
251:
252: int FCancelRequest (sd, action, sharedASE, diag, ndiag, fti)
253: int sd;
254: int action;
255: PE sharedASE;
256: struct FTAMdiagnostic diag[];
257: int ndiag;
258: struct FTAMindication *fti;
259: {
260: SBV smask;
261: int result;
262: register struct ftamblk *fsb;
263:
264: switch (action) {
265: case FACTION_SUCCESS:
266: case FACTION_TRANS:
267: case FACTION_PERM:
268: break;
269:
270: default:
271: return ftamlose (fti, FS_GEN_NOREASON, 0, NULLCP,
272: "bad value for action parameter");
273: }
274: toomuchP (diag, ndiag, NFDIAG, "diagnostic");
275: missingP (fti);
276:
277: smask = sigioblock ();
278:
279: ftamPsig (fsb, sd);
280:
281: result = FCancelRequestAux (fsb, action, sharedASE, diag, ndiag, fti);
282:
283: (void) sigiomask (smask);
284:
285: return result;
286: }
287:
288: /* */
289:
290: static int FCancelRequestAux (fsb, action, sharedASE, diag, ndiag, fti)
291: register struct ftamblk *fsb;
292: int action;
293: PE sharedASE;
294: struct FTAMdiagnostic diag[];
295: int ndiag;
296: struct FTAMindication *fti;
297: {
298: int result,
299: settings;
300: char *prequest;
301: PE pe;
302: struct PSAPindication pis;
303: struct PSAPindication *pi = &pis;
304: struct PSAPabort *pa = &pi -> pi_abort;
305: register struct type_FTAM_PDU *pdu;
306: register struct type_FTAM_F__CANCEL__request *req;
307:
308: switch (fsb -> fsb_state) {
309: case FSB_DATAREAD:
310: case FSB_DATAWRITE:
311: break;
312:
313: default:
314: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP, "wrong state");
315: }
316:
317: pe = NULLPE;
318: if ((pdu = (struct type_FTAM_PDU *) calloc (1, sizeof *pdu)) == NULL) {
319: no_mem: ;
320: (void) ftamlose (fti, FS_GEN (fsb), 1, NULLCP, "out of memory");
321: out: ;
322: if (pe)
323: pe_free (pe);
324: if (pdu)
325: free_FTAM_PDU (pdu);
326: if (fti -> fti_abort.fta_action == FACTION_PERM)
327: freefsblk (fsb);
328: return NOTOK;
329: }
330: pdu -> offset = type_FTAM_PDU_f__cancel__request;
331: if ((req = (struct type_FTAM_F__CANCEL__request *)
332: calloc (1, sizeof *req)) == NULL)
333: goto no_mem;
334: pdu -> un.f__cancel__request = req;
335: if ((req -> action__result =
336: (struct type_FTAM_Action__Result *)
337: calloc (1, sizeof *req -> action__result)) == NULL)
338: goto no_mem;
339: req -> action__result -> parm = action;
340: if (sharedASE
341: && (req -> shared__ASE__information =
342: shared2fpm (fsb, sharedASE, fti)) == NULL)
343: goto out;
344: if (ndiag > 0
345: && (req -> diagnostic = diag2fpm (fsb, 0, diag, ndiag, fti))
346: == NULL)
347: goto out;
348:
349: if (encode_FTAM_PDU (&pe, 1, 0, NULLCP, pdu) == NOTOK) {
350: (void) ftamlose (fti, FS_GEN (fsb), 1, NULLCP,
351: "error encoding PDU: %s", PY_pepy);
352: goto out;
353: }
354:
355: pe -> pe_context = fsb -> fsb_id;
356:
357: if (fsb -> fsb_srequirements & SR_RESYNC) {
358: fsbtrace (fsb, (fsb -> fsb_fd, "P-RESYNCHRONIZE.REQUEST",
359: "F-CANCEL-request", pe, 0));
360:
361: settings = 0; /* XXX: more later! */
362:
363: result = PReSyncRequest (fsb -> fsb_fd, SYNC_ABANDON, SERIAL_NONE,
364: settings, &pe, 1, pi);
365:
366: prequest = "PReSyncRequest";
367: }
368: else {
369: fsbtrace (fsb, (fsb -> fsb_fd, "P-DATA.REQUEST", "F-CANCEL-request",
370: pe, 0));
371:
372: result = PDataRequest (fsb -> fsb_fd, &pe, 1, pi);
373:
374: prequest = "PDataRequest";
375: }
376:
377: pe_free (pe);
378: pe = NULLPE;
379: free_FTAM_PDU (pdu);
380: pdu = NULL;
381:
382: if (result == NOTOK) {
383: (void) ps2ftamlose (fsb, fti, prequest, pa);
384: goto out;
385: }
386:
387: fsb -> fsb_flags |= FSB_CANCEL;
388: fsb -> fsb_state = FSB_DATACANCEL;
389: fsb -> fsb_cancelaction = action;
390: if (fsb -> fsb_cancelshared = sharedASE)
391: fsb -> fsb_cancelshared -> pe_refcnt++;
392: fsb -> fsb_canceldiags = diag;
393: fsb -> fsb_cancelndiag = ndiag;
394:
395: return FWaitRequestAux (fsb, NOTOK, fti);
396: }
397:
398: /* F-CANCEL.RESPONSE */
399:
400: int FCancelResponse (sd, action, sharedASE, diag, ndiag, fti)
401: int sd;
402: int action;
403: PE sharedASE;
404: struct FTAMdiagnostic diag[];
405: int ndiag;
406: struct FTAMindication *fti;
407: {
408: SBV smask;
409: int result;
410: register struct ftamblk *fsb;
411:
412: switch (action) {
413: case FACTION_SUCCESS:
414: case FACTION_TRANS:
415: case FACTION_PERM:
416: break;
417:
418: default:
419: return ftamlose (fti, FS_GEN_NOREASON, 0, NULLCP,
420: "bad value for action parameter");
421: }
422: toomuchP (diag, ndiag, NFDIAG, "diagnostic");
423: missingP (fti);
424:
425: smask = sigioblock ();
426:
427: ftamPsig (fsb, sd);
428:
429: result = FCancelResponseAux (fsb, action, sharedASE, diag, ndiag, fti);
430:
431: (void) sigiomask (smask);
432:
433: return result;
434: }
435:
436: /* */
437:
438: int FCancelResponseAux (fsb, action, sharedASE, diag, ndiag, fti)
439: register struct ftamblk *fsb;
440: int action;
441: PE sharedASE;
442: struct FTAMdiagnostic diag[];
443: int ndiag;
444: struct FTAMindication *fti;
445: {
446: int result;
447: char *prequest;
448: PE pe;
449: struct PSAPindication pis;
450: struct PSAPindication *pi = &pis;
451: struct PSAPabort *pa = &pi -> pi_abort;
452: register struct type_FTAM_PDU *pdu;
453: register struct type_FTAM_F__CANCEL__response *rsp;
454:
455: if (fsb -> fsb_state != FSB_DATACANCEL)
456: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP, "wrong state");
457:
458: pe = NULLPE;
459: if ((pdu = (struct type_FTAM_PDU *) calloc (1, sizeof *pdu)) == NULL) {
460: no_mem: ;
461: (void) ftamlose (fti, FS_GEN (fsb), 1, NULLCP, "out of memory");
462: out: ;
463: if (pe)
464: pe_free (pe);
465: if (pdu)
466: free_FTAM_PDU (pdu);
467: if (fti -> fti_abort.fta_action == FACTION_PERM)
468: freefsblk (fsb);
469: return NOTOK;
470: }
471: pdu -> offset = type_FTAM_PDU_f__cancel__response;
472: if ((rsp = (struct type_FTAM_F__CANCEL__response *)
473: calloc (1, sizeof *rsp)) == NULL)
474: goto no_mem;
475: pdu -> un.f__cancel__response = rsp;
476: if ((rsp -> action__result =
477: (struct type_FTAM_Action__Result *)
478: calloc (1, sizeof *rsp -> action__result)) == NULL)
479: goto no_mem;
480: rsp -> action__result -> parm = action;
481: if (sharedASE
482: && (rsp -> shared__ASE__information =
483: shared2fpm (fsb, sharedASE, fti)) == NULL)
484: goto out;
485: if (ndiag > 0
486: && (rsp -> diagnostic = diag2fpm (fsb, 0, diag, ndiag, fti))
487: == NULL)
488: goto out;
489:
490: if (encode_FTAM_PDU (&pe, 1, 0, NULLCP, pdu) == NOTOK) {
491: (void) ftamlose (fti, FS_GEN (fsb), 1, NULLCP,
492: "error encoding PDU: %s", PY_pepy);
493: goto out;
494: }
495:
496: pe -> pe_context = fsb -> fsb_id;
497:
498: if (fsb -> fsb_srequirements & SR_RESYNC) {
499: fsbtrace (fsb, (fsb -> fsb_fd, "P-RESYNCHRONIZE.RESPONSE",
500: "F-CANCEL-response", pe, 0));
501:
502: result = PReSyncResponse (fsb -> fsb_fd, SERIAL_NONE,
503: fsb -> fsb_settings, &pe, 1, pi);
504:
505: prequest = "PReSyncResponse";
506: }
507: else {
508: fsbtrace (fsb, (fsb -> fsb_fd, "P-DATA.REQUEST", "F-CANCEL-response",
509: pe, 0));
510:
511: result = PDataRequest (fsb -> fsb_fd, &pe, 1, pi);
512:
513: prequest = "PDataRequest";
514: }
515:
516: pe_free (pe);
517: pe = NULLPE;
518: free_FTAM_PDU (pdu);
519: pdu = NULL;
520:
521: if (result == NOTOK) {
522: (void) ps2ftamlose (fsb, fti, prequest, pa);
523: goto out;
524: }
525:
526: fsb -> fsb_state = FSB_DATAIDLE;
527:
528: return OK;
529: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.