![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ftamrespond.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 ftamrespond.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / ftam |
1.1 root 1: /* ftamrespond.c - FPM: responder */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/ftam/RCS/ftamrespond.c,v 7.0 89/11/23 21:53:51 mrose Rel $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/ftam/RCS/ftamrespond.c,v 7.0 89/11/23 21:53:51 mrose Rel $
9: *
10: *
11: * $Log: ftamrespond.c,v $
12: * Revision 7.0 89/11/23 21:53:51 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 "fpkt.h"
32:
33: /* F-INITIALIZE.INDICATION */
34:
35: int FInit (vecp, vec, fts, tracing, fti)
36: int vecp;
37: char **vec;
38: struct FTAMstart *fts;
39: IFP tracing;
40: struct FTAMindication *fti;
41: {
42: register int i;
43: PE pe;
44: struct AcSAPstart acss;
45: register struct AcSAPstart *acs = &acss;
46: register struct PSAPstart *ps = &acs -> acs_start;
47: struct AcSAPindication acis;
48: register struct AcSAPindication *aci = &acis;
49: register struct AcSAPabort *aca = &aci -> aci_abort;
50: register struct ftamblk *fsb;
51: struct type_FTAM_PDU *pdu;
52: register struct type_FTAM_F__INITIALIZE__request *req;
53: register struct type_FTAM_F__INITIALIZE__response *rsp;
54:
55: missingP (vec);
56: missingP (fts);
57: missingP (fti);
58:
59: if ((fsb = newfsblk ()) == NULL)
60: return ftamlose (fti, FS_GEN_NOREASON, 0, NULLCP, "out of memory");
61: fsb -> fsb_trace = tracing;
62:
63: bzero ((char *) fts, sizeof *fts);
64:
65: pdu = NULL;
66:
67: if (AcInit (vecp, vec, acs, aci) == NOTOK) {
68: (void) acs2ftamlose (fsb, fti, "AcInit", aca);
69: goto out1;
70: }
71:
72: fsb -> fsb_fd = acs -> acs_sd;
73:
74: fsb -> fsb_srequirements = ps -> ps_srequirements;
75: fsb -> fsb_srequirements &= ~SR_RESYNC; /* XXX */
76: if (!(fsb -> fsb_srequirements & (SR_MINORSYNC | SR_RESYNC)))
77: ps -> ps_isn = SERIAL_NONE;
78:
79: fsb -> fsb_settings = ps -> ps_settings;
80: #define dotoken(requires,shift,bit,type) \
81: { \
82: if (fsb -> fsb_srequirements & requires) \
83: switch (fsb -> fsb_settings & (ST_MASK << shift)) { \
84: case ST_INIT_VALUE << shift: \
85: fsb -> fsb_avail |= bit; \
86: break; \
87: \
88: case ST_RESP_VALUE << shift: \
89: fsb -> fsb_owned |= bit; \
90: fsb -> fsb_avail |= bit; \
91: break; \
92: \
93: default: \
94: (void) ftamoops (fti, FS_PRO_ERRPROC, 1, EREF_RFPM, \
95: EREF_IFPM, NULLCP, \
96: "%s token management botched", type); \
97: goto out2; \
98: } \
99: }
100: dotokens ();
101: #undef dotoken
102: if (fsb -> fsb_owned != 0) {
103: (void) ftamoops (fti, FS_PRO_ERRPROC, 1, EREF_RFPM, EREF_IFPM, NULLCP,
104: "token management botched");
105: goto out2;
106: }
107: fsb -> fsb_ssn = ps -> ps_isn;
108: fsb -> fsb_ssdusize = ps -> ps_ssdusize;
109: fsb -> fsb_connect = ps -> ps_connect; /* struct copy */
110: fsb -> fsb_prequirements = ps -> ps_prequirements;
111:
112: if (acs -> acs_ninfo < 1 || (pe = acs -> acs_info[0]) == NULLPE) {
113: (void) ftamoops (fti, FS_PRO_ERR, 1, EREF_RFPM, EREF_IFPM, NULLCP,
114: NULLCP);
115: goto out2;
116: }
117:
118: if (decode_FTAM_PDU (pe, 1, NULLIP, NULLVP, &pdu) == NOTOK) {
119: (void) ftamoops (fti, FS_PRO_ERRMSG, 1, EREF_RFPM, EREF_RFPM,
120: NULLCP, "unable to parse PDU: %s", PY_pepy);
121: goto out3;
122: }
123: if (pdu -> offset != type_FTAM_PDU_f__initialize__request) {
124: (void) ftamoops (fti, FS_PRO_ERRPROC, 1, EREF_RFPM, EREF_RFPM,
125: NULLCP, "expecting F-INITIALIZE-request, got %d",
126: pdu -> offset);
127: goto out3;
128: }
129: req = pdu -> un.f__initialize__request;
130:
131: fsbtrace (fsb, (fsb -> fsb_fd, "A-ASSOCIATE.INDICATION",
132: "F-INITIALIZE-request", pe, 1));
133:
134: fsb -> fsb_id = pe -> pe_context;
135:
136: if (req -> presentation__context__management) {
137: if (!(fsb -> fsb_prequirements & PR_MANAGEMENT)) {
138: req -> presentation__context__management = 0;
139: fsb -> fsb_prequirements &= ~PR_RESTORATION;
140: }
141: }
142: else
143: fsb -> fsb_prequirements &= ~(PR_MANAGEMENT | PR_RESTORATION);
144: if (req -> service__class) {
145: if (fpm2bits (fsb, fclass_pairs, req -> service__class,
146: &fsb -> fsb_class, fti) == NOTOK)
147: goto out3;
148: }
149: else
150: fsb -> fsb_class = FCLASS_TRANSFER;
151:
152: if (fpm2bits (fsb, funit_pairs, req -> functional__units,
153: &fsb -> fsb_units, fti) == NOTOK)
154: goto out3;
155: /* conservative... */
156: if (fsb -> fsb_class & FCLASS_TRANSFER)
157: fsb -> fsb_units |= FUNITS_TRANSFER;
158: if (fsb -> fsb_class & FCLASS_TM)
159: fsb -> fsb_units |= FUNITS_TM;
160: if (fsb -> fsb_class & FCLASS_ACCESS)
161: fsb -> fsb_units |= FUNITS_ACCESS;
162: if (fsb -> fsb_class & FCLASS_MANAGE)
163: fsb -> fsb_units |= FUNITS_MANAGE;
164: if (!(fsb -> fsb_class &=
165: (FCLASS_TRANSFER | FCLASS_TM | FCLASS_MANAGE | FCLASS_ACCESS))) {
166: (void) ftamoops (fti, FS_ACS_CLASS, 1, EREF_RFPM, EREF_IFPM,
167: NULLCP, NULLCP);
168: goto out3;
169: }
170: if (!(fsb -> fsb_units & FUNIT_LIMITED)
171: && (fsb -> fsb_units & FUNIT_ENHANCED)) {
172: (void) ftamoops (fti, FS_PRO_ERRFUNIT, 1, EREF_RFPM, EREF_IFPM,
173: NULLCP,
174: "enhanced-file-management requires limited-file-management");
175: goto out3;
176: }
177: if (!(fsb -> fsb_units & FUNIT_GROUPING)) { /* XXX: should be OPTIONAL */
178: (void) ftamoops (fti, FS_PRO_ERRFUNIT, 1, EREF_RFPM, EREF_IFPM,
179: NULLCP,
180: "insufficient functional units for service class");
181: goto out3;
182: }
183: if (req -> attribute__groups
184: && fpm2bits (fsb, fattr_pairs, req -> attribute__groups,
185: &fsb -> fsb_attrs, fti) == NOTOK)
186: goto out3;
187: if ((fsb -> fsb_attrs & FATTR_SECURITY)
188: && !(fsb -> fsb_attrs & FATTR_STORAGE)) {
189: (void) ftamoops (fti, FS_ACS_GRP, 1, EREF_RFPM, EREF_IFPM,
190: NULLCP, NULLCP);
191: goto out3;
192: }
193:
194: fts -> fts_sd = fsb -> fsb_fd;
195: fts -> fts_callingtitle = acs -> acs_callingtitle; /* struct copy */
196: bzero ((char *) &acs -> acs_callingtitle, sizeof acs -> acs_callingtitle);
197: fts -> fts_calledtitle = acs -> acs_calledtitle; /* struct copy */
198: bzero ((char *) &acs -> acs_calledtitle, sizeof acs -> acs_calledtitle);
199: if ((fsb -> fsb_context = oid_cpy (acs -> acs_context)) == NULLOID) {
200: no_mem: ;
201: (void) ftamoops (fti, FS_GEN_NOREASON, 1, EREF_RFPM, EREF_RFPM,
202: NULLCP, "out of memory");
203: goto out3;
204: }
205: fts -> fts_context = acs -> acs_context;
206: acs -> acs_context = NULLOID;
207: fts -> fts_callingaddr = ps -> ps_calling; /* struct copy */
208: fts -> fts_calledaddr = ps -> ps_called; /* struct copy */
209: fts -> fts_manage = (fsb -> fsb_prequirements & PR_MANAGEMENT) ? 1 : 0;
210: fts -> fts_class = fsb -> fsb_class;
211: fts -> fts_units = fsb -> fsb_units;
212: fts -> fts_attrs = fsb -> fsb_attrs;
213: if (req -> shared__ASE__information
214: && fpm2shared (fsb, req -> shared__ASE__information,
215: &fts -> fts_sharedASE, fti) == NOTOK)
216: goto out3;
217: fts -> fts_fqos = fsb -> fsb_fqos = MY_FQOS;
218:
219: if (ps -> ps_ctxlist.pc_nctx > 1) {
220: #define PC_XXX (-2) /* unique code */
221:
222: int acsid;
223: register struct type_FTAM_Contents__Type__List *dtn;
224: register struct FTAMcontent *fx,
225: *fx2;
226: register struct PSAPcontext *px;
227: register struct isodocument *id;
228:
229: fsb -> fsb_contexts = ps -> ps_ctxlist;/* struct copy */
230: bzero ((char *) &ps -> ps_ctxlist, sizeof ps -> ps_ctxlist);
231:
232: fx = fts -> fts_contents.fc_contents;
233:
234: (void) AcFindPCI (fsb -> fsb_fd, &acsid, aci);
235:
236: fx2 = fsb -> fsb_contents.fc_contents;
237: fsb -> fsb_contents.fc_ncontent = 0;
238:
239: for (px = fsb -> fsb_contexts.pc_ctx,
240: i = fsb -> fsb_contexts.pc_nctx - 1;
241: i >= 0;
242: px++, i--)
243: if (px -> pc_id != fsb -> fsb_id
244: && px -> pc_id != acsid
245: && px -> pc_result == PC_ACCEPT)
246: px -> pc_result = PC_XXX;
247:
248: for (dtn = req -> contents__type__list; dtn; dtn = dtn -> next) {
249: if ((id = getisodocumentbytype (dtn -> Document__Type__Name))
250: == NULL)
251: continue;
252: for (px = fsb -> fsb_contexts.pc_ctx,
253: i = fsb -> fsb_contexts.pc_nctx - 1;
254: i >= 0;
255: px++, i--) {
256: if (px -> pc_id == fsb -> fsb_id
257: || px -> pc_id == acsid
258: || oid_cmp (id -> id_abstract, px -> pc_asn))
259: continue;
260: break;
261: }
262:
263: if (i < 0)
264: continue;
265:
266: if ((fx2 -> fc_dtn = oid_cpy (dtn -> Document__Type__Name))
267: == NULLOID
268: || (fx -> fc_dtn = oid_cpy (dtn -> Document__Type__Name))
269: == NULLOID)
270: goto no_mem;
271: fx2 -> fc_id = fx -> fc_id = px -> pc_id;
272: if (px -> pc_result == PC_XXX)
273: px -> pc_result = PC_ACCEPT;
274: fx2 -> fc_result = fx -> fc_result = px -> pc_result;
275:
276: fx++, fts -> fts_contents.fc_ncontent++;
277: fx2++, fsb -> fsb_contents.fc_ncontent++;
278: }
279:
280: for (px = fsb -> fsb_contexts.pc_ctx,
281: i = fsb -> fsb_contexts.pc_nctx - 1;
282: i >= 0;
283: px++, i--)
284: if (px -> pc_result == PC_XXX)
285: px -> pc_result = PC_REJECTED;
286:
287: #undef PC_XXX
288: }
289: else
290: if (req -> contents__type__list) {
291: (void) ftamoops (fti, FS_PRO_ERRPROC, 1, EREF_RFPM, EREF_IFPM,
292: NULLCP, "content types management botched");
293: goto out3;
294: }
295:
296: if (req -> initiator__identity
297: && (fts -> fts_initiator = qb2str (req -> initiator__identity))
298: == NULL)
299: goto no_mem;
300: if (req -> account
301: && (fts -> fts_account = qb2str (req -> account)) == NULL)
302: goto no_mem;
303: if (req -> filestore__password) { /* both choices are qbufs... */
304: register struct qbuf *qb = req -> filestore__password -> un.graphic;
305:
306: if ((fts -> fts_password = qb2str (qb)) == NULL)
307: goto no_mem;
308: fts -> fts_passlen = qb -> qb_len;
309: }
310: fts -> fts_ssdusize = fsb -> fsb_ssdusize;
311: fts -> fts_qos = ps -> ps_qos; /* struct copy */
312:
313: free_FTAM_PDU (pdu);
314: ACSFREE (acs);
315:
316: return OK;
317:
318: out3: ;
319: if (pdu)
320: free_FTAM_PDU (pdu);
321:
322: out2: ;
323: ACSFREE (acs);
324:
325: out1: ;
326: pe = NULLPE;
327: if ((pdu = (struct type_FTAM_PDU *) calloc (1, sizeof *pdu))
328: == NULL)
329: goto carry_on;
330: pdu -> offset = type_FTAM_PDU_f__initialize__response;
331: if ((rsp = (struct type_FTAM_F__INITIALIZE__response *)
332: calloc (1, sizeof *rsp)) == NULL)
333: goto carry_on;
334: pdu -> un.f__initialize__response = rsp;
335: if (rsp -> state__result = (struct type_FTAM_State__Result *)
336: calloc (1, sizeof *rsp -> state__result))
337: rsp -> state__result -> parm = FSTATE_FAILURE;
338: if (rsp -> action__result = (struct type_FTAM_Action__Result *)
339: calloc (1, sizeof *rsp -> action__result))
340: rsp -> action__result -> parm= FACTION_PERM;
341: rsp -> functional__units = bits2fpm (fsb, funit_pairs, 0, fti);
342: if (rsp -> ftam__quality__of__service =
343: (struct type_FTAM_FTAM__Quality__Of__Service *)
344: calloc (1, sizeof *rsp -> ftam__quality__of__service))
345: rsp -> ftam__quality__of__service -> parm = MY_FQOS;
346: rsp -> diagnostic = diag2fpm (fsb, 1, fti -> fti_abort.fta_diags, 1, fti);
347: rsp -> checkpoint__window = 1;
348:
349: if (encode_FTAM_PDU (&pe, 1, 0, NULLCP, pdu) != NOTOK)
350: pe -> pe_context = fsb -> fsb_id;
351:
352: carry_on: ;
353: fsbtrace (fsb, (fsb -> fsb_fd, "A-ASSOCIATE.RESPONSE(reject)",
354: "F-INITIALIZE-response", pe, 0));
355:
356: (void) AcAssocResponse (acs -> acs_sd, ACS_TRANSIENT, ACS_USER_NOREASON,
357: NULLOID, NULLAEI, NULLPA, NULLPC, ps -> ps_defctxresult, 0, 0,
358: SERIAL_NONE, 0, &ps -> ps_connect, pe ? &pe : NULLPEP,
359: pe ? 1 : 0, aci);
360: if (pe)
361: pe_free (pe);
362: if (pdu)
363: free_FTAM_PDU (pdu);
364:
365: fsb -> fsb_fd = NOTOK;
366: freefsblk (fsb);
367:
368: return NOTOK;
369: }
370:
371: /* F-INITIALIZE.RESPONSE */
372:
373: int FInitializeResponse (sd, state, action, context, respondtitle,
374: respondaddr, manage, class, units, attrs, sharedASE, fqos, contents,
375: diag, ndiag, fti)
376: int sd;
377: int state,
378: action,
379: manage,
380: class,
381: units,
382: attrs,
383: fqos;
384: OID context;
385: AEI respondtitle;
386: struct PSAPaddr *respondaddr;
387: PE sharedASE;
388: struct FTAMcontentlist *contents;
389: struct FTAMdiagnostic diag[];
390: int ndiag;
391: struct FTAMindication *fti;
392: {
393: register int i;
394: int result,
395: status;
396: PE pe;
397: register struct FTAMcontentlist *pl;
398: register struct FTAMcontent *px;
399: struct AcSAPindication acis;
400: register struct AcSAPindication *aci = &acis;
401: register struct AcSAPabort *aca = &aci -> aci_abort;
402: register struct ftamblk *fsb;
403: register struct type_FTAM_PDU *pdu;
404: register struct type_FTAM_F__INITIALIZE__response *rsp;
405:
406: if ((fsb = findfsblk (sd)) == NULL || (fsb -> fsb_flags & FSB_CONN))
407: return ftamlose (fti, FS_GEN_NOREASON, 0, NULLCP,
408: "invalid ftam descriptor");
409:
410: switch (state) {
411: case FSTATE_SUCCESS:
412: status = ACS_ACCEPT;
413: break;
414:
415: case FSTATE_FAILURE:
416: break;
417:
418: default:
419: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
420: "bad value for state parameter");
421: }
422: switch (action) {
423: case FACTION_SUCCESS:
424: if (state == FSTATE_SUCCESS)
425: break;
426: bad_pair: ;
427: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
428: "bad value for state/action parameters");
429:
430: case FACTION_TRANS:
431: if (state != FSTATE_FAILURE)
432: goto bad_pair;
433: status = ACS_TRANSIENT;
434: break;
435:
436: case FACTION_PERM:
437: if (state != FSTATE_FAILURE)
438: goto bad_pair;
439: status = ACS_PERMANENT;
440: break;
441:
442: default:
443: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
444: "bad value for action parameter");
445: }
446: #ifdef notdef
447: missingP (context);
448: missingP (respondtitle);
449: missingP (respondaddr);
450: #endif
451: if (manage) {
452: if (!(fsb -> fsb_prequirements & PR_MANAGEMENT))
453: return ftamlose (fti, FS_ACS_CONTEXT, 0, NULLCP, NULLCP);
454: }
455: else
456: fsb -> fsb_prequirements &= ~(PR_MANAGEMENT | PR_RESTORATION);
457: switch (class & fsb -> fsb_class) {
458: case FCLASS_TRANSFER:
459: case FCLASS_ACCESS:
460: case FCLASS_MANAGE:
461: case FCLASS_TM:
462: fsb -> fsb_class &= class;
463: break;
464:
465: default:
466: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
467: "service class mismatch, offered 0x%x received 0x%x",
468: fsb -> fsb_class, class);
469: }
470: if (units & ~fsb -> fsb_units)
471: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
472: "functional units not open for negotiation");
473: if (!(units & FUNIT_LIMITED) && (units & FUNIT_ENHANCED))
474: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
475: "enhanced-file-management requires limited-file-management");
476: fsb -> fsb_units = units;
477: switch (fsb -> fsb_class) {
478: case FCLASS_TRANSFER:
479: if (!(fsb -> fsb_units & FUNITS_TRANSFER))
480: goto not_enough;
481: goto do_trans;
482: case FCLASS_TM:
483: if (!(fsb -> fsb_units & FUNITS_TM))
484: goto not_enough;
485: do_trans: ;
486: if (!(fsb -> fsb_units & (FUNIT_READ | FUNIT_WRITE))) {
487: not_enough: ;
488: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
489: "insufficient functional units for service class");
490: }
491: if (fsb -> fsb_units & (FUNIT_ACCESS | FUNIT_FADULOCK)) {
492: too_many: ;
493: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
494: "illegal functional units for service class");
495: }
496: break;
497:
498: case FCLASS_ACCESS:
499: if (!(fsb -> fsb_units & FUNITS_ACCESS))
500: goto not_enough;
501: break;
502:
503: case FCLASS_MANAGE:
504: if (!(fsb -> fsb_units & FUNITS_MANAGE))
505: goto not_enough;
506: if (fsb -> fsb_units & (FUNIT_READ | FUNIT_WRITE
507: | FUNIT_ACCESS | FUNIT_FADULOCK
508: | FUNIT_RECOVERY | FUNIT_RESTART))
509: goto too_many;
510: break;
511: }
512: if (attrs & ~fsb -> fsb_attrs)
513: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
514: "attribute groups not open for negotiation");
515: if ((attrs & FATTR_SECURITY) && !(attrs & FATTR_STORAGE))
516: return ftamlose (fti, FS_ACS_GRP, 0, NULLCP, NULLCP);
517: fsb -> fsb_attrs = attrs;
518: if (fqos != MY_FQOS)
519: return ftamlose (fti, FS_ACS_ROLLBACK, 1, NULLCP,
520: "class-%d-recovery not supported", fqos);
521: pl = &fsb -> fsb_contents;
522: if (contents) {
523: int acsid;
524: register struct FTAMcontent *fx = contents -> fc_contents;
525:
526: if (contents -> fc_ncontent != pl -> fc_ncontent)
527: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
528: "proposed/resulting content types mismatch");
529:
530: (void) AcFindPCI (fsb -> fsb_fd, &acsid, aci);
531: for (px = pl -> fc_contents, i = pl -> fc_ncontent - 1;
532: i >= 0;
533: px++, i--) {
534: if (fx -> fc_id != px -> fc_id)
535: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
536: "bad context id %d at offset %d (wanted %d)",
537: fx -> fc_id, fx - contents -> fc_contents,
538: px -> fc_id);
539: switch (fx -> fc_result) {
540: case PC_ACCEPT:
541: case PC_REJECTED:
542: if (px -> fc_result != PC_ACCEPT) {
543: invalid_result: ;
544: return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
545: "invalid result %d for content id %d",
546: fx -> fc_result, fx -> fc_id);
547: }
548: px -> fc_result = fx -> fc_result;
549: break;
550:
551: default:
552: if (px -> fc_result != fx -> fc_result)
553: goto invalid_result;
554: break;
555: }
556:
557: fx++;
558: }
559: }
560:
561: toomuchP (diag, ndiag, NFDIAG, "diagnostic");
562: missingP (fti);
563:
564: if ((pdu = (struct type_FTAM_PDU *) calloc (1, sizeof *pdu)) == NULL) {
565: no_mem: ;
566: result = ftamlose (fti, FS_GEN (fsb), 1, NULLCP, "out of memory");
567: goto out;
568: }
569: pdu -> offset = type_FTAM_PDU_f__initialize__response;
570: if ((rsp = (struct type_FTAM_F__INITIALIZE__response *)
571: calloc (1, sizeof *rsp)) == NULL)
572: goto no_mem;
573: pdu -> un.f__initialize__response = rsp;
574: if (state != int_FTAM_State__Result_success) {
575: if ((rsp -> state__result =
576: (struct type_FTAM_State__Result *)
577: calloc (1, sizeof *rsp -> state__result))
578: == NULL)
579: goto no_mem;
580: rsp -> state__result -> parm = state;
581: }
582: if (action != int_FTAM_Action__Result_success) {
583: if ((rsp -> action__result =
584: (struct type_FTAM_Action__Result *)
585: calloc (1, sizeof *rsp -> action__result))
586: == NULL)
587: goto no_mem;
588: rsp -> action__result -> parm = action;
589: }
590: rsp -> presentation__context__management = manage;
591: if (fsb -> fsb_class != FCLASS_TRANSFER
592: && (rsp -> service__class = bits2fpm (fsb, fclass_pairs,
593: fsb -> fsb_class, fti))
594: == NULLPE)
595: goto out;
596: if ((rsp -> functional__units = bits2fpm (fsb, funit_pairs,
597: fsb -> fsb_units, fti))
598: == NULLPE)
599: goto out;
600: if (fsb -> fsb_attrs
601: && (rsp -> attribute__groups = bits2fpm (fsb, fattr_pairs,
602: attrs, fti)) == NULLPE)
603: goto out;
604: if (sharedASE
605: && (rsp -> shared__ASE__information =
606: shared2fpm (fsb, sharedASE, fti)) == NULL)
607: goto out;
608: if ((rsp -> ftam__quality__of__service =
609: (struct type_FTAM_FTAM__Quality__Of__Service *)
610: calloc (1, sizeof *rsp -> ftam__quality__of__service))
611: == NULL)
612: goto no_mem;
613: rsp -> ftam__quality__of__service -> parm = fsb -> fsb_fqos;
614: if (contents) {
615: struct type_FTAM_Contents__Type__List *fpm;
616: register struct type_FTAM_Contents__Type__List **fpc;
617:
618: fpc = &rsp -> contents__type__list;
619: for (px = pl -> fc_contents, i = pl -> fc_ncontent - 1;
620: i >= 0;
621: px++, i--)
622: if (px -> fc_result == PC_ACCEPT) {
623: if ((fpm = (struct type_FTAM_Contents__Type__List *)
624: calloc (1, sizeof *fpm)) == NULL)
625: goto no_mem;
626: *fpc = fpm;
627:
628: if ((fpm -> Document__Type__Name = oid_cpy (px -> fc_dtn))
629: == NULLOID)
630: goto no_mem;
631: fpc = &fpm -> next;
632: }
633: }
634:
635: if (ndiag > 0
636: && (rsp -> diagnostic = diag2fpm (fsb, 0, diag, ndiag, fti))
637: == NULL)
638: goto out;
639: rsp -> checkpoint__window = 1;
640:
641: if (encode_FTAM_PDU (&pe, 1, 0, NULLCP, pdu) == NOTOK) {
642: (void) ftamlose (fti, FS_GEN (fsb), 1, NULLCP,
643: "error encoding PDU: %s", PY_pepy);
644: goto out;
645: }
646:
647: pe -> pe_context = fsb -> fsb_id;
648:
649: fsbtrace (fsb, (fsb -> fsb_fd, "A-ASSOCIATE.RESPONSE",
650: "F-INITIALIZE-response", pe, 0));
651:
652: result = AcAssocResponse (fsb -> fsb_fd, status, status != ACS_ACCEPT
653: ? ACS_USER_NOREASON : ACS_USER_NULL,
654: context ? context : fsb -> fsb_context, respondtitle,
655: respondaddr, &fsb -> fsb_contexts, PC_ACCEPT,
656: fsb -> fsb_prequirements, fsb -> fsb_srequirements,
657: fsb -> fsb_ssn, fsb -> fsb_settings, &fsb -> fsb_connect,
658: &pe, 1, aci);
659:
660: pe_free (pe);
661: pe = NULLPE;
662: free_FTAM_PDU (pdu);
663: pdu = NULL;
664:
665: if (result == NOTOK) {
666: (void) acs2ftamlose (fsb, fti, "AcAssocResponse", aca);
667: goto out;
668: }
669:
670: fsb -> fsb_flags |= FSB_CONN;
671: return OK;
672:
673: out: ;
674: if (pe)
675: pe_free (pe);
676: if (pdu)
677: free_FTAM_PDU (pdu);
678:
679: pe = NULLPE;
680: if ((pdu = (struct type_FTAM_PDU *) calloc (1, sizeof *pdu))
681: == NULL)
682: goto carry_on;
683: pdu -> offset = type_FTAM_PDU_f__initialize__response;
684: if ((rsp = (struct type_FTAM_F__INITIALIZE__response *)
685: calloc (1, sizeof *rsp))
686: == NULL)
687: goto carry_on;
688: pdu -> un.f__initialize__response = rsp;
689: if (rsp -> state__result = (struct type_FTAM_State__Result *)
690: calloc (1, sizeof *rsp -> state__result))
691: rsp -> state__result -> parm = FSTATE_FAILURE;
692: if (rsp -> action__result = (struct type_FTAM_Action__Result *)
693: calloc (1, sizeof *rsp -> action__result))
694: rsp -> action__result -> parm= FACTION_PERM;
695: rsp -> functional__units = bits2fpm (fsb, funit_pairs, 0, fti);
696: if (rsp -> ftam__quality__of__service =
697: (struct type_FTAM_FTAM__Quality__Of__Service *)
698: calloc (1, sizeof *rsp -> ftam__quality__of__service))
699: rsp -> ftam__quality__of__service -> parm = MY_FQOS;
700: rsp -> diagnostic = diag2fpm (fsb, 1, fti -> fti_abort.fta_diags, 1, fti);
701: rsp -> checkpoint__window = 1;
702:
703: if (encode_FTAM_PDU (&pe, 1, 0, NULLCP, pdu) != NOTOK)
704: pe -> pe_context = fsb -> fsb_id;
705:
706: carry_on: ;
707: fsbtrace (fsb, (fsb -> fsb_fd, "A-ASSOCIATE.RESPONSE(reject)",
708: "F-INITIALIZE-response", pe, 0));
709:
710: (void) AcAssocResponse (fsb -> fsb_fd, ACS_TRANSIENT, ACS_USER_NOREASON,
711: NULLOID, NULLAEI, NULLPA, NULLPC, PC_ACCEPT, 0, 0, SERIAL_NONE,
712: 0, &fsb -> fsb_connect, pe ? &pe : NULLPEP, pe ? 1 : 0, aci);
713: if (pe)
714: pe_free (pe);
715: if (pdu)
716: free_FTAM_PDU (pdu);
717:
718: fsb -> fsb_fd = NOTOK;
719: freefsblk (fsb);
720:
721: return NOTOK;
722: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.