sys: Tidy up header includes
[openafs.git] / src / sys / rmtsysnet.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  *
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afsconfig.h>
11 #include <afs/param.h>
12
13 #include <roken.h>
14
15 #include <afs/afs_consts.h>
16 #include <afs/vice.h>
17 #include <afs/afsint.h>
18 #include <afs/venus.h>
19 #include <rx/xdr.h>
20
21 #include "rmtsys.h"
22
23
24 /*
25  * We deal with converting pioctl parameters between host and network order.
26  * Painful but somebody has to do this and pioctl is the best place rather than
27  * leaving it to the calling application programs!
28  */
29
30 #define MAXNAME         100
31 #define MAXGCSIZE       16
32
33 struct Acl {
34     int nplus;
35     int nminus;
36     struct AclEntry *pluslist;
37     struct AclEntry *minuslist;
38 };
39
40 struct AclEntry {
41     struct AclEntry *next;
42     char name[MAXNAME];
43     afs_int32 rights;
44 };
45
46 struct ClearToken {
47     afs_int32 AuthHandle;
48     char HandShakeKey[8];
49     afs_int32 ViceId;
50     afs_int32 BeginTimestamp;
51     afs_int32 EndTimestamp;
52 };
53
54 char *
55 RSkipLine(char *astr)
56 {
57     while (*astr != '\n')
58         astr++;
59     astr++;
60     return astr;
61 }
62
63
64 struct Acl *
65 RParseAcl(char *astr)
66 {
67     int nplus, nminus, i, trights;
68     char tname[MAXNAME];
69     struct AclEntry *first, *last, *tl;
70     struct Acl *ta;
71     sscanf(astr, "%d", &nplus);
72     astr = RSkipLine(astr);
73     sscanf(astr, "%d", &nminus);
74     astr = RSkipLine(astr);
75
76     ta = (struct Acl *)malloc(sizeof(struct Acl));
77     ta->nplus = nplus;
78     ta->nminus = nminus;
79
80     last = 0;
81     first = 0;
82     for (i = 0; i < nplus; i++) {
83         sscanf(astr, "%100s %d", tname, &trights);
84         astr = RSkipLine(astr);
85         tl = (struct AclEntry *)malloc(sizeof(struct AclEntry));
86         if (!first)
87             first = tl;
88         strcpy(tl->name, tname);
89         tl->rights = trights;
90         tl->next = 0;
91         if (last)
92             last->next = tl;
93         last = tl;
94     }
95     ta->pluslist = first;
96
97     last = 0;
98     first = 0;
99     for (i = 0; i < nminus; i++) {
100         sscanf(astr, "%100s %d", tname, &trights);
101         astr = RSkipLine(astr);
102         tl = (struct AclEntry *)malloc(sizeof(struct AclEntry));
103         if (!first)
104             first = tl;
105         strcpy(tl->name, tname);
106         tl->rights = trights;
107         tl->next = 0;
108         if (last)
109             last->next = tl;
110         last = tl;
111     }
112     ta->minuslist = first;
113
114     return ta;
115 }
116
117
118 void
119 RAclToString(struct Acl *acl, char *mydata, int ntoh_conv)
120 {
121     char tstring[AFS_PIOCTL_MAXSIZE];
122     struct AclEntry *tp;
123
124 /* No conversion needed since they're in network order in the first place */
125     sprintf(mydata, "%d\n%d\n", acl->nplus, acl->nminus);
126     for (tp = acl->pluslist; tp; tp = tp->next) {
127         sprintf(tstring, "%s %d\n", tp->name, tp->rights);
128         strcat(mydata, tstring);
129     }
130     for (tp = acl->minuslist; tp; tp = tp->next) {
131         sprintf(tstring, "%s %d\n", tp->name, tp->rights);
132         strcat(mydata, tstring);
133     }
134 }
135
136
137 /* Free all malloced stuff */
138 void
139 RCleanAcl(struct Acl *aa)
140 {
141     struct AclEntry *te, *ne;
142
143     for (te = aa->pluslist; te; te = ne) {
144         ne = te->next;
145         free(te);
146     }
147     for (te = aa->minuslist; te; te = ne) {
148         ne = te->next;
149         free(te);
150     }
151     free(aa);
152 }
153
154
155 void
156 RFetchVolumeStatus_conversion(char *data, int ntoh_conv)
157 {
158     struct AFSFetchVolumeStatus *status = (AFSFetchVolumeStatus *) data;
159
160     if (ntoh_conv) {            /* Network -> Host */
161         status->Vid = ntohl(status->Vid);
162         status->ParentId = ntohl(status->ParentId);
163 #ifdef  notdef
164 /* save cycles */
165         status->OnLine = status->OnLine;
166         status->InService = status->InService;
167         status->Blessed = status->Blessed;
168         status->NeedsSalvage = status->NeedsSalvage;
169 #endif
170         status->Type = ntohl(status->Type);
171         status->MinQuota = ntohl(status->MinQuota);
172         status->MaxQuota = ntohl(status->MaxQuota);
173         status->BlocksInUse = ntohl(status->BlocksInUse);
174         status->PartBlocksAvail = ntohl(status->PartBlocksAvail);
175         status->PartMaxBlocks = ntohl(status->PartMaxBlocks);
176     } else {                    /* Host -> Network */
177         status->Vid = htonl(status->Vid);
178         status->ParentId = htonl(status->ParentId);
179 #ifdef  notdef
180 /* save cycles */
181         status->OnLine = status->OnLine;
182         status->InService = status->InService;
183         status->Blessed = status->Blessed;
184         status->NeedsSalvage = status->NeedsSalvage;
185 #endif
186         status->Type = htonl(status->Type);
187         status->MinQuota = htonl(status->MinQuota);
188         status->MaxQuota = htonl(status->MaxQuota);
189         status->BlocksInUse = htonl(status->BlocksInUse);
190         status->PartBlocksAvail = htonl(status->PartBlocksAvail);
191         status->PartMaxBlocks = htonl(status->PartMaxBlocks);
192     }
193 }
194
195 void
196 RClearToken_convert(char *ptr, int ntoh_conv)
197 {
198     struct ClearToken *ticket = (struct ClearToken *)ptr;
199
200     if (ntoh_conv) {            /* Network -> host */
201         ticket->AuthHandle = ntohl(ticket->AuthHandle);
202         ticket->ViceId = ntohl(ticket->ViceId);
203         ticket->BeginTimestamp = ntohl(ticket->BeginTimestamp);
204         ticket->EndTimestamp = ntohl(ticket->EndTimestamp);
205     } else {                    /* Host -> Network */
206         ticket->AuthHandle = htonl(ticket->AuthHandle);
207         ticket->ViceId = htonl(ticket->ViceId);
208         ticket->BeginTimestamp = htonl(ticket->BeginTimestamp);
209         ticket->EndTimestamp = htonl(ticket->EndTimestamp);
210     }
211 }
212
213 void
214 inparam_conversion(afs_int32 cmd, char *buffer, afs_int32 ntoh_conv)
215 {
216     struct Acl *acl;
217     afs_int32 *lptr, i;
218     char *ptr;
219
220     switch (cmd & 0xffff) {
221     case VIOCSETAL & 0xffff:
222         acl = RParseAcl(buffer);
223         RAclToString(acl, buffer, ntoh_conv);
224         RCleanAcl(acl);
225         break;
226     case VIOCSETTOK & 0xffff:
227         lptr = (afs_int32 *) buffer;
228         /* i is sizeof of the secret ticket */
229         if (ntoh_conv) {
230             i = ntohl(*lptr);
231             *lptr = i;
232         } else {
233             i = *lptr;
234             *lptr = htonl(i);
235         }
236         lptr++;
237         ptr = (char *)lptr;
238         ptr += i;               /* skip over the ticket */
239         lptr = (afs_int32 *) ptr;
240         /* i is now size of the clear token */
241         if (ntoh_conv) {
242             i = ntohl(*lptr);
243             *lptr = i;
244         } else {
245             i = *lptr;
246             *lptr = htonl(i);
247         }
248         lptr++;
249         ptr = (char *)lptr;
250         RClearToken_convert(ptr, ntoh_conv);
251         ptr += i;               /* sizeof(struct ClearToken) */
252         lptr = (afs_int32 *) ptr;
253         if (ntoh_conv)
254             *lptr = ntohl(*lptr);
255         else
256             *lptr = htonl(*lptr);
257         lptr++;                 /* primary flag */
258         break;
259     case VIOCSETVOLSTAT & 0xffff:
260         RFetchVolumeStatus_conversion(buffer, ntoh_conv);
261         break;
262     case VIOCGETTOK & 0xffff:
263     case VIOCCKSERV & 0xffff:
264     case VIOCACCESS & 0xffff:
265     case VIOCSETCACHESIZE & 0xffff:
266     case VIOCGETCELL & 0xffff:
267     case VIOC_AFS_MARINER_HOST & 0xffff:
268     case VIOC_VENUSLOG & 0xffff:
269     case VIOC_AFS_SYSNAME & 0xffff:
270     case VIOC_EXPORTAFS & 0xffff:
271         lptr = (afs_int32 *) buffer;
272         if (ntoh_conv)
273             *lptr = ntohl(*lptr);
274         else
275             *lptr = htonl(*lptr);
276         break;
277     case VIOC_SETCELLSTATUS & 0xffff:
278         lptr = (afs_int32 *) buffer;
279         if (ntoh_conv)
280             *lptr = ntohl(*lptr);
281         else
282             *lptr = htonl(*lptr);
283         lptr++;
284         if (ntoh_conv)
285             *lptr = ntohl(*lptr);
286         else
287             *lptr = htonl(*lptr);
288         break;
289     case VIOCGETAL & 0xffff:
290     case VIOCGETVOLSTAT & 0xffff:
291     case VIOCGETCACHEPARMS & 0xffff:
292     case VIOCFLUSH & 0xffff:
293     case VIOCSTAT & 0xffff:
294     case VIOCUNLOG & 0xffff:
295     case VIOCCKBACK & 0xffff:
296     case VIOCCKCONN & 0xffff:
297     case VIOCGETTIME & 0xffff:  /* Obsolete */
298     case VIOCWHEREIS & 0xffff:
299     case VIOCPREFETCH & 0xffff:
300     case VIOCNOP & 0xffff:      /* Obsolete */
301     case VIOCENGROUP & 0xffff:  /* Obsolete */
302     case VIOCDISGROUP & 0xffff: /* Obsolete */
303     case VIOCLISTGROUPS & 0xffff:       /* Obsolete */
304     case VIOCUNPAG & 0xffff:
305     case VIOCWAITFOREVER & 0xffff:      /* Obsolete */
306     case VIOCFLUSHCB & 0xffff:
307     case VIOCNEWCELL & 0xffff:
308     case VIOC_AFS_DELETE_MT_PT & 0xffff:
309     case VIOC_AFS_STAT_MT_PT & 0xffff:
310     case VIOC_FILE_CELL_NAME & 0xffff:
311     case VIOC_GET_WS_CELL & 0xffff:
312     case VIOC_GET_PRIMARY_CELL & 0xffff:
313     case VIOC_GETCELLSTATUS & 0xffff:
314     case VIOC_FLUSHVOLUME & 0xffff:
315     case VIOCGETFID & 0xffff:   /* nothing yet */
316         break;
317     default:
318         /* Note that new pioctls are supposed to be in network order! */
319         break;
320     }
321 }
322
323
324 void
325 outparam_conversion(afs_int32 cmd, char *buffer, afs_int32 ntoh_conv)
326 {
327     struct Acl *acl;
328     afs_int32 *lptr, i;
329     char *ptr;
330
331     switch (cmd & 0xffff) {
332     case VIOCGETAL & 0xffff:
333         acl = RParseAcl(buffer);
334         RAclToString(acl, buffer, ntoh_conv);
335         RCleanAcl(acl);
336         break;
337     case VIOCGETVOLSTAT & 0xffff:
338         RFetchVolumeStatus_conversion(buffer, ntoh_conv);
339         break;
340     case VIOCSETVOLSTAT & 0xffff:
341         RFetchVolumeStatus_conversion(buffer, ntoh_conv);
342         break;
343     case VIOCGETTOK & 0xffff:
344         lptr = (afs_int32 *) buffer;
345         /* i is set to sizeof secret ticket */
346         if (ntoh_conv) {
347             i = ntohl(*lptr);
348             *lptr = i;
349         } else {
350             i = *lptr;
351             *lptr = htonl(i);
352         }
353         lptr++;
354         ptr = (char *)lptr;
355         ptr += i;               /* skip over the ticket */
356         lptr = (afs_int32 *) ptr;
357         /* i is set to sizeof clear ticket */
358         if (ntoh_conv) {
359             i = ntohl(*lptr);
360             *lptr = i;
361         } else {
362             i = *lptr;
363             *lptr = htonl(i);
364         }
365         lptr++;
366         ptr = (char *)lptr;
367         RClearToken_convert(ptr, ntoh_conv);
368         ptr += i;               /* sizeof(struct ClearToken) */
369         lptr = (afs_int32 *) ptr;
370         if (ntoh_conv)
371             *lptr = ntohl(*lptr);
372         else
373             *lptr = htonl(*lptr);
374         lptr++;                 /* primary flag */
375         break;
376     case VIOCCKCONN & 0xffff:
377     case VIOC_AFS_MARINER_HOST & 0xffff:
378     case VIOC_VENUSLOG & 0xffff:
379     case VIOC_GETCELLSTATUS & 0xffff:
380     case VIOC_AFS_SYSNAME & 0xffff:
381     case VIOC_EXPORTAFS & 0xffff:
382         lptr = (afs_int32 *) buffer;
383         if (ntoh_conv)
384             *lptr = ntohl(*lptr);
385         else
386             *lptr = htonl(*lptr);
387         break;
388     case VIOCGETCACHEPARMS & 0xffff:
389         lptr = (afs_int32 *) buffer;
390         for (i = 0; i < MAXGCSIZE; i++, lptr++) {
391             if (ntoh_conv)
392                 *lptr = ntohl(*lptr);
393             else
394                 *lptr = htonl(*lptr);
395         }
396         break;
397     case VIOCUNLOG & 0xffff:
398     case VIOCCKSERV & 0xffff:   /* Already in network order */
399     case VIOCCKBACK & 0xffff:
400     case VIOCGETTIME & 0xffff:  /* Obsolete */
401     case VIOCWHEREIS & 0xffff:  /* Already in network order */
402     case VIOCPREFETCH & 0xffff:
403     case VIOCNOP & 0xffff:      /* Obsolete */
404     case VIOCENGROUP & 0xffff:  /* Obsolete */
405     case VIOCDISGROUP & 0xffff: /* Obsolete */
406     case VIOCLISTGROUPS & 0xffff:       /* Obsolete */
407     case VIOCACCESS & 0xffff:
408     case VIOCUNPAG & 0xffff:
409     case VIOCWAITFOREVER & 0xffff:      /* Obsolete */
410     case VIOCSETCACHESIZE & 0xffff:
411     case VIOCFLUSHCB & 0xffff:
412     case VIOCNEWCELL & 0xffff:
413     case VIOCGETCELL & 0xffff:  /* Already in network order */
414     case VIOC_AFS_DELETE_MT_PT & 0xffff:
415     case VIOC_AFS_STAT_MT_PT & 0xffff:
416     case VIOC_FILE_CELL_NAME & 0xffff:  /* no need to convert */
417     case VIOC_GET_WS_CELL & 0xffff:     /* no need to convert */
418     case VIOCGETFID & 0xffff:   /* nothing yet */
419     case VIOCSETAL & 0xffff:
420     case VIOCFLUSH & 0xffff:
421     case VIOCSTAT & 0xffff:
422     case VIOCSETTOK & 0xffff:
423     case VIOC_GET_PRIMARY_CELL & 0xffff:        /* The cell is returned here */
424     case VIOC_SETCELLSTATUS & 0xffff:
425     case VIOC_FLUSHVOLUME & 0xffff:
426         break;
427     default:
428         /* Note that new pioctls are supposed to be in network order! */
429         break;
430     }
431 }