![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to attribute.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / xns / examples / filing_common|
Return to attribute.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / xns / examples / filing_common |
1.1 root 1: #ifndef lint
2: static char *rcsid = "$Header: attribute.c,v 1.2 87/03/31 14:32:17 ed Exp $";
3: #endif lint
4:
5: /* $Log: attribute.c,v $
6: * Revision 1.2 87/03/31 14:32:17 ed
7: * Added Filing version 5 support.
8: *
9: * Revision 1.1 87/01/14 11:25:53 ed
10: * Initial revision
11: *
12: */
13:
14: #include <sys/types.h>
15: #include <netns/ns.h>
16: #include <netns/sp.h>
17: #ifdef FILING4
18: #include "filingV4.h"
19: #include "clearinghouseV2.h"
20: #endif FILING4
21: #ifdef FILING5
22: #include "filingV5.h"
23: #include "clearinghouseV2.h"
24: #endif FILING5
25: #ifdef FILING6
26: #include "filingV6.h"
27: #include "clearinghouseV3.h"
28: #endif FILING6
29: #ifdef FILINGSUBSET1
30: #include "filingsubsetV1.h"
31: #include "clearinghouseV3.h"
32: #endif FILINGSUBSET1
33:
34: StringToAttr(str, attr)
35: char *str;
36: FILING_Attribute *attr;
37: {
38: Unspecified buf[2049], *bp;
39: Cardinal len;
40:
41: bp = buf + sizeof_Cardinal(len);
42: len = externalize_String(&str, bp);
43: (void) externalize_Cardinal(&len, buf);
44: internalize_Sequence_of_Unspecified(&(attr->value), buf);
45: return;
46: }
47:
48: char *
49: AttrToString(attr)
50: FILING_Attribute *attr;
51: {
52: Unspecified buf[2049], *bp;
53: Cardinal len;
54: char *strval;
55:
56: externalize_Sequence_of_Unspecified(&(attr->value), buf);
57: bp = buf;
58: bp += internalize_Cardinal(&len, bp);
59: bp += internalize_String(&strval, bp);
60: return(strval);
61: }
62:
63: UserToAttr(id, attr)
64: CLEARINGHOUSE_Name id;
65: FILING_Attribute *attr;
66: {
67: Unspecified buf[2049], *bp;
68: Cardinal len;
69:
70: bp = buf + sizeof_Cardinal(len);
71: len = CLEARINGHOUSE_externalize_Name(&id, bp);
72: (void) externalize_Cardinal(&len, buf);
73: internalize_Sequence_of_Unspecified(&(attr->value), buf);
74: return;
75: }
76:
77: LongCardinalToAttr(val, attr)
78: LongCardinal val;
79: FILING_Attribute *attr;
80: {
81: Unspecified buf[3], *bp;
82: Cardinal len;
83:
84: bp = buf + sizeof_Cardinal(len);
85: len = externalize_LongCardinal(&val, bp);
86: (void) externalize_Cardinal(&len, buf);
87: internalize_Sequence_of_Unspecified(&(attr->value), buf);
88: return;
89: }
90:
91: LongCardinal
92: AttrToLongCardinal(attr)
93: FILING_Attribute *attr;
94: {
95: Unspecified buf[2];
96: LongCardinal result;
97:
98: (void) externalize_Unspecified(attr->value.sequence, buf);
99: (void) externalize_Unspecified((attr->value.sequence)+1, buf+1);
100: (void) internalize_LongCardinal(&result, buf);
101: return(result);
102: }
103:
104: BooleanToAttr(val, attr)
105: int val;
106: FILING_Attribute *attr;
107: {
108: Boolean boolval;
109: Unspecified buf[3], *bp;
110: Cardinal len;
111:
112: boolval = (Boolean) val;
113: bp = buf + sizeof_Cardinal(len);
114: len = externalize_Boolean(&boolval, bp);
115: (void) externalize_Cardinal(&len, buf);
116: internalize_Sequence_of_Unspecified(&(attr->value), buf);
117: return;
118: }
119:
120: int
121: AttrToBoolean(attr)
122: FILING_Attribute *attr;
123: {
124: Unspecified buf[1];
125: Boolean result;
126:
127: (void) externalize_Unspecified(attr->value.sequence, buf);
128: (void) internalize_Boolean(&result, buf);
129: return(result);
130: }
131:
132: CardinalToAttr(val, attr)
133: Cardinal val;
134: FILING_Attribute *attr;
135: {
136: Unspecified buf[3], *bp;
137: Cardinal len;
138:
139: bp = buf + sizeof_Cardinal(len);
140: len = externalize_Cardinal(&val, bp);
141: (void) externalize_Cardinal(&len, buf);
142: internalize_Sequence_of_Unspecified(&(attr->value), buf);
143: return;
144: }
145:
146: Cardinal
147: AttrToCardinal(attr)
148: FILING_Attribute *attr;
149: {
150: Unspecified buf[2];
151: Cardinal result;
152: (void) externalize_Unspecified(attr->value.sequence, buf);
153: (void) internalize_Cardinal(&result, buf);
154: return(result);
155: }
156:
157: FileIDToAttr(value, attr)
158: Cardinal value[];
159: FILING_Attribute *attr;
160: {
161: Unspecified buf[6], *bp;
162: Cardinal len;
163:
164: bp = buf + sizeof_Cardinal(len);
165: len = FILING_externalize_FileID(value, bp);
166: (void) externalize_Cardinal(&len, buf);
167: internalize_Sequence_of_Unspecified(&(attr->value), buf);
168: return;
169: }
170:
171: Unspecified *
172: AttrToFileID(attr)
173: FILING_Attribute *attr;
174: {
175: Unspecified *bp;
176: Unspecified buf[6];
177:
178: bp= Allocate(FILING_sizeof_FileID(0));
179:
180: (void) FILING_externalize_FileID(attr->value.sequence,buf);
181: (void) FILING_internalize_FileID(bp,buf);
182:
183: return(bp);
184: }
185:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.