![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ftamattr.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 ftamattr.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / ftam |
1.1 root 1: /* ftamattr.c - FPM: encode/decode attributes */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/ftam/RCS/ftamattr.c,v 7.1 90/03/23 10:53:58 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/ftam/RCS/ftamattr.c,v 7.1 90/03/23 10:53:58 mrose Exp $
9: *
10: *
11: * $Log: ftamattr.c,v $
12: * Revision 7.1 90/03/23 10:53:58 mrose
13: * update
14: *
15: * Revision 7.0 89/11/23 21:53:23 mrose
16: * Release 6.0
17: *
18: */
19:
20: /*
21: * NOTICE
22: *
23: * Acquisition, use, and distribution of this module and related
24: * materials are subject to the restrictions of a license agreement.
25: * Consult the Preface in the User's Manual for the full terms of
26: * this agreement.
27: *
28: */
29:
30:
31: /* LINTLIBRARY */
32:
33: #include <stdio.h>
34: #include "fpkt.h"
35:
36: /* */
37:
38: struct type_FTAM_Read__Attributes *attr2fpm (fsb, fa, fti)
39: register struct ftamblk *fsb;
40: register struct FTAMattributes *fa;
41: struct FTAMindication *fti;
42: {
43: register int i;
44: register char *cp,
45: **ap;
46: register struct type_FTAM_Read__Attributes *fpm;
47:
48: if ((fpm = (struct type_FTAM_Read__Attributes *) calloc (1, sizeof *fpm))
49: == NULL) {
50: no_mem: ;
51: (void) ftamlose (fti, FS_GEN (fsb), 1, NULLCP, "out of memory");
52: out: ;
53: if (fpm)
54: free_FTAM_Read__Attributes (fpm);
55: return NULL;
56: }
57:
58: if (fa -> fa_present & FA_FILENAME) {
59: register struct type_FTAM_Filename__Attribute *fn,
60: **fc;
61:
62: if (fa -> fa_novalue & FA_FILENAME) {
63: (void) ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
64: "filename not present");
65: goto out;
66: }
67:
68: if (fa -> fa_nfile > NFFILE) {
69: (void) ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
70: "too many filenames");
71: goto out;
72: }
73:
74: fc = &fpm -> filename;
75: for (ap = fa -> fa_files, i = fa -> fa_nfile - 1; i >= 0; ap++, i--) {
76: if (*ap == NULL) {
77: (void) ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
78: "empty filename at slot %d",
79: fa -> fa_nfile - i - 1);
80: goto out;
81: }
82:
83: if ((fn = (struct type_FTAM_Filename__Attribute *)
84: calloc (1, sizeof *fpm -> filename))
85: == NULL)
86: goto no_mem;
87: *fc = fn;
88:
89: if ((fn -> GraphicString = str2qb (*ap, strlen (*ap), 1)) == NULL)
90: goto no_mem;
91:
92: fc = &((*fc) -> next);
93: }
94: }
95:
96: if (fa -> fa_present & FA_ACTIONS) {
97: if (fa -> fa_novalue & FA_ACTIONS) {
98: (void) ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
99: "permitted-actions not present");
100: goto out;
101: }
102:
103: if ((fpm -> permitted__actions = bits2fpm (fsb, fpermitted_pairs,
104: fa -> fa_permitted, fti))
105: == NULL)
106: goto out;
107: }
108:
109: if (fa -> fa_present & FA_CONTENTS) {
110: if (fa -> fa_novalue & FA_CONTENTS) {
111: (void) ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
112: "contents-type not present");
113: goto out;
114: }
115: if (fa -> fa_contents == NULLOID) {
116: (void) ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
117: "missing contents-type");
118: goto out;
119: }
120: if ((fpm -> contents__type =
121: (struct type_FTAM_Contents__Type__Attribute *)
122: calloc (1, sizeof *fpm -> contents__type)) == NULL
123: || (fpm -> contents__type -> document__type__name =
124: oid_cpy (fa -> fa_contents)) == NULL)
125: goto no_mem;
126: if (fpm -> contents__type -> parameter = fa -> fa_parameter)
127: fpm -> contents__type -> parameter -> pe_refcnt++;
128: }
129:
130: if (fa -> fa_present & FA_ACCOUNT) {
131: if (fa -> fa_account == NULL) {
132: (void) ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
133: "missing account");
134: goto out;
135: }
136: if ((fpm -> storage__account =
137: (struct type_FTAM_Account__Attribute *)
138: calloc (1, sizeof *fpm -> storage__account))
139: == NULL)
140: goto no_mem;
141: if (fa -> fa_novalue & FA_ACCOUNT)
142: fpm -> storage__account -> offset =
143: type_FTAM_Account__Attribute_no__value__available;
144: else {
145: fpm -> storage__account -> offset =
146: type_FTAM_Account__Attribute_actual__values;
147: if ((fpm -> storage__account -> un.actual__values =
148: str2qb (fa -> fa_account, strlen (fa -> fa_account), 1))
149: == NULL)
150: goto no_mem;
151: }
152: }
153:
154: #define dodate(flag,field,tag) \
155: if (fa -> fa_present & flag) { \
156: if ((fpm -> tag = (struct type_FTAM_Date__and__Time__Attribute *) \
157: calloc (1, sizeof *fpm -> tag)) == NULL) \
158: goto no_mem; \
159: if (fa -> fa_novalue & flag) \
160: fpm -> tag -> offset = \
161: type_FTAM_Date__and__Time__Attribute_no__value__available;\
162: else { \
163: fpm -> tag -> offset = \
164: type_FTAM_Date__and__Time__Attribute_actual__values; \
165: if ((cp = gent2str (field)) == NULL \
166: || (fpm -> tag -> un.actual__values = \
167: str2qb (cp, strlen (cp), 1)) == NULL) \
168: goto no_mem; \
169: } \
170: }
171: dodate (FA_DATE_CREATE, &fa -> fa_date_create,
172: date__and__time__of__creation);
173: dodate (FA_DATE_MODIFY, &fa -> fa_date_modify,
174: date__and__time__of__last__modification);
175: dodate (FA_DATE_READ, &fa -> fa_date_read,
176: date__and__time__of__last__read__access);
177: dodate (FA_DATE_ATTR, &fa -> fa_date_attribute,
178: date__and__time__of__last__attribute__modification);
179: #undef dodate
180:
181: #define douser(flag,field,tag,name) \
182: if (fa -> fa_present & flag) { \
183: if ((fpm -> tag = (struct type_FTAM_User__Identity__Attribute *) \
184: calloc (1, sizeof *fpm -> tag)) == NULL) \
185: goto no_mem; \
186: if (fa -> fa_novalue & flag) \
187: fpm -> tag -> offset = \
188: type_FTAM_User__Identity__Attribute_no__value__available; \
189: else { \
190: if (field == NULL) { \
191: (void) ftamlose (fti, FS_GEN (fsb), 0, NULLCP, "missing %s", \
192: name); \
193: goto out; \
194: } \
195: fpm -> tag -> offset = \
196: type_FTAM_User__Identity__Attribute_actual__values; \
197: if ((fpm -> tag -> un.actual__values = str2qb (field, \
198: strlen (field), 1)) \
199: == NULL) \
200: goto no_mem; \
201: } \
202: }
203: douser (FA_ID_CREATE, fa -> fa_id_create,
204: identity__of__creator, "identity-of-creator");
205: douser (FA_ID_MODIFY, fa -> fa_id_modify,
206: identity__of__last__modifier, "identity-of-last-modifier");
207: douser (FA_ID_READ, fa -> fa_id_read,
208: identity__of__last__reader, "identity-of-last-reader");
209: douser (FA_ID_ATTR, fa -> fa_id_attribute,
210: identity__of__last__attribute__modifier,
211: "identity-of-last-attribute-modifier");
212: #undef douser
213:
214: if (fa -> fa_present & FA_AVAILABILITY) {
215: if ((fpm -> file__availability =
216: (struct type_FTAM_File__Availability__Attribute *)
217: calloc (1, sizeof *fpm -> file__availability))
218: == NULL)
219: goto no_mem;
220: if (fa -> fa_novalue & FA_AVAILABILITY)
221: fpm -> file__availability -> offset =
222: type_FTAM_File__Availability__Attribute_no__value__available;
223: else {
224: fpm -> file__availability -> offset =
225: type_FTAM_File__Availability__Attribute_actual__values;
226: switch (fa -> fa_availability) {
227: case FA_AVAIL_IMMED:
228: case FA_AVAIL_DEFER:
229: fpm -> file__availability -> un.actual__values =
230: fa -> fa_availability;
231: break;
232:
233: default:
234: (void) ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
235: "bad value for file-availability");
236: goto out;
237: }
238: }
239: }
240:
241: #define dosize(flag,field,tag) \
242: if (fa -> fa_present & flag) { \
243: if ((fpm -> tag = (struct type_FTAM_Filesize__Attribute *) \
244: calloc (1, sizeof *fpm -> tag)) == NULL) \
245: goto no_mem; \
246: if (fa -> fa_novalue & flag) \
247: fpm -> tag -> offset = \
248: type_FTAM_Filesize__Attribute_no__value__available; \
249: else { \
250: fpm -> tag -> offset = \
251: type_FTAM_Filesize__Attribute_actual__values; \
252: fpm -> tag -> un.actual__values = field; \
253: } \
254: }
255: dosize (FA_FILESIZE, fa -> fa_filesize, filesize);
256: dosize (FA_FUTURESIZE, fa -> fa_futuresize, future__filesize);
257: #undef dosize
258:
259: if (fa -> fa_present & FA_CONTROL) {
260: if ((fpm -> access__control =
261: (struct type_FTAM_Access__Control__Attribute *)
262: calloc (1, sizeof *fpm -> access__control))
263: == NULL)
264: goto no_mem;
265: if (fa -> fa_novalue & FA_CONTROL)
266: fpm -> access__control -> offset =
267: type_FTAM_Access__Control__Attribute_no__value__available;
268: else {
269: fpm -> access__control -> offset =
270: type_FTAM_Access__Control__Attribute_actual__values;
271: if ((fpm -> access__control -> un.actual__values =
272: acl2fpm (fsb, fa -> fa_control, fti)) == NULL)
273: goto out;
274: }
275: }
276:
277: if (fa -> fa_present & FA_LEGAL) {
278: if ((fpm -> legal__qualification =
279: (struct type_FTAM_Legal__Qualification__Attribute *)
280: calloc (1, sizeof *fpm -> legal__qualification))
281: == NULL)
282: goto no_mem;
283: if (fa -> fa_novalue & FA_LEGAL)
284: fpm -> legal__qualification -> offset =
285: type_FTAM_Legal__Qualification__Attribute_no__value__available;
286: else {
287: if (fa -> fa_legal == NULL) {
288: (void) ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
289: "missing legal-qualification");
290: goto out;
291: }
292: fpm -> legal__qualification -> offset =
293: type_FTAM_Legal__Qualification__Attribute_actual__values;
294: if ((fpm -> legal__qualification -> un.actual__values =
295: str2qb (fa -> fa_legal, strlen (fa -> fa_legal), 1))
296: == NULL)
297: goto no_mem;
298: }
299: }
300:
301: /*
302: * Added private use attribute functionality for Retix NBS9 interworking.
303: * No value should always be set because we don't support private use.
304: * pmk.
305: */
306: if (fa -> fa_present & FA_PRIVATE) {
307: (void) ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
308: "private-use attribute not supported");
309: goto out;
310: }
311:
312: return fpm;
313: }
314:
315: /* */
316:
317: int fpm2attr (fsb, fpm, fa, fti)
318: register struct ftamblk *fsb;
319: register struct type_FTAM_Read__Attributes *fpm;
320: register struct FTAMattributes *fa;
321: struct FTAMindication *fti;
322: {
323: register char *cp;
324: register UTC u;
325:
326: bzero ((char *) fa, sizeof *fa);
327:
328: if (fpm -> filename) {
329: register int n;
330: register char **ap;
331: register struct type_FTAM_Filename__Attribute *fn;
332:
333: fa -> fa_present |= FA_FILENAME;
334:
335: ap = fa -> fa_files, n = NFFILE;
336: for (fn = fpm -> filename; fn; fn = fn -> next) {
337: if (n-- <= 0) {
338: (void) ftamlose (fti, FS_GEN (fsb), 1, NULLCP,
339: "too many names in filename");
340: out: ;
341: FAFREE (fa);
342: return NOTOK;
343: }
344: if ((*ap++ = qb2str (fn -> GraphicString)) == NULL) {
345: no_mem: ;
346: (void) ftamlose (fti, FS_GEN (fsb), 1, NULLCP,
347: "out of memory");
348: goto out;
349: }
350: fa -> fa_nfile++;
351: }
352: }
353:
354: if (fpm -> permitted__actions) {
355: fa -> fa_present |= FA_ACTIONS;
356:
357: if (fpm2bits (fsb, fpermitted_pairs, fpm -> permitted__actions,
358: &fa -> fa_permitted, fti) == NOTOK)
359: goto out;
360: }
361:
362: if (fpm -> contents__type) {
363: fa -> fa_present |= FA_CONTENTS;
364:
365: fa -> fa_contents = fpm -> contents__type -> document__type__name;
366: fpm -> contents__type -> document__type__name = NULLOID;
367: if (fpm -> contents__type -> parameter
368: && (fa -> fa_parameter =
369: pe_cpy (fpm -> contents__type -> parameter))
370: == NULLPE)
371: goto no_mem;
372: }
373:
374: if (fpm -> storage__account) {
375: fa -> fa_present |= FA_ACCOUNT;
376:
377: if (fpm -> storage__account -> offset
378: == type_FTAM_Account__Attribute_no__value__available)
379: fa -> fa_novalue |= FA_ACCOUNT;
380: else
381: if ((fa -> fa_account =
382: qb2str (fpm -> storage__account -> un.actual__values))
383: == NULL)
384: goto no_mem;
385: }
386:
387: #define dodate(flag,field,tag) \
388: if (fpm -> tag) { \
389: fa -> fa_present |= flag; \
390: \
391: if (fpm -> tag -> offset \
392: == type_FTAM_Date__and__Time__Attribute_no__value__available) \
393: fa -> fa_novalue |= flag; \
394: else { \
395: if ((cp = qb2str (fpm -> tag -> un.actual__values)) == NULL) \
396: goto no_mem; \
397: u = str2gent (cp, strlen (cp)); \
398: free (cp); \
399: if (u == NULLUTC) \
400: goto no_mem; \
401: field = *u; \
402: } \
403: }
404: dodate (FA_DATE_CREATE, fa -> fa_date_create,
405: date__and__time__of__creation);
406: dodate (FA_DATE_MODIFY, fa -> fa_date_modify,
407: date__and__time__of__last__modification);
408: dodate (FA_DATE_READ, fa -> fa_date_read,
409: date__and__time__of__last__read__access);
410: dodate (FA_DATE_ATTR, fa -> fa_date_attribute,
411: date__and__time__of__last__attribute__modification);
412: #undef dodate
413:
414: #define douser(flag,field,tag,name) \
415: if (fpm -> tag) { \
416: fa -> fa_present |= flag; \
417: \
418: if (fpm -> tag -> offset \
419: == type_FTAM_User__Identity__Attribute_no__value__available) \
420: fa -> fa_novalue |= flag; \
421: else \
422: if ((field = qb2str (fpm -> tag -> un.actual__values)) == NULL) \
423: goto no_mem; \
424: }
425: douser (FA_ID_CREATE, fa -> fa_id_create,
426: identity__of__creator, "identity-of-creator");
427: douser (FA_ID_MODIFY, fa -> fa_id_modify,
428: identity__of__last__modifier, "identity-of-last-modifier");
429: douser (FA_ID_READ, fa -> fa_id_read,
430: identity__of__last__reader, "identity-of-last-reader");
431: douser (FA_ID_ATTR, fa -> fa_id_attribute,
432: identity__of__last__attribute__modifier,
433: "identity-of-last-attribute-modifier");
434: #undef douser
435:
436: if (fpm -> file__availability) {
437: fa -> fa_present |= FA_AVAILABILITY;
438:
439: if (fpm -> file__availability -> offset ==
440: type_FTAM_File__Availability__Attribute_no__value__available)
441: fa -> fa_novalue |= FA_AVAILABILITY;
442: else
443: fa -> fa_availability =
444: fpm -> file__availability -> un.actual__values;
445: }
446:
447: #define dosize(flag,field,tag) \
448: if (fpm -> tag) { \
449: fa -> fa_present |= flag; \
450: \
451: if (fpm -> tag -> offset \
452: == type_FTAM_Filesize__Attribute_no__value__available) \
453: fa -> fa_novalue |= flag; \
454: else \
455: field = fpm -> tag -> un.actual__values; \
456: }
457: dosize (FA_FILESIZE, fa -> fa_filesize, filesize);
458: dosize (FA_FUTURESIZE, fa -> fa_futuresize, future__filesize);
459: #undef dosize
460:
461: if (fpm -> access__control) {
462: fa -> fa_present |= FA_CONTROL;
463:
464: if (fpm -> access__control -> offset
465: == type_FTAM_Access__Control__Attribute_no__value__available)
466: fa -> fa_novalue |= FA_CONTROL;
467: else
468: if (fpm2acl (fsb, fpm -> access__control -> un.actual__values,
469: &fa -> fa_control, fti) == NOTOK)
470: goto out;
471: }
472:
473: if (fpm -> legal__qualification) {
474: fa -> fa_present |= FA_LEGAL;
475:
476: if (fpm -> legal__qualification -> offset ==
477: type_FTAM_Legal__Qualification__Attribute_no__value__available)
478: fa -> fa_novalue |= FA_LEGAL;
479: else
480: if ((fa -> fa_legal =
481: qb2str (fpm -> legal__qualification -> un.actual__values))
482: == NULL)
483: goto no_mem;
484: }
485:
486: /* Added private use functionality pmk */
487: if (fpm -> private__use) {
488: fa -> fa_present |= FA_PRIVATE;
489: /* Set no value, regardless of what is there we don't support it */
490: fa -> fa_novalue |= FA_PRIVATE;
491: }
492:
493: return OK;
494: }
495:
496: /* */
497:
498: void FAFREE (fa)
499: register struct FTAMattributes *fa;
500: {
501: register int FAI;
502:
503: for (FAI = (fa) -> fa_nfile - 1; FAI >= 0; FAI--)
504: if ((fa) -> fa_files[FAI])
505: free ((fa) -> fa_files[FAI]), (fa) -> fa_files[FAI] = NULL;
506: (fa) -> fa_nfile = 0;
507: if ((fa) -> fa_contents)
508: oid_free ((fa) -> fa_contents), (fa) -> fa_contents = NULLOID;
509: if ((fa) -> fa_parameter)
510: pe_free ((fa) -> fa_parameter), (fa) -> fa_parameter = NULLPE;
511: if ((fa) -> fa_account)
512: free ((fa) -> fa_account), (fa) -> fa_account = NULL;
513: if ((fa) -> fa_id_create)
514: free ((fa) -> fa_id_create), (fa) -> fa_id_create = NULL;
515: if ((fa) -> fa_id_modify)
516: free ((fa) -> fa_id_modify), (fa) -> fa_id_modify = NULL;
517: if ((fa) -> fa_id_read)
518: free ((fa) -> fa_id_read), (fa) -> fa_id_read = NULL;
519: if ((fa) -> fa_id_attribute)
520: free ((fa) -> fa_id_attribute), (fa) -> fa_id_attribute = NULL;
521: if (fa -> fa_control) {
522: FEFREE (fa -> fa_control);
523: fa -> fa_control = NULL;
524: }
525: if ((fa) -> fa_legal)
526: free ((fa) -> fa_legal), (fa) -> fa_legal = NULL;
527: if ((fa) -> fa_private)
528: free ((fa) -> fa_private), (fa) -> fa_private = NULL;
529: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.