![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ftaminitiate.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 ftaminitiate.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / ftam |
1.1 root 1: /* ftaminitiate.c - FPM: initiator */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/ftam/RCS/ftaminitiate.c,v 7.0 89/11/23 21:53:41 mrose Rel $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/ftam/RCS/ftaminitiate.c,v 7.0 89/11/23 21:53:41 mrose Rel $
9: *
10: *
11: * $Log: ftaminitiate.c,v $
12: * Revision 7.0 89/11/23 21:53:41 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:
35: #define FS_CTX "iso ftam"
36: #define FS_ASN "ftam pci"
37:
38: /* F-INITIALIZE.REQUEST */
39:
40: int FInitializeRequest (context, callingtitle, calledtitle, callingaddr,
41: calledaddr, manage, class, units, attrs, sharedASE, fqos, contents,
42: initiator, account, password, passlen, qos, tracing, ftc, fti)
43: OID context;
44: AEI callingtitle,
45: calledtitle;
46: struct PSAPaddr *callingaddr,
47: *calledaddr;
48: int manage,
49: class,
50: units,
51: attrs,
52: fqos,
53: passlen;
54: PE sharedASE;
55: struct FTAMcontentlist *contents;
56: char *initiator,
57: *account,
58: *password;
59: struct QOStype *qos;
60: IFP tracing;
61: struct FTAMconnect *ftc;
62: struct FTAMindication *fti;
63: {
64: SBV smask;
65: int result;
66:
67: #ifdef notdef
68: missingP (context);
69: missingP (callingtitle);
70: missingP (calledtitle);
71: missingP (callingaddr);
72: #endif
73: missingP (calledaddr);
74: if (manage)
75: return ftamlose (fti, FS_ACS_CONTEXT, 1, NULLCP, NULLCP);
76: if (units & ~MY_FUNIT)
77: return ftamlose (fti, FS_ACS_FUNIT, 1, NULLCP, NULLCP);
78: if (!(units & FUNIT_LIMITED) && (units & FUNIT_ENHANCED))
79: return ftamlose (fti, FS_GEN_NOREASON, 1, NULLCP,
80: "enhanced-file-management requires limited-file-management");
81: if ((class & FCLASS_TRANSFER
82: && ((units & FUNITS_TRANSFER) != FUNITS_TRANSFER))) {
83: not_enough: ;
84: return ftamlose (fti, FS_GEN_NOREASON, 1, NULLCP,
85: "insufficient functional units for service class");
86: }
87: if ((class & FCLASS_TM) && ((units & FUNITS_TM) != FUNITS_TM))
88: goto not_enough;
89: if ((class & (FCLASS_TRANSFER | FCLASS_TM))
90: && !(units & (FUNIT_READ | FUNIT_WRITE)))
91: goto not_enough;
92: if ((class & FCLASS_ACCESS) && ((units & FUNITS_ACCESS) != FUNITS_ACCESS))
93: goto not_enough;
94: if ((class & FCLASS_MANAGE) && ((units & FUNITS_MANAGE) != FUNITS_MANAGE))
95: goto not_enough;
96: if (!(class &=
97: (FCLASS_TRANSFER | FCLASS_TM | FCLASS_MANAGE | FCLASS_ACCESS)))
98: return ftamlose (fti, FS_ACS_CLASS, 1, NULLCP, NULLCP);
99: if (!(units & FUNIT_LIMITED) && (units & FUNIT_ENHANCED))
100: return ftamlose (fti, FS_GEN_NOREASON, 1, NULLCP,
101: "enhanced-file-management requires limited-file-management");
102: if (!(units & FUNIT_GROUPING)) /* XXX: should be OPTIONAL */
103: goto not_enough;
104: if (attrs & ~MY_FATTR)
105: return ftamlose (fti, FS_ACS_GRPSUP, 1, NULLCP, NULLCP);
106: if ((attrs & FATTR_SECURITY) && !(attrs & FATTR_STORAGE))
107: return ftamlose (fti, FS_ACS_GRP, 1, NULLCP, NULLCP);
108: if (contents && contents -> fc_ncontent > NFCONT)
109: return ftamlose (fti, FS_GEN_NOREASON, 1, NULLCP,
110: "too many content types");
111: if (password == NULL)
112: passlen = 0;
113: #ifdef notdef
114: missingP (qos);
115: #endif
116: missingP (fti);
117:
118: smask = sigioblock ();
119:
120: result = FInitializeRequestAux (context, callingtitle, calledtitle,
121: callingaddr, calledaddr, manage, class, units, attrs, sharedASE, fqos,
122: contents, initiator, account, password, passlen, qos, tracing, ftc,
123: fti);
124:
125: (void) sigiomask (smask);
126:
127: return result;
128: }
129:
130: /* */
131:
132: static int FInitializeRequestAux (context, callingtitle, calledtitle,
133: callingaddr, calledaddr, manage, class, units, attrs, sharedASE, fqos,
134: contents, initiator, account, password, passlen, qos, tracing, ftc,
135: fti)
136: OID context;
137: AEI callingtitle,
138: calledtitle;
139: struct PSAPaddr *callingaddr,
140: *calledaddr;
141: int manage,
142: class,
143: units,
144: attrs,
145: fqos,
146: passlen;
147: PE sharedASE;
148: struct FTAMcontentlist *contents;
149: char *initiator,
150: *account,
151: *password;
152: struct QOStype *qos;
153: IFP tracing;
154: struct FTAMconnect *ftc;
155: struct FTAMindication *fti;
156: {
157: register int i;
158: int bits,
159: idc,
160: result,
161: settings;
162: long isn;
163: PE pe;
164: OID ctx,
165: pci;
166: struct SSAPref *sr;
167: register struct PSAPcontext *px;
168: struct PSAPctxlist pls;
169: register struct PSAPctxlist *pl = &pls;
170: struct AcSAPconnect accs;
171: register struct AcSAPconnect *acc = &accs;
172: register struct PSAPconnect *pc = &acc -> acc_connect;
173: struct AcSAPindication acis;
174: register struct AcSAPindication *aci = &acis;
175: register struct AcSAPabort *aca = &aci -> aci_abort;
176: register struct FTAMcontent *fx;
177: register struct ftamblk *fsb;
178: struct type_FTAM_PDU *pdu;
179: register struct type_FTAM_F__INITIALIZE__request *req;
180: register struct type_FTAM_F__INITIALIZE__response *rsp;
181:
182: if ((fsb = newfsblk ()) == NULL)
183: return ftamlose (fti, FS_GEN_NOREASON, 1, NULLCP, "out of memory");
184: fsb -> fsb_flags |= FSB_INIT;
185: fsb -> fsb_trace = tracing;
186:
187: ctx = pci = NULLOID, pl -> pc_nctx = 0;
188: bzero ((char *) ftc, sizeof *ftc);
189:
190: pdu = NULL;
191:
192: if (context == NULLOID && (context = ode2oid (FS_CTX)) == NULLOID) {
193: result = ftamlose (fti, FS_ACS_MGMT, 1, NULLCP, "%s: unknown", FS_CTX);
194: goto out1;
195: }
196: if ((ctx = oid_cpy (context)) == NULLOID) {
197: no_mem: ;
198: result = ftamlose (fti, FS_GEN_NOREASON, 1, NULLCP, "out of memory");
199: goto out1;
200: }
201:
202: if ((pci = ode2oid (FS_ASN)) == NULLOID) {
203: result = ftamlose (fti, FS_ACS_MGMT, 1, NULLCP, "%s: unknown", FS_ASN);
204: goto out1;
205: }
206: if ((pci = oid_cpy (pci)) == NULLOID)
207: goto no_mem;
208:
209: px = pl -> pc_ctx, pl -> pc_nctx = 0;
210:
211: px -> pc_id = fsb -> fsb_id = idc = 1;
212: if ((px -> pc_asn = ode2oid (FS_ASN)) == NULLOID) {
213: result = ftamlose (fti, FS_ACS_MGMT, 1, NULLCP, "%s: unknown", FS_ASN);
214: goto out1;
215: }
216: if ((px -> pc_asn = oid_cpy (px -> pc_asn)) == NULLOID)
217: goto no_mem;
218: if ((px -> pc_atn = ode2oid (BER)) == NULLOID) {
219: result = ftamlose (fti, FS_ACS_MGMT, 1, NULLCP, "%s: unknown", BER);
220: goto out1;
221: }
222: if ((px -> pc_atn = oid_cpy (px -> pc_atn)) == NULLOID)
223: goto no_mem;
224: px++, pl -> pc_nctx++;
225:
226: if (contents) {
227: register struct isodocument *id;
228:
229: for (fx = contents -> fc_contents, i = contents -> fc_ncontent - 1;
230: i >= 0;
231: fx++, i--) {
232: if (fx -> fc_dtn == NULLOID) {
233: result = ftamlose (fti, FS_GEN (fsb), 1, NULLCP,
234: "empty content type at slot %d",
235: contents -> fc_ncontent - i - 1);
236: goto out1;
237: }
238:
239: if ((id = getisodocumentbytype (fx -> fc_dtn)) == NULL) {
240: result = ftamlose (fti, FS_GEN (fsb), 1, NULLCP,
241: "unknown document type %s at slot %d",
242: sprintoid (fx -> fc_dtn),
243: contents -> fc_ncontent - i - 1);
244: goto out1;
245: }
246:
247: px -> pc_id = (idc += 2);
248: if ((px -> pc_asn = oid_cpy (id -> id_abstract)) == NULLOID)
249: goto no_mem;
250: if ((px -> pc_atn = oid_cpy (id -> id_transfer)) == NULLOID)
251: goto no_mem;
252: px++, pl -> pc_nctx++;
253: }
254: }
255:
256: if ((pdu = (struct type_FTAM_PDU *) calloc (1, sizeof *pdu)) == NULL)
257: goto no_mem;
258: pdu -> offset = type_FTAM_PDU_f__initialize__request;
259: if ((req = (struct type_FTAM_F__INITIALIZE__request *)
260: calloc (1, sizeof *req)) == NULL)
261: goto no_mem;
262: pdu -> un.f__initialize__request = req;
263: req -> presentation__context__management = manage;
264: if (class != FCLASS_TRANSFER
265: && (req -> service__class = bits2fpm (fsb, fclass_pairs, class,
266: fti)) == NULLPE)
267: goto out1;
268: if ((req -> functional__units = bits2fpm (fsb, funit_pairs, units, fti))
269: == NULLPE)
270: goto out1;
271: if (attrs && (req -> attribute__groups = bits2fpm (fsb, fattr_pairs,
272: attrs, fti)) == NULLPE)
273: goto out1;
274: if (sharedASE
275: && (req -> shared__ASE__information =
276: shared2fpm (fsb, sharedASE, fti)) == NULL)
277: goto out1;
278: if ((req -> ftam__quality__of__service =
279: (struct type_FTAM_FTAM__Quality__Of__Service *)
280: calloc (1, sizeof *req -> ftam__quality__of__service))
281: == NULL)
282: goto no_mem;
283: #ifdef lint
284: req -> ftam__quality__of__service -> parm = fqos;
285: #else
286: req -> ftam__quality__of__service -> parm = MY_FQOS;
287: #endif
288: if (contents) {
289: struct type_FTAM_Contents__Type__List *fpm;
290: register struct type_FTAM_Contents__Type__List **fpc;
291:
292: fpc = &req -> contents__type__list;
293: for (fx = contents -> fc_contents, i = contents -> fc_ncontent - 1;
294: i >= 0;
295: fx++, i--) {
296: if ((fpm = (struct type_FTAM_Contents__Type__List *)
297: calloc (1, sizeof *fpm)) == NULL)
298: goto no_mem;
299: *fpc = fpm;
300:
301: if ((fpm -> Document__Type__Name = oid_cpy (fx -> fc_dtn))
302: == NULLOID)
303: goto no_mem;
304: fpc = &fpm -> next;
305: }
306: }
307: if (initiator
308: && (req -> initiator__identity = str2qb (initiator,
309: strlen (initiator), 1))
310: == NULL)
311: goto out1;
312: if (account
313: && (req -> account = str2qb (account, strlen (account), 1))
314: == NULL)
315: goto out1;
316: if (password) {
317: register struct type_FTAM_Password *p;
318:
319: if ((p = (struct type_FTAM_Password *) calloc (1, sizeof *p))
320: == NULL)
321: goto no_mem;
322: req -> filestore__password = p;
323: p -> offset = type_FTAM_Password_binary;
324: if ((p -> un.binary = str2qb (password, passlen, 1)) == NULL)
325: goto no_mem;
326: }
327: req -> checkpoint__window = 1;
328:
329: if (encode_FTAM_PDU (&pe, 1, 0, NULLCP, pdu) == NOTOK) {
330: (void) ftamlose (fti, FS_GEN (fsb), 1, NULLCP,
331: "error encoding PDU: %s", PY_pepy);
332: goto out1;
333: }
334:
335: pe -> pe_context = fsb -> fsb_id;
336:
337: fsb -> fsb_srequirements = SR_DUPLEX | SR_RESYNC;
338: fsb -> fsb_srequirements &= ~SR_RESYNC; /* XXX */
339: if (units & (FUNIT_RECOVERY | FUNIT_RESTART))
340: fsb -> fsb_srequirements |= SR_MINORSYNC;
341: isn = (fsb -> fsb_srequirements & (SR_MINORSYNC | SR_RESYNC)) ? 1L
342: : SERIAL_NONE;
343: fsb -> fsb_prequirements = manage ? (PR_MANAGEMENT | PR_RESTORATION) : 0;
344: settings = 0;
345: #define dotoken(requires,shift,bit,type) \
346: { \
347: if (fsb -> fsb_srequirements & requires) \
348: settings |= ST_INIT_VALUE << shift; \
349: }
350: dotokens ();
351: #undef dotoken
352:
353: if ((sr = addr2ref (PLocalHostName ())) == NULL)
354: goto no_mem;
355:
356: fsbtrace (fsb, (fsb -> fsb_fd, "A-ASSOCIATE.REQUEST",
357: "F-INITIALIZE-request", pe, 0));
358:
359: result = AcAssocRequest (ctx, callingtitle, calledtitle, callingaddr,
360: calledaddr, pl, NULLOID /* pci */, fsb -> fsb_prequirements,
361: fsb -> fsb_srequirements, isn, settings, sr, &pe, 1,
362: qos, acc, aci);
363:
364: if (result == NOTOK) {
365: (void) acs2ftamlose (fsb, fti, "AcAssocRequest", aca);
366: goto out1;
367: }
368:
369: fsb -> fsb_fd = acc -> acc_sd;
370:
371: pe_free (pe);
372: pe = NULLPE;
373: free_FTAM_PDU (pdu);
374: pdu = NULL;
375: oid_free (ctx);
376: ctx = NULLOID;
377: oid_free (pci);
378: pci = NULLOID;
379: for (px = pl -> pc_ctx, i = pl -> pc_nctx - 1; i >= 0; px++, i--) {
380: if (px -> pc_asn)
381: oid_free (px -> pc_asn);
382: if (px -> pc_atn)
383: oid_free (px -> pc_atn);
384: }
385:
386: if (acc -> acc_ninfo < 1 || (pe = acc -> acc_info[0]) == NULLPE) {
387: if (acc -> acc_result != ACS_ACCEPT) {
388: register struct FTAMabort *fta = &fti -> fti_abort;
389:
390: aca -> aca_reason = acc -> acc_result;
391: (void) acs2ftamlose (fsb, fti, "AcAssocRequest(pseudo)", aca);
392:
393: ftc -> ftc_sd = NOTOK;
394: ftc -> ftc_state = FSTATE_FAILURE;
395: ftc -> ftc_action = FACTION_PERM;
396: *ftc -> ftc_diags = *fta -> fta_diags; /* struct copy */
397: ftc -> ftc_ndiag = fta -> fta_ndiag;
398:
399: result = OK;
400: }
401: else
402: result = fpktlose (fsb, fti, FS_PRO_ERR, NULLCP, NULLCP);
403: goto out2;
404: }
405:
406: if (decode_FTAM_PDU (pe, 1, NULLIP, NULLVP, &pdu) == NOTOK) {
407: result = fpktlose (fsb, fti, FS_PRO_ERRMSG, NULLCP,
408: "unable to parse PDU: %s", PY_pepy);
409: goto out2;
410: }
411: if (pdu -> offset != type_FTAM_PDU_f__initialize__response) {
412: result = fpktlose (fsb, fti, FS_PRO_ERRPROC, NULLCP,
413: "expecting F-INITIALIZE-response, got %d",
414: pdu -> offset);
415: goto out2;
416: }
417: rsp = pdu -> un.f__initialize__response;
418:
419: fsbtrace (fsb,
420: (fsb -> fsb_fd, "A-ASSOCIATE.CONFIRMATION", "F-INITIALIZE-response",
421: pe, 1));
422:
423: ftc -> ftc_state = rsp -> state__result
424: ? rsp -> state__result -> parm
425: : int_FTAM_State__Result_success;
426: ftc -> ftc_action = rsp -> action__result
427: ? rsp -> action__result -> parm
428: : int_FTAM_Action__Result_success;
429: switch (acc -> acc_result) {
430: case ACS_ACCEPT:
431: if (ftc -> ftc_state != FSTATE_SUCCESS
432: || ftc -> ftc_action != FACTION_SUCCESS) {
433: result = fpktlose (fsb, fti, FS_PRO_ERRPROC, NULLCP,
434: "state/action mismatch");
435: goto out2;
436: }
437:
438: fsb -> fsb_flags |= FSB_CONN;
439: fsb -> fsb_srequirements &= pc -> pc_srequirements;
440: #define dotoken(requires,shift,bit,type) \
441: { \
442: if (fsb -> fsb_srequirements & requires) \
443: switch (pc -> pc_settings & (ST_MASK << shift)) { \
444: case ST_INIT_VALUE << shift: \
445: fsb -> fsb_owned |= bit; \
446: fsb -> fsb_avail |= bit; \
447: break; \
448: \
449: case ST_RESP_VALUE << shift: \
450: fsb -> fsb_avail |= bit; \
451: break; \
452: \
453: default: \
454: result = fpktlose (fsb, fti, FS_PRO_ERRPROC, NULLCP, \
455: "%s token management botched", type); \
456: goto out2; \
457: } \
458: }
459: dotokens ();
460: #undef dotoken
461: if (fsb -> fsb_owned != fsb -> fsb_avail) {
462: result = fpktlose (fsb, fti, FS_PRO_ERRPROC, NULLCP,
463: "token management botched");
464: goto out2;
465: }
466: fsb -> fsb_ssdusize = pc -> pc_ssdusize;
467:
468: pl = &pc -> pc_ctxlist;
469: if (pl -> pc_nctx > 0 && pl -> pc_ctx[0].pc_result != PC_ACCEPT) {
470: result = fpktlose (fsb, fti, FS_PRO_ERRPROC, NULLCP,
471: "FTAM PCI rejected");
472: goto out2;
473: }
474:
475: fsb -> fsb_prequirements &= pc -> pc_prequirements;
476: if (rsp -> presentation__context__management) {
477: if (!(fsb -> fsb_prequirements & PR_MANAGEMENT)) {
478: result = fpktlose (fsb, fti, FS_PRO_ERRPROC, NULLCP,
479: "presentation content management mismatch");
480: goto out2;
481: }
482: }
483: else
484: fsb -> fsb_prequirements &= ~PR_MANAGEMENT;
485:
486: if (rsp -> service__class) {
487: if (fpm2bits (fsb, fclass_pairs, rsp -> service__class, &bits,
488: fti) == NOTOK)
489: goto out2;
490: }
491: else
492: bits = FCLASS_TRANSFER;
493: switch (fsb -> fsb_class = (bits & class)) {
494: case FCLASS_TRANSFER:
495: i = FUNITS_TRANSFER;
496: break;
497:
498: case FCLASS_ACCESS:
499: i = FUNITS_ACCESS;
500: break;
501:
502: case FCLASS_MANAGE:
503: i = FUNITS_MANAGE;
504: break;
505:
506: case FCLASS_TM:
507: i = FUNITS_TM;
508: break;
509:
510: case FCLASS_UNCONS:
511: i = FUNITS_UNCONS;
512: break;
513:
514: default:
515: result = fpktlose (fsb, fti, FS_PRO_ERRPROC, NULLCP,
516: "service class mismatch, offered 0x%x received 0x%x",
517: class, bits);
518: goto out2;
519: }
520: if (fpm2bits (fsb, funit_pairs, rsp -> functional__units, &bits,
521: fti) == NOTOK)
522: goto out2;
523: bits |= i; /* conservative... */
524: if ((fsb -> fsb_units = bits) & ~units) {
525: result = fpktlose (fsb, fti, FS_PRO_ERRFUNIT, NULLCP,
526: "functional unit mismatch");
527: goto out2;
528: }
529: if (!(fsb -> fsb_units & FUNIT_GROUPING)) {
530: /* XXX: should be OPTIONAL */
531: result = fpktlose (fsb, fti, FS_PRO_ERRFUNIT, NULLCP,
532: "insufficient functional units for service class");
533: goto out2;
534: }
535: switch (fsb -> fsb_class) {
536: case FCLASS_TRANSFER:
537: case FCLASS_TM:
538: if (fsb -> fsb_units & (FUNIT_ACCESS | FUNIT_FADULOCK)) {
539: too_many: ;
540: result = fpktlose (fsb, fti, FS_PRO_ERRFUNIT, NULLCP,
541: "illegal functional units for service class");
542: goto out2;
543: }
544: break;
545:
546: case FCLASS_MANAGE:
547: if (fsb -> fsb_units & (FUNIT_READ | FUNIT_WRITE
548: | FUNIT_ACCESS | FUNIT_FADULOCK
549: | FUNIT_RECOVERY
550: | FUNIT_RESTART))
551: goto too_many;
552: break;
553: }
554: if (rsp -> attribute__groups) {
555: if (fpm2bits (fsb, fattr_pairs, rsp -> attribute__groups,
556: &bits, fti) == NOTOK)
557: goto out2;
558: }
559: else
560: bits = 0;
561: if (bits & ~attrs) {
562: result = fpktlose (fsb, fti, FS_PRO_ERRPROC, NULLCP,
563: "attribute group mismatch");
564: goto out2;
565: }
566: fsb -> fsb_attrs = bits;
567: if (rsp -> ftam__quality__of__service -> parm != MY_FQOS) {
568: result = fpktlose (fsb, fti, FS_ACS_ROLLBACK, NULLCP,
569: "class-%d-recovery not supported",
570: rsp -> ftam__quality__of__service -> parm);
571: goto out2;
572: }
573: fsb -> fsb_fqos = MY_FQOS;
574:
575: ftc -> ftc_sd = fsb -> fsb_fd;
576: break;
577:
578: default:
579: ftc -> ftc_sd = NOTOK;
580: if (ftc -> ftc_state == FSTATE_SUCCESS
581: && ftc -> ftc_action == FACTION_SUCCESS) {
582: result = fpktlose (fsb, fti, FS_PRO_ERRPROC, NULLCP,
583: "state/action mismatch");
584: goto out2;
585: }
586: {
587: register struct FTAMabort *fta = &fti -> fti_abort;
588:
589: bzero ((char *) fta, sizeof *fta);
590: fta -> fta_peer = 1;
591: }
592: break;
593: }
594:
595: ftc -> ftc_respondtitle = acc -> acc_respondtitle; /* struct copy */
596: bzero ((char *) &acc -> acc_respondtitle, sizeof acc -> acc_respondtitle);
597: ftc -> ftc_respondaddr = pc -> pc_responding; /* struct copy */
598: ftc -> ftc_context = acc -> acc_context;
599: acc -> acc_context = NULLOID;
600: ftc -> ftc_manage = (fsb -> fsb_prequirements & PR_MANAGEMENT) ? 1 : 0;
601: ftc -> ftc_class = fsb -> fsb_class;
602: ftc -> ftc_units = fsb -> fsb_units;
603: ftc -> ftc_attrs = fsb -> fsb_attrs;
604: if (rsp -> shared__ASE__information
605: && fpm2shared (fsb, rsp -> shared__ASE__information,
606: &ftc -> ftc_sharedASE, fti) == NOTOK)
607: goto out2;
608: ftc -> ftc_fqos = fsb -> fsb_fqos;
609:
610: if (contents) {
611: register struct type_FTAM_Contents__Type__List *dtn;
612: register struct FTAMcontent *fx2;
613:
614: fx2 = ftc -> ftc_contents.fc_contents;
615:
616: for (fx = contents -> fc_contents,
617: i = contents -> fc_ncontent - 1;
618: i >= 0;
619: fx++, i--) {
620: for (dtn = rsp -> contents__type__list; dtn; dtn = dtn -> next)
621: if (oid_cmp (fx -> fc_dtn, dtn -> Document__Type__Name) == 0)
622: break;
623: if (dtn == NULL)
624: continue;
625:
626: px = pl -> pc_ctx + 1 + (fx - contents -> fc_contents);
627:
628: fx2 -> fc_dtn = dtn -> Document__Type__Name;
629: fx2 -> fc_id = px -> pc_id;
630: fx2 -> fc_result = px -> pc_result;
631:
632: fx2++, ftc -> ftc_contents.fc_ncontent++;
633: }
634:
635: for (dtn = rsp -> contents__type__list; dtn; dtn = dtn -> next) {
636: for (fx2 = ftc -> ftc_contents.fc_contents,
637: i = ftc -> ftc_contents.fc_ncontent - 1;
638: i >= 0;
639: fx2++, i--)
640: if (dtn -> Document__Type__Name == fx2 -> fc_dtn) {
641: dtn -> Document__Type__Name = NULLOID;
642: break;
643: }
644: }
645: }
646: if (rsp -> diagnostic)
647: (void) fpm2diag (fsb, rsp -> diagnostic, ftc -> ftc_diags,
648: &ftc -> ftc_ndiag, fti);
649: ftc -> ftc_ssdusize = fsb -> fsb_ssdusize;
650: ftc -> ftc_qos = pc -> pc_qos; /* struct copy */
651:
652: free_FTAM_PDU (pdu);
653: ACCFREE (acc);
654:
655: if (acc -> acc_result != ACS_ACCEPT)
656: freefsblk (fsb);
657:
658: return OK;
659:
660: out2: ;
661: ACCFREE (acc);
662:
663: out1: ;
664: if (pdu)
665: free_FTAM_PDU (pdu);
666: if (ctx)
667: oid_free (ctx);
668: if (pci)
669: oid_free (pci);
670: for (px = pl -> pc_ctx, i = pl -> pc_nctx - 1; i >= 0; px++, i--) {
671: if (px -> pc_asn)
672: oid_free (px -> pc_asn);
673: if (px -> pc_atn)
674: oid_free (px -> pc_atn);
675: }
676: freefsblk (fsb);
677:
678: return result;
679: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.