![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ftambulk1.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 ftambulk1.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / ftam |
1.1 root 1: /* ftambulk1.c - FPM: initiate bulk data transfer */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/ftam/RCS/ftambulk1.c,v 7.0 89/11/23 21:53:27 mrose Rel $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/ftam/RCS/ftambulk1.c,v 7.0 89/11/23 21:53:27 mrose Rel $
9: *
10: *
11: * $Log: ftambulk1.c,v $
12: * Revision 7.0 89/11/23 21:53:27 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-{READ,WRITE}.REQUEST */
35:
36: int FReadWriteRequest (sd, operation, identity, context, level, lock, fti)
37: int sd;
38: int operation;
39: struct FADUidentity *identity;
40: int context, /* F-READ.REQUEST only */
41: level, /* .. */
42: lock;
43: struct FTAMindication *fti;
44: {
45: SBV smask;
46: int result,
47: state;
48: register struct ftamblk *fsb;
49:
50: switch (operation) {
51: case FA_OPS_READ:
52: state = FSB_DATAREAD;
53: break;
54:
55: case FA_OPS_INSERT:
56: case FA_OPS_REPLACE:
57: case FA_OPS_EXTEND:
58: state = FSB_DATAWRITE;
59: break;
60:
61: default:
62: return ftamlose (fti, FS_GEN_NOREASON, 0, NULLCP,
63: "bad value for operation parameter");
64: }
65: missingP (identity);
66: if (operation == FA_OPS_READ)
67: switch (context) {
68: case FA_ACC_HA:
69: case FA_ACC_HN:
70: case FA_ACC_FA:
71: case FA_ACC_FL:
72: case FA_ACC_FS:
73: case FA_ACC_UA:
74: case FA_ACC_US:
75: break;
76:
77: default:
78: return ftamlose (fti, FS_GEN_NOREASON, 0, NULLCP,
79: "bad value for context parameter");
80: }
81: missingP (fti);
82:
83: smask = sigioblock ();
84:
85: ftamPsig (fsb, sd);
86:
87: result = FReadWriteRequestAux (fsb, state, operation, identity, context,
88: level, lock, fti);
89:
90: (void) sigiomask (smask);
91:
92: return result;
93: }
94:
95: /* */
96:
97: static int FReadWriteRequestAux (fsb, state, operation, identity, context,
98: level, lock, fti)
99: register struct ftamblk *fsb;
100: int state,
101: operation;
102: struct FADUidentity *identity;
103: int context,
104: level,
105: lock;
106: struct FTAMindication *fti;
107: {
108: int result;
109: char *fpdu;
110: PE pe;
111: struct PSAPindication pis;
112: struct PSAPindication *pi = &pis;
113: struct PSAPabort *pa = &pi -> pi_abort;
114: register struct type_FTAM_PDU *pdu;
115: register struct type_FTAM_F__READ__request *rd;
116: register struct type_FTAM_F__WRITE__request *wr;
117:
118: if (!(fsb -> fsb_flags & FSB_INIT))
119: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP, "not initiator");
120: if (fsb -> fsb_state != FSB_DATAIDLE)
121: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP, "wrong state");
122:
123: switch (state) {
124: case FSB_DATAREAD:
125: if (!(fsb -> fsb_units & FUNIT_READ))
126: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
127: "reading not allowed");
128: break;
129:
130: case FSB_DATAWRITE:
131: if (!(fsb -> fsb_units & FUNIT_WRITE))
132: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
133: "writing not allowed");
134: break;
135: }
136:
137: pe = NULLPE;
138: if ((pdu = (struct type_FTAM_PDU *) calloc (1, sizeof *pdu)) == NULL) {
139: no_mem: ;
140: (void) ftamlose (fti, FS_GEN (fsb), 1, NULLCP, "out of memory");
141: out: ;
142: if (pe)
143: pe_free (pe);
144: if (pdu)
145: free_FTAM_PDU (pdu);
146: if (fti -> fti_abort.fta_action == FACTION_PERM)
147: freefsblk (fsb);
148: return NOTOK;
149: }
150: if (state != FSB_DATAREAD) {
151: pdu -> offset = type_FTAM_PDU_f__write__request;
152: if ((wr = (struct type_FTAM_F__WRITE__request *)
153: calloc (1, sizeof *wr)) == NULL)
154: goto no_mem;
155: pdu -> un.f__write__request = wr;
156: fpdu = "F-WRITE-request";
157:
158: wr -> file__access__data__unit__operation = operation;
159: if ((wr -> file__access__data__unit__identity =
160: faduid2fpm (fsb, identity, fti)) == NULL)
161: goto out;
162: if (fsb -> fsb_units & FUNIT_FADULOCK) {
163: if ((wr -> fadu__lock = (struct type_FTAM_FADU__Lock *)
164: calloc (1, sizeof *wr -> fadu__lock))
165: == NULL)
166: goto no_mem;
167: wr -> fadu__lock -> parm = lock ? int_FTAM_FADU__Lock_on
168: : int_FTAM_FADU__Lock_off;
169: }
170: }
171: else {
172: pdu -> offset = type_FTAM_PDU_f__read__request;
173: if ((rd = (struct type_FTAM_F__READ__request *)
174: calloc (1, sizeof *rd)) == NULL)
175: goto no_mem;
176: pdu -> un.f__read__request = rd;
177: fpdu = "F-READ-request";
178:
179: if ((rd -> file__access__data__unit__identity =
180: faduid2fpm (fsb, identity, fti)) == NULL)
181: goto out;
182: if ((rd -> access__context =
183: (struct type_FTAM_Access__Context *)
184: calloc (1, sizeof *rd -> access__context))
185: == NULL)
186: goto no_mem;
187: if ((rd -> access__context -> access__context = context)
188: == FA_ACC_FL) {
189: rd -> access__context -> optionals |=
190: opt_FTAM_Access__Context_level__number;
191: rd -> access__context -> level__number = level;
192: }
193:
194: if (fsb -> fsb_units & FUNIT_FADULOCK) {
195: if ((rd -> fadu__lock = (struct type_FTAM_FADU__Lock *)
196: calloc (1, sizeof *wr -> fadu__lock))
197: == NULL)
198: goto no_mem;
199: rd -> fadu__lock -> parm = lock ? int_FTAM_FADU__Lock_on
200: : int_FTAM_FADU__Lock_off;
201: }
202: }
203:
204: if (encode_FTAM_PDU (&pe, 1, 0, NULLCP, pdu) == NOTOK) {
205: (void) ftamlose (fti, FS_GEN (fsb), 1, NULLCP,
206: "error encoding PDU: %s", PY_pepy);
207: goto out;
208: }
209:
210: pe -> pe_context = fsb -> fsb_id;
211:
212: fsbtrace (fsb, (fsb -> fsb_fd, "P-DATA.REQUEST", fpdu, pe, 0));
213:
214: result = PDataRequest (fsb -> fsb_fd, &pe, 1, pi);
215:
216: pe_free (pe);
217: pe = NULLPE;
218: free_FTAM_PDU (pdu);
219: pdu = NULL;
220:
221: if (result == NOTOK) {
222: (void) ps2ftamlose (fsb, fti, "PDataRequest", pa);
223: goto out;
224: }
225:
226: fsb -> fsb_state = state;
227:
228: return OK;
229: }
230:
231: /* F-TRANSFER-END.REQUEST */
232:
233: int FTransEndRequest (sd, sharedASE, fti)
234: int sd;
235: PE sharedASE;
236: struct FTAMindication *fti;
237: {
238: SBV smask;
239: int result;
240: register struct ftamblk *fsb;
241:
242: missingP (fti);
243:
244: smask = sigioblock ();
245:
246: ftamPsig (fsb, sd);
247:
248: result = FTransEndRequestAux (fsb, sharedASE, fti);
249:
250: (void) sigiomask (smask);
251:
252: return result;
253: }
254:
255:
256: /* */
257:
258: static int FTransEndRequestAux (fsb, sharedASE, fti)
259: register struct ftamblk *fsb;
260: PE sharedASE;
261: struct FTAMindication *fti;
262: {
263: int result;
264: PE pe;
265: struct PSAPindication pis;
266: struct PSAPindication *pi = &pis;
267: struct PSAPabort *pa = &pi -> pi_abort;
268: register struct type_FTAM_PDU *pdu;
269:
270: if (!(fsb -> fsb_flags & FSB_INIT))
271: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP, "not initiator");
272: if (fsb -> fsb_state != FSB_DATAFIN1)
273: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP, "wrong state");
274:
275: pe = NULLPE;
276: if ((pdu = (struct type_FTAM_PDU *) calloc (1, sizeof *pdu)) == NULL) {
277: (void) ftamlose (fti, FS_GEN (fsb), 1, NULLCP, "out of memory");
278: out: ;
279: if (pe)
280: pe_free (pe);
281: if (pdu)
282: free_FTAM_PDU (pdu);
283: if (fti -> fti_abort.fta_action == FACTION_PERM)
284: freefsblk (fsb);
285: return NOTOK;
286: }
287: pdu -> offset = type_FTAM_PDU_f__transfer__end__request;
288: if (sharedASE
289: && (pdu -> un.f__transfer__end__request =
290: shared2fpm (fsb, sharedASE, fti)) == NULL)
291: goto out;
292:
293: if (encode_FTAM_PDU (&pe, 1, 0, NULLCP, pdu) == NOTOK) {
294: (void) ftamlose (fti, FS_GEN (fsb), 1, NULLCP,
295: "error encoding PDU: %s", PY_pepy);
296: goto out;
297: }
298:
299: pe -> pe_context = fsb -> fsb_id;
300:
301: fsbtrace (fsb, (fsb -> fsb_fd, "P-DATA.REQUEST", "F-TRANSFER-END-request",
302: pe, 0));
303:
304: result = PDataRequest (fsb -> fsb_fd, &pe, 1, pi);
305:
306: pe_free (pe);
307: pe = NULLPE;
308: free_FTAM_PDU (pdu);
309: pdu = NULL;
310:
311:
312: if (result == NOTOK) {
313: (void) ps2ftamlose (fsb, fti, "PDataRequest", pa);
314: goto out;
315: }
316:
317: fsb -> fsb_state = FSB_DATAFIN2;
318:
319: return FWaitRequestAux (fsb, NOTOK, fti);
320: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.