![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ftamgroup2.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 ftamgroup2.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / ftam |
1.1 root 1: /* ftamgroup2.c - FPM: respond to a grouped transaction */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/ftam/RCS/ftamgroup2.c,v 7.0 89/11/23 21:53:39 mrose Rel $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/ftam/RCS/ftamgroup2.c,v 7.0 89/11/23 21:53:39 mrose Rel $
9: *
10: *
11: * $Log: ftamgroup2.c,v $
12: * Revision 7.0 89/11/23 21:53:39 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-{MANAGE,BULK-{BEGIN,END}}.RESPONSE (group) */
35:
36: int FManageResponse (sd, ftg, fti)
37: int sd;
38: struct FTAMgroup *ftg;
39: struct FTAMindication *fti;
40: {
41: return FGroupResponse (sd, ftg, FTI_MANAGEMENT, FSB_INITIALIZED, fti);
42: }
43:
44:
45: int FBulkBeginResponse (sd, ftg, fti)
46: int sd;
47: struct FTAMgroup *ftg;
48: struct FTAMindication *fti;
49: {
50: return FGroupResponse (sd, ftg, FTI_BULKBEGIN, FSB_DATAIDLE, fti);
51: }
52:
53:
54: int FBulkEndResponse (sd, ftg, fti)
55: int sd;
56: struct FTAMgroup *ftg;
57: struct FTAMindication *fti;
58: {
59: return FGroupResponse (sd, ftg, FTI_BULKEND, FSB_INITIALIZED, fti);
60: }
61:
62: /* F-GROUP.RESPONSE (group) */
63:
64: static int FGroupResponse (sd, ftg, type, state, fti)
65: int sd;
66: struct FTAMgroup *ftg;
67: int type,
68: state;
69: struct FTAMindication *fti;
70: {
71: SBV smask;
72: int result;
73: register struct ftamblk *fsb;
74:
75: missingP (ftg);
76: missingP (fti);
77:
78: smask = sigioblock ();
79:
80: ftamPsig (fsb, sd);
81:
82: if ((result = frgrpchk (fsb, ftg, type, fti)) != NOTOK)
83: result = FGroupResponseAux (fsb, ftg, state, fti);
84:
85: (void) sigiomask (smask);
86:
87: return result;
88: }
89:
90: /* */
91:
92: static int FGroupResponseAux (fsb, ftg, state, fti)
93: register struct ftamblk *fsb;
94: register struct FTAMgroup *ftg;
95: int state;
96: struct FTAMindication *fti;
97: {
98: register int i;
99: int did_loop,
100: npdu,
101: result,
102: okstate;
103: char **txp,
104: *texts[NPDATA];
105: PE pe,
106: *pep,
107: info[NPDATA];
108: struct PSAPindication pis;
109: struct PSAPindication *pi = &pis;
110: struct PSAPabort *pa = &pi -> pi_abort;
111: struct type_FTAM_PDU **pdup,
112: *pdus[NPDATA];
113:
114: bzero ((char *) texts, sizeof texts);
115: bzero ((char *) info, sizeof info);
116: bzero ((char *) pdus, sizeof pdus);
117:
118: did_loop = 0;
119: if ((result = frgrp2pdus (fsb, ftg, pdus, texts, &npdu, fti)) == NOTOK)
120: goto out;
121: for (pdup = pdus, pep = info, txp = texts, i = npdu - 1;
122: i >= 0;
123: pdup++, pep++, txp++, i--) {
124: pe = NULLPE;
125: if (encode_FTAM_PDU (&pe, 1, 0, NULLCP, *pdup) == NOTOK) {
126: result = ftamlose (fti, FS_GEN (fsb), 1, NULLCP,
127: "error encoding PDU: %s", PY_pepy);
128: goto out;
129: }
130: (*pep = pe) -> pe_context = fsb -> fsb_id;
131:
132: fsbtrace (fsb, (fsb -> fsb_fd, "P-DATA.REQUEST", *txp, pe, 0));
133: }
134: did_loop = 1;
135:
136: result = PDataRequest (fsb -> fsb_fd, info, npdu, pi);
137:
138: out: ;
139: for (pdup = pdus, pep = info, i = NPDATA - 1;
140: i >= 0;
141: pdup++, pep++, i--) {
142: if (*pep)
143: pe_free (*pep);
144: if (*pdup)
145: free_FTAM_PDU (*pdup);
146: }
147:
148: if (result == NOTOK) {
149: if (did_loop)
150: (void) ps2ftamlose (fsb, fti, "PDataRequest", pa);
151: if (fti -> fti_abort.fta_action == FACTION_PERM)
152: freefsblk (fsb);
153:
154: return NOTOK;
155: }
156:
157: switch (state) {
158: case FSB_DATAIDLE:
159: if (ftg -> ftg_flags & FTG_SELECT)
160: okstate = ftg -> ftg_select.ftse_state;
161: else
162: okstate = ftg -> ftg_create.ftce_state;
163: if (okstate != FSTATE_SUCCESS
164: || ftg -> ftg_open.ftop_state != FSTATE_SUCCESS) {
165: fsb -> fsb_state = FSB_INITIALIZED;
166: break;
167: } /* else fall */
168:
169: default:
170: fsb -> fsb_state = state;
171: break;
172: }
173:
174: return OK;
175: }
176:
177: /* */
178:
179: static int frgrpchk (fsb, ftg, type, fti)
180: register struct ftamblk *fsb;
181: register struct FTAMgroup *ftg;
182: int type;
183: struct FTAMindication *fti;
184: {
185: if (fsb -> fsb_flags & FSB_INIT)
186: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP, "not responder");
187: switch (fsb -> fsb_state) {
188: case FSB_MANAGEMENT:
189: if (type != FTI_MANAGEMENT)
190: goto wrong_state;
191: if (ftg -> ftg_flags & ~fsb -> fsb_group) {
192: reply_mismatch: ;
193: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
194: "group reply mismatch; expecting 0x%x, found 0x%x",
195: fsb -> fsb_group, ftg -> ftg_flags);
196: }
197: break;
198:
199: case FSB_BULKBEGIN:
200: if (type != FTI_BULKBEGIN)
201: goto wrong_state;
202: if (ftg -> ftg_flags & ~fsb -> fsb_group)
203: goto reply_mismatch;
204: break;
205:
206: case FSB_BULKEND:
207: if (type != FTI_BULKEND)
208: goto wrong_state;
209: if (ftg -> ftg_flags & ~fsb -> fsb_group)
210: goto reply_mismatch;
211: break;
212:
213: default:
214: wrong_state: ;
215: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP, "wrong state");
216: }
217:
218: if (ftg -> ftg_flags & FTG_SELECT) {
219: register struct FTAMselect *ftse = &ftg -> ftg_select;
220:
221: switch (ftse -> ftse_state) {
222: case FSTATE_SUCCESS:
223: case FSTATE_FAILURE:
224: break;
225:
226: default:
227: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
228: "bad value for select state parameter");
229: }
230: switch (ftse -> ftse_action) {
231: case FACTION_SUCCESS:
232: case FACTION_TRANS:
233: case FACTION_PERM:
234: break;
235:
236: default:
237: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
238: "bad value for select action parameter");
239: }
240: if (ftse -> ftse_attrs.fa_present != FA_FILENAME)
241: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
242: "only filename should be present");
243: if (ftse -> ftse_ndiag > NFDIAG)
244: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
245: "too many select diagnostics");
246: }
247:
248: if (ftg -> ftg_flags & FTG_CREATE) {
249: register struct FTAMcreate *ftce = &ftg -> ftg_create;
250:
251: switch (ftce -> ftce_state) {
252: case FSTATE_SUCCESS:
253: case FSTATE_FAILURE:
254: break;
255:
256: default:
257: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
258: "bad value for create state parameter");
259: }
260: switch (ftce -> ftce_action) {
261: case FACTION_SUCCESS:
262: case FACTION_TRANS:
263: case FACTION_PERM:
264: break;
265:
266: default:
267: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
268: "bad value for create action parameter");
269: }
270: if (!(ftce -> ftce_attrs.fa_present & FA_FILENAME))
271: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
272: "filename not present");
273: if (!(ftce -> ftce_attrs.fa_present & FA_ACTIONS))
274: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
275: "permitted-actions not present");
276: if (!(ftce -> ftce_attrs.fa_present & FA_CONTENTS))
277: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
278: "contents-type not present");
279: if (ftce -> ftce_attrs.fa_present & ~FA_CRE_ATTRS)
280: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
281: "illegal attributes present");
282: if (!(fsb -> fsb_attrs & FATTR_STORAGE)
283: && (ftce -> ftce_attrs.fa_present & FA_STORAGE))
284: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
285: "storage attributes not permitted");
286: if (!(fsb -> fsb_attrs & FATTR_SECURITY)
287: && (ftce -> ftce_attrs.fa_present & FA_SECURITY))
288: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
289: "security attributes not permitted");
290: if (ftce -> ftce_ndiag > NFDIAG)
291: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
292: "too many create diagnostics");
293: }
294:
295: if (ftg -> ftg_flags & FTG_CLOSE) {
296: register struct FTAMclose *ftcl = &ftg -> ftg_close;
297:
298: switch (ftcl -> ftcl_action) {
299: case FACTION_SUCCESS:
300: case FACTION_TRANS:
301: case FACTION_PERM:
302: break;
303:
304: default:
305: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
306: "bad value for close action parameter");
307: }
308: if (ftcl -> ftcl_ndiag > NFDIAG)
309: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
310: "too many close diagnostics");
311: }
312:
313: if (ftg -> ftg_flags & FTG_RDATTR) {
314: register struct FTAMreadattr *ftra = &ftg -> ftg_readattr;
315:
316: switch (ftra -> ftra_action) {
317: case FACTION_SUCCESS:
318: case FACTION_TRANS:
319: case FACTION_PERM:
320: break;
321:
322: default:
323: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
324: "bad value for read attribute action parameter");
325: }
326: if (!(fsb -> fsb_attrs & FATTR_STORAGE)
327: && (ftra -> ftra_attrs.fa_present & FA_STORAGE))
328: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
329: "storage attributes not permitted");
330: if (!(fsb -> fsb_attrs & FATTR_SECURITY)
331: && (ftra -> ftra_attrs.fa_present & FA_SECURITY))
332: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
333: "security attributes not permitted");
334: if (ftra -> ftra_ndiag > NFDIAG)
335: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
336: "too many read attribute diagnostics");
337: }
338:
339: if (ftg -> ftg_flags & FTG_CHATTR) {
340: register struct FTAMchngattr *ftca = &ftg -> ftg_chngattr;
341:
342: switch (ftca -> ftca_action) {
343: case FACTION_SUCCESS:
344: case FACTION_TRANS:
345: case FACTION_PERM:
346: break;
347:
348: default:
349: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
350: "bad value for change attribute action parameter");
351: }
352: if (!(fsb -> fsb_attrs & FATTR_STORAGE)
353: && (ftca -> ftca_attrs.fa_present & FA_STORAGE))
354: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
355: "storage attributes not permitted");
356: if (!(fsb -> fsb_attrs & FATTR_SECURITY)
357: && (ftca -> ftca_attrs.fa_present & FA_SECURITY))
358: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
359: "security attributes not permitted");
360: if (ftca -> ftca_attrs.fa_present & FA_CONTROL)
361: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
362: "encoding of access-control not supported (yet)");
363: if (ftca -> ftca_ndiag > NFDIAG)
364: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
365: "too many change attribute diagnostics");
366: }
367:
368: if (ftg -> ftg_flags & FTG_DESELECT) {
369: register struct FTAMdeselect *ftde = &ftg -> ftg_deselect;
370:
371: switch (ftde -> ftde_action) {
372: case FACTION_SUCCESS:
373: case FACTION_TRANS:
374: case FACTION_PERM:
375: break;
376:
377: default:
378: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
379: "bad value for deselect action parameter");
380: }
381: if (!(fsb -> fsb_flags & FSB_DECHARGE)
382: && ftde -> ftde_charges.fc_ncharge > 0)
383: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
384: "deselect not permitted to include charges");
385: if (ftde -> ftde_charges.fc_ncharge > NFCHRG)
386: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
387: "too many deselect charges");
388: if (ftde -> ftde_ndiag > NFDIAG)
389: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
390: "too many deselect diagnostics");
391: }
392:
393: if (ftg -> ftg_flags & FTG_DELETE) {
394: register struct FTAMdelete *ftxe = &ftg -> ftg_delete;
395:
396: switch (ftxe -> ftxe_action) {
397: case FACTION_SUCCESS:
398: case FACTION_TRANS:
399: case FACTION_PERM:
400: break;
401:
402: default:
403: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
404: "bad value for delete action parameter");
405: }
406: if (ftxe -> ftxe_charges.fc_ncharge > NFCHRG)
407: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
408: "too many delete charges");
409: if (ftxe -> ftxe_ndiag > NFDIAG)
410: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
411: "too many delete diagnostics");
412: }
413:
414: if (ftg -> ftg_flags & FTG_OPEN) {
415: register struct FTAMopen *ftop = &ftg -> ftg_open;
416: register struct FTAMconcurrency *fc;
417:
418: switch (ftop -> ftop_state) {
419: case FSTATE_SUCCESS:
420: case FSTATE_FAILURE:
421: break;
422:
423: default:
424: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
425: "bad value for open state parameter");
426: }
427: switch (ftop -> ftop_action) {
428: case FACTION_SUCCESS:
429: case FACTION_TRANS:
430: case FACTION_PERM:
431: break;
432:
433: default:
434: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
435: "bad value for open action parameter");
436: }
437: if (ftop -> ftop_contents == NULLOID)
438: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
439: "missing open contents type parameter");
440: if (fsb -> fsb_attrs & FATTR_STORAGE) {
441: fc = &ftop -> ftop_conctl;
442: if (fc -> fc_readattrlock != FLOCK_NOTREQD
443: || fc -> fc_chngattrlock != FLOCK_NOTREQD
444: || fc -> fc_deletelock != FLOCK_NOTREQD)
445: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
446: "bad settings for open concurrency control");
447: }
448: if (ftop -> ftop_ndiag > NFDIAG)
449: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
450: "too many open diagnostics");
451: }
452:
453: return OK;
454: }
455:
456: /* */
457:
458: static int frgrp2pdus (fsb, ftg, pdus, texts, npdu, fti)
459: register struct ftamblk *fsb;
460: register struct FTAMgroup *ftg;
461: struct type_FTAM_PDU *pdus[];
462: char *texts[];
463: int *npdu;
464: struct FTAMindication *fti;
465: {
466: int flags,
467: i;
468: register struct type_FTAM_PDU *pdu;
469:
470: i = 0;
471:
472: #define new_pdu(t,o,u,x) \
473: register struct t *req; \
474: \
475: if ((pdu = (struct type_FTAM_PDU *) calloc (1, sizeof *pdu)) == NULL) \
476: goto no_mem; \
477: pdus[i] = pdu; \
478: pdu -> offset = o; \
479: texts[i++] = x; \
480: if ((req = (struct t *) calloc (1, sizeof *req)) == NULL) \
481: goto no_mem; \
482: pdu -> un.u = req;
483:
484: #define new_state(s) \
485: if (s != int_FTAM_State__Result_success) { \
486: if ((req -> state__result = \
487: (struct type_FTAM_State__Result *) \
488: calloc (1, sizeof *req -> state__result)) \
489: == NULL) \
490: goto no_mem; \
491: req -> state__result -> parm = s; \
492: }
493:
494: #define new_action(a) \
495: if (a != int_FTAM_Action__Result_success) { \
496: if ((req -> action__result = \
497: (struct type_FTAM_Action__Result *) \
498: calloc (1, sizeof *req -> action__result)) \
499: == NULL) \
500: goto no_mem; \
501: req -> action__result -> parm = a; \
502: }
503:
504: if ((flags = ftg -> ftg_flags) & FTG_SELECT) {
505: if (ftg -> ftg_select.ftse_state == FSTATE_FAILURE)
506: flags &= FTG_BEGIN | FTG_SELECT | FTG_END;
507: }
508: else
509: if (flags & FTG_CREATE) {
510: if (ftg -> ftg_create.ftce_state == FSTATE_FAILURE)
511: flags &= FTG_BEGIN | FTG_CREATE | FTG_END;
512: }
513:
514: if (flags & FTG_BEGIN) {
515: if ((pdu = (struct type_FTAM_PDU *) calloc (1, sizeof *pdu)) == NULL)
516: goto no_mem;
517: pdus[i] = pdu;
518: pdu -> offset = type_FTAM_PDU_f__begin__group__response;
519: texts[i++] = "F-BEGIN-GROUP-response";
520: }
521:
522: if (flags & FTG_SELECT) {
523: register struct FTAMselect *ftse = &ftg -> ftg_select;
524:
525: new_pdu (type_FTAM_F__SELECT__response,
526: type_FTAM_PDU_f__select__response,
527: f__select__response, "F-SELECT-response");
528: new_state (ftse -> ftse_state);
529: new_action (ftse -> ftse_action);
530: if ((req -> attributes = attr2fpm (fsb, &ftse -> ftse_attrs, fti))
531: == NULL)
532: return NOTOK;
533: if (ftse -> ftse_sharedASE
534: && (req -> shared__ASE__information =
535: shared2fpm (fsb, ftse -> ftse_sharedASE, fti)) == NULL)
536: return NOTOK;
537: if (ftse -> ftse_ndiag > 0
538: && (req -> diagnostic = diag2fpm (fsb, 0, ftse -> ftse_diags,
539: ftse -> ftse_ndiag, fti))
540: == NULL)
541: return NOTOK;
542: }
543:
544: if (flags & FTG_CREATE) {
545: register struct FTAMcreate *ftce = &ftg -> ftg_create;
546:
547: new_pdu (type_FTAM_F__CREATE__response,
548: type_FTAM_PDU_f__create__response,
549: f__create__response, "F-CREATE-response");
550: new_state (ftce -> ftce_state);
551: new_action (ftce -> ftce_action);
552: if ((req -> initial__attributes = attr2fpm (fsb, &ftce -> ftce_attrs,
553: fti)) == NULL)
554: return NOTOK;
555: if (ftce -> ftce_sharedASE
556: && (req -> shared__ASE__information =
557: shared2fpm (fsb, ftce -> ftce_sharedASE, fti)) == NULL)
558: return NOTOK;
559: if (ftce -> ftce_ndiag > 0
560: && (req -> diagnostic = diag2fpm (fsb, 0, ftce -> ftce_diags,
561: ftce -> ftce_ndiag, fti))
562: == NULL)
563: return NOTOK;
564: }
565:
566: if (flags & FTG_CLOSE) {
567: register struct FTAMclose *ftcl = &ftg -> ftg_close;
568:
569: new_pdu (type_FTAM_F__CLOSE__response,
570: type_FTAM_PDU_f__close__response,
571: f__close__response, "F-CLOSE-response");
572: new_action (ftcl -> ftcl_action);
573: if (ftcl -> ftcl_sharedASE
574: && (req -> shared__ASE__information =
575: shared2fpm (fsb, ftcl -> ftcl_sharedASE, fti)) == NULL)
576: return NOTOK;
577: if (ftcl -> ftcl_ndiag > 0
578: && (req -> diagnostic = diag2fpm (fsb, 0, ftcl -> ftcl_diags,
579: ftcl -> ftcl_ndiag, fti))
580: == NULL)
581: return NOTOK;
582: }
583:
584: if (flags & FTG_RDATTR) {
585: register struct FTAMreadattr *ftra = &ftg -> ftg_readattr;
586:
587: new_pdu (type_FTAM_F__READ__ATTRIB__response,
588: type_FTAM_PDU_f__read__attrib__response,
589: f__read__attrib__response, "F-READ-ATTRIB-response");
590: new_action (ftra -> ftra_action);
591: if (ftra -> ftra_attrs.fa_present
592: && (req -> attributes = attr2fpm (fsb, &ftra -> ftra_attrs,
593: fti)) == NULL)
594: return NOTOK;
595: if (ftra -> ftra_ndiag > 0
596: && (req -> diagnostic = diag2fpm (fsb, 0, ftra -> ftra_diags,
597: ftra -> ftra_ndiag, fti))
598: == NULL)
599: return NOTOK;
600: }
601:
602: if (flags & FTG_CHATTR) {
603: register struct FTAMchngattr *ftca = &ftg -> ftg_chngattr;
604:
605: new_pdu (type_FTAM_F__CHANGE__ATTRIB__response,
606: type_FTAM_PDU_f__change__attrib__response,
607: f__change__attrib__response, "F-CHANGE-ATTRIB-response");
608: new_action (ftca -> ftca_action);
609: if (ftca -> ftca_attrs.fa_present
610: && (req -> attributes = attr2fpm (fsb, &ftca -> ftca_attrs,
611: fti)) == NULL)
612: return NOTOK;
613: if (ftca -> ftca_ndiag > 0
614: && (req -> diagnostic = diag2fpm (fsb, 0, ftca -> ftca_diags,
615: ftca -> ftca_ndiag, fti))
616: == NULL)
617: return NOTOK;
618: }
619:
620: if (flags & FTG_DESELECT) {
621: register struct FTAMdeselect *ftde = &ftg -> ftg_deselect;
622:
623: new_pdu (type_FTAM_F__DESELECT__response,
624: type_FTAM_PDU_f__deselect__response,
625: f__deselect__response, "F-DESELECT-response");
626: new_action (ftde -> ftde_action);
627: if (ftde -> ftde_sharedASE
628: && (req -> shared__ASE__information =
629: shared2fpm (fsb, ftde -> ftde_sharedASE, fti)) == NULL)
630: return NOTOK;
631: if (ftde -> ftde_charges.fc_ncharge
632: && (req -> charging = chrg2fpm (fsb, &ftde -> ftde_charges,
633: fti)) == NULL)
634: return NOTOK;
635: if (ftde -> ftde_ndiag > 0
636: && (req -> diagnostic = diag2fpm (fsb, 0, ftde -> ftde_diags,
637: ftde -> ftde_ndiag, fti))
638: == NULL)
639: return NOTOK;
640: }
641:
642: if (flags & FTG_DELETE) {
643: register struct FTAMdelete *ftxe = &ftg -> ftg_delete;
644:
645: new_pdu (type_FTAM_F__DELETE__response,
646: type_FTAM_PDU_f__delete__response,
647: f__delete__response, "F-DELETE-response");
648: new_action (ftxe -> ftxe_action);
649: if (ftxe -> ftxe_sharedASE
650: && (req -> shared__ASE__information =
651: shared2fpm (fsb, ftxe -> ftxe_sharedASE, fti)) == NULL)
652: return NOTOK;
653: if (ftxe -> ftxe_charges.fc_ncharge
654: && (req -> charging = chrg2fpm (fsb, &ftxe -> ftxe_charges,
655: fti)) == NULL)
656: return NOTOK;
657: if (ftxe -> ftxe_ndiag > 0
658: && (req -> diagnostic = diag2fpm (fsb, 0, ftxe -> ftxe_diags,
659: ftxe -> ftxe_ndiag, fti))
660: == NULL)
661: return NOTOK;
662: }
663:
664: if (flags & FTG_OPEN) {
665: register struct FTAMopen *ftop = &ftg -> ftg_open;
666: register struct type_FTAM_Contents__Type__Attribute *proposed;
667:
668: new_pdu (type_FTAM_F__OPEN__response,
669: type_FTAM_PDU_f__open__response,
670: f__open__response, "F-OPEN-response");
671: new_state (ftop -> ftop_state);
672: new_action (ftop -> ftop_action);
673: if ((proposed = (struct type_FTAM_Contents__Type__Attribute *)
674: calloc (1, sizeof *proposed)) == NULL)
675: goto no_mem;
676: req -> contents__type = proposed;
677: if ((proposed -> document__type__name =
678: oid_cpy (ftop -> ftop_contents)) == NULLOID)
679: goto no_mem;
680: if (proposed -> parameter = ftop -> ftop_parameter)
681: proposed -> parameter -> pe_refcnt++;
682: if (conctl_present (&ftop -> ftop_conctl)
683: && (req -> concurrency__control =
684: conctl2fpm (fsb, &ftop -> ftop_conctl, fti))
685: == NULL)
686: return NOTOK;
687: if (ftop -> ftop_sharedASE
688: && (req -> shared__ASE__information =
689: shared2fpm (fsb, ftop -> ftop_sharedASE, fti)) == NULL)
690: return NOTOK;
691: if (ftop -> ftop_ndiag > 0
692: && (req -> diagnostic = diag2fpm (fsb, 0, ftop -> ftop_diags,
693: ftop -> ftop_ndiag, fti))
694: == NULL)
695: return NOTOK;
696: }
697:
698: if (flags & FTG_END) {
699: if ((pdu = (struct type_FTAM_PDU *) calloc (1, sizeof *pdu)) == NULL)
700: goto no_mem;
701: pdus[i] = pdu;
702: pdu -> offset = type_FTAM_PDU_f__end__group__response;
703: texts[i++] = "F-END-GROUP-response";
704: }
705:
706: *npdu = i;
707: return OK;
708:
709: #undef new_pdu
710: #undef new_state
711: #undef new_action
712:
713: no_mem: ;
714: return ftamlose (fti, FS_GEN (fsb), 1, NULLCP, "out of memory");
715: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.