399b818b04f3ba5222071cd3395cae0298e50f54
[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 RCSID("$Header$");
14
15 #include <errno.h>
16 #include <sys/param.h>
17 #include <sys/types.h>
18 #include <afs/vice.h>
19 #ifdef AFS_NT40_ENV
20 #include <winsock2.h>
21 #else
22 #include <netdb.h>
23 #include <netinet/in.h>
24 #include <sys/file.h>
25 #endif
26 #include <sys/stat.h>
27 #include <stdio.h>
28 #ifdef HAVE_STRING_H
29 #include <string.h>
30 #else
31 #ifdef HAVE_STRINGS_H
32 #include <strings.h>
33 #endif
34 #endif
35 #include <afs/afsint.h>
36 #include <afs/venus.h>
37 #include <rx/xdr.h>
38 #include "rmtsys.h"
39
40
41 /*
42  * We deal with converting pioctl parameters between host and network order.
43  * Painful but somebody has to do this and pioctl is the best place rather than
44  * leaving it to the calling application programs!
45  */
46
47 #define MAXNAME         100
48 #define MAXSIZE         2048
49 #define MAXHOSTS        8       /* XXX HARD Limit limitation XXX */
50 #define MAXGCSIZE       16
51
52 struct Acl {
53     int     nplus;
54     int     nminus;
55     struct  AclEntry *pluslist;
56     struct  AclEntry *minuslist;
57 };
58
59 struct AclEntry {
60     struct  AclEntry    *next;
61     char                name[MAXNAME];
62     afs_int32           rights;
63 };
64
65 struct ClearToken {
66         afs_int32 AuthHandle;
67         char HandShakeKey[8];
68         afs_int32 ViceId;
69         afs_int32 BeginTimestamp;
70         afs_int32 EndTimestamp;
71 };
72
73 char *RSkipLine (astr)
74     register char *astr; {
75     while (*astr !='\n') astr++;
76     astr++;
77     return astr;
78 }
79
80
81 struct Acl *RParseAcl(astr)
82     char *astr; {
83     int nplus, nminus, i, trights;
84     char tname[MAXNAME];
85     struct AclEntry *first, *last, *tl;
86     struct Acl *ta;
87     sscanf(astr, "%d", &nplus);
88     astr = RSkipLine(astr);
89     sscanf(astr, "%d", &nminus);
90     astr = RSkipLine(astr);
91
92     ta = (struct Acl *) malloc (sizeof (struct Acl));
93     ta->nplus = nplus;
94     ta->nminus = nminus;
95
96     last = 0;
97     first = 0;
98     for(i=0;i<nplus;i++) {
99         sscanf(astr, "%100s %d", tname, &trights);
100         astr = RSkipLine(astr);
101         tl = (struct AclEntry *) malloc(sizeof (struct AclEntry));
102         if (!first) first = tl;
103         strcpy(tl->name, tname);
104         tl->rights = trights;
105         tl->next = 0;
106         if (last) last->next = tl;
107         last = tl;
108     }
109     ta->pluslist = first;
110
111     last = 0;
112     first = 0;
113     for(i=0;i<nminus;i++) {
114         sscanf(astr, "%100s %d", tname, &trights);
115         astr = RSkipLine(astr);
116         tl = (struct AclEntry *) malloc(sizeof (struct AclEntry));
117         if (!first) first = tl;
118         strcpy(tl->name, tname);
119         tl->rights = trights;
120         tl->next = 0;
121         if (last) last->next = tl;
122         last = tl;
123     }
124     ta->minuslist = first;
125
126     return ta;
127 }
128
129
130 RAclToString(acl, mydata, ntoh_conv)
131 struct Acl *acl;
132 char *mydata;
133 int ntoh_conv; {
134     char tstring[MAXSIZE];
135     struct AclEntry *tp;
136
137 /* No conversion needed since they're in network order in the first place */
138     sprintf(mydata, "%d\n%d\n", acl->nplus, acl->nminus);
139     for(tp = acl->pluslist;tp;tp=tp->next) {
140         sprintf(tstring, "%s %d\n", tp->name, tp->rights);
141         strcat(mydata, tstring);
142     }
143     for(tp = acl->minuslist;tp;tp=tp->next) {
144         sprintf(tstring, "%s %d\n", tp->name, tp->rights);
145         strcat(mydata, tstring);
146     }
147 }
148
149
150 /* Free all malloced stuff */
151 RCleanAcl(aa)
152 struct Acl *aa; {
153     register struct AclEntry *te, *ne;
154
155     for(te = aa->pluslist; te; te=ne) {
156         ne = te->next;
157         free(te);
158     }
159     for(te = aa->minuslist; te; te=ne) {
160         ne = te->next;
161         free(te);
162     }
163     free(aa);
164 }
165
166
167 RFetchVolumeStatus_conversion(data, ntoh_conv)
168 char *data;
169 int ntoh_conv;
170 {
171     struct AFSFetchVolumeStatus *status = (AFSFetchVolumeStatus *)data;
172
173     if (ntoh_conv) { /* Network -> Host */
174         status->Vid = ntohl(status->Vid);
175         status->ParentId = ntohl(status->ParentId);
176 #ifdef  notdef
177 /* save cycles */
178         status->OnLine = status->OnLine;
179         status->InService = status->InService;
180         status->Blessed = status->Blessed;
181         status->NeedsSalvage = status->NeedsSalvage;
182 #endif
183         status->Type = ntohl(status->Type);
184         status->MinQuota = ntohl(status->MinQuota);
185         status->MaxQuota = ntohl(status->MaxQuota);
186         status->BlocksInUse = ntohl(status->BlocksInUse);
187         status->PartBlocksAvail = ntohl(status->PartBlocksAvail);
188         status->PartMaxBlocks = ntohl(status->PartMaxBlocks);
189     } else {    /* Host -> Network */
190         status->Vid = htonl(status->Vid);
191         status->ParentId = htonl(status->ParentId);
192 #ifdef  notdef
193 /* save cycles */
194         status->OnLine = status->OnLine;
195         status->InService = status->InService;
196         status->Blessed = status->Blessed;
197         status->NeedsSalvage = status->NeedsSalvage;
198 #endif
199         status->Type = htonl(status->Type);
200         status->MinQuota = htonl(status->MinQuota);
201         status->MaxQuota = htonl(status->MaxQuota);
202         status->BlocksInUse = htonl(status->BlocksInUse);
203         status->PartBlocksAvail = htonl(status->PartBlocksAvail);
204         status->PartMaxBlocks = htonl(status->PartMaxBlocks);
205     }
206 }
207
208 RClearToken_convert(ptr, ntoh_conv)
209 char *ptr;
210 int ntoh_conv;
211 {
212     struct ClearToken *ticket = (struct ClearToken *)ptr;
213
214     if (ntoh_conv) {    /* Network -> host */
215         ticket->AuthHandle = ntohl(ticket->AuthHandle);
216         ticket->ViceId = ntohl(ticket->ViceId);
217         ticket->BeginTimestamp = ntohl(ticket->BeginTimestamp);
218         ticket->EndTimestamp = ntohl(ticket->EndTimestamp);
219     } else {    /* Host -> Network */
220         ticket->AuthHandle = htonl(ticket->AuthHandle);
221         ticket->ViceId = htonl(ticket->ViceId);
222         ticket->BeginTimestamp = htonl(ticket->BeginTimestamp);
223         ticket->EndTimestamp = htonl(ticket->EndTimestamp);
224     }   
225 }
226
227 inparam_conversion(cmd, buffer, ntoh_conv)
228 afs_int32 cmd, ntoh_conv;
229 char *buffer;
230 {
231     struct Acl *acl;
232     afs_int32 *lptr, i;
233     char *ptr;
234
235     switch (cmd & 0xffff) {
236         case VIOCSETAL & 0xffff:
237             acl = RParseAcl(buffer);
238             RAclToString(acl, buffer, ntoh_conv);
239             RCleanAcl(acl);
240             break;
241         case VIOCSETTOK & 0xffff:
242             lptr = (afs_int32 *)buffer;
243             /* i is sizeof of the secret ticket */
244             if (ntoh_conv) {
245                 i = ntohl(*lptr);
246                 *lptr = i;
247             } else {
248                 i = *lptr;
249                 *lptr = htonl(i);
250             }
251             lptr++;
252             ptr = (char *)lptr;
253             ptr += i;   /* skip over the ticket */
254             lptr = (afs_int32 *)ptr;
255             /* i is now size of the clear token */
256             if (ntoh_conv) {
257                 i = ntohl(*lptr);
258                 *lptr = i;
259             } else {
260                 i = *lptr;
261                 *lptr = htonl(i);
262             }
263             lptr++;
264             ptr = (char *)lptr;
265             RClearToken_convert(ptr, ntoh_conv);
266             ptr += i;   /* sizeof(struct ClearToken) */
267             lptr = (afs_int32 *)ptr;
268             if (ntoh_conv)
269                 *lptr = ntohl(*lptr);
270             else
271                 *lptr = htonl(*lptr);
272             lptr++;   /* primary flag */            
273             break;
274         case VIOCSETVOLSTAT & 0xffff:
275             RFetchVolumeStatus_conversion(buffer, ntoh_conv);
276             break;
277         case VIOCGETTOK & 0xffff:
278             lptr = (afs_int32 *)buffer;
279             if (ntoh_conv)
280                 *lptr = ntohl(*lptr);
281             else
282                 *lptr = htonl(*lptr);
283             break;
284         case VIOCCKSERV & 0xffff:
285             lptr = (afs_int32 *)buffer;
286             if (ntoh_conv)
287                 *lptr = ntohl(*lptr);
288             else
289                 *lptr = htonl(*lptr);
290             break;
291         case VIOCACCESS & 0xffff:
292             lptr = (afs_int32 *)buffer;
293             if (ntoh_conv)
294                 *lptr = ntohl(*lptr);
295             else
296                 *lptr = htonl(*lptr);
297             break;
298         case VIOCSETCACHESIZE & 0xffff:
299             lptr = (afs_int32 *)buffer;
300             if (ntoh_conv)
301                 *lptr = ntohl(*lptr);
302             else
303                 *lptr = htonl(*lptr);
304             break;
305         case VIOCGETCELL & 0xffff:
306             lptr = (afs_int32 *)buffer;
307             if (ntoh_conv)
308                 *lptr = ntohl(*lptr);
309             else
310                 *lptr = htonl(*lptr);
311             break;
312         case VIOC_AFS_MARINER_HOST & 0xffff:
313             lptr = (afs_int32 *)buffer;
314             if (ntoh_conv)
315                 *lptr = ntohl(*lptr);
316             else
317                 *lptr = htonl(*lptr);
318             break;
319         case VIOC_VENUSLOG & 0xffff:
320             lptr = (afs_int32 *)buffer;
321             if (ntoh_conv)
322                 *lptr = ntohl(*lptr);
323             else
324                 *lptr = htonl(*lptr);
325             break;
326         case VIOC_SETCELLSTATUS & 0xffff:
327             lptr = (afs_int32 *)buffer;
328             if (ntoh_conv)
329                 *lptr = ntohl(*lptr);
330             else
331                 *lptr = htonl(*lptr);
332             lptr++;
333             if (ntoh_conv)
334                 *lptr = ntohl(*lptr);
335             else
336                 *lptr = htonl(*lptr);
337             break;
338         case VIOC_AFS_SYSNAME & 0xffff:
339             lptr = (afs_int32 *)buffer;
340             if (ntoh_conv)
341                 *lptr = ntohl(*lptr);
342             else
343                 *lptr = htonl(*lptr);
344             break;
345         case VIOC_EXPORTAFS & 0xffff:
346             lptr = (afs_int32 *)buffer;
347             if (ntoh_conv)
348                 *lptr = ntohl(*lptr);
349             else
350                 *lptr = htonl(*lptr);
351             break;
352         case VIOCGETAL & 0xffff:
353         case VIOCGETVOLSTAT & 0xffff:
354         case VIOCGETCACHEPARMS & 0xffff:
355         case VIOCFLUSH & 0xffff:
356         case VIOCSTAT & 0xffff:
357         case VIOCUNLOG & 0xffff:
358         case VIOCCKBACK & 0xffff:
359         case VIOCCKCONN & 0xffff:
360         case VIOCGETTIME & 0xffff:      /* Obsolete */
361         case VIOCWHEREIS & 0xffff:
362         case VIOCPREFETCH & 0xffff:
363         case VIOCNOP & 0xffff:          /* Obsolete */
364         case VIOCENGROUP & 0xffff:      /* Obsolete */
365         case VIOCDISGROUP & 0xffff:     /* Obsolete */
366         case VIOCLISTGROUPS & 0xffff:   /* Obsolete */
367         case VIOCUNPAG & 0xffff:
368         case VIOCWAITFOREVER & 0xffff:  /* Obsolete */
369         case VIOCFLUSHCB & 0xffff:
370         case VIOCNEWCELL & 0xffff:
371         case VIOC_AFS_DELETE_MT_PT & 0xffff:
372         case VIOC_AFS_STAT_MT_PT & 0xffff:
373         case VIOC_FILE_CELL_NAME & 0xffff:
374         case VIOC_GET_WS_CELL & 0xffff:
375         case VIOC_GET_PRIMARY_CELL & 0xffff:
376         case VIOC_GETCELLSTATUS & 0xffff:
377         case VIOC_FLUSHVOLUME & 0xffff:
378         case VIOCGETFID & 0xffff:       /* nothing yet */
379             break;
380         default:
381             /* Note that new pioctls are supposed to be in network order! */
382             break;          
383     }
384 }
385     
386
387 outparam_conversion(cmd, buffer, ntoh_conv)
388 afs_int32 cmd, ntoh_conv;
389 char *buffer;
390 {
391     struct Acl *acl;
392     afs_int32 *lptr, i;
393     char *ptr;
394
395     switch (cmd & 0xffff) {
396         case VIOCGETAL & 0xffff:
397             acl = RParseAcl(buffer);
398             RAclToString(acl, buffer, ntoh_conv);
399             RCleanAcl(acl);
400             break;
401         case VIOCGETVOLSTAT & 0xffff:
402             RFetchVolumeStatus_conversion(buffer, ntoh_conv);
403             break;
404         case VIOCSETVOLSTAT & 0xffff:
405             RFetchVolumeStatus_conversion(buffer, ntoh_conv);
406             break;
407         case VIOCGETTOK & 0xffff:
408             lptr = (afs_int32 *)buffer;                 
409             /* i is set to sizeof secret ticket */
410             if (ntoh_conv) {
411                 i = ntohl(*lptr);
412                 *lptr = i;
413             } else {
414                 i = *lptr;
415                 *lptr = htonl(i);
416             }
417             lptr++;
418             ptr = (char *)lptr;
419             ptr += i;   /* skip over the ticket */
420             lptr = (afs_int32 *)ptr;
421             /* i is set to sizeof clear ticket */
422             if (ntoh_conv) {
423                 i = ntohl(*lptr);
424                 *lptr = i;
425             } else {
426                 i = *lptr;
427                 *lptr = htonl(i);
428             }
429             lptr++;
430             ptr = (char *)lptr;
431             RClearToken_convert(ptr, ntoh_conv);
432             ptr += i;   /* sizeof(struct ClearToken) */
433             lptr = (afs_int32 *)ptr;
434             if (ntoh_conv)
435                 *lptr = ntohl(*lptr);
436             else
437                 *lptr = htonl(*lptr);
438             lptr++;   /* primary flag */         
439             break;
440         case VIOCCKCONN & 0xffff:
441             if (ntoh_conv)
442                 *lptr = ntohl(*lptr);
443             else
444                 *lptr = htonl(*lptr);
445             break;
446         case VIOC_AFS_MARINER_HOST & 0xffff:
447             lptr = (afs_int32 *)buffer;
448             if (ntoh_conv)
449                 *lptr = ntohl(*lptr);
450             else
451                 *lptr = htonl(*lptr);
452             break;
453         case VIOC_VENUSLOG & 0xffff:
454             lptr = (afs_int32 *)buffer;
455             if (ntoh_conv)
456                 *lptr = ntohl(*lptr);
457             else
458                 *lptr = htonl(*lptr);
459             break;
460         case VIOC_GETCELLSTATUS & 0xffff:
461             lptr = (afs_int32 *)buffer;
462             if (ntoh_conv)
463                 *lptr = ntohl(*lptr);
464             else
465                 *lptr = htonl(*lptr);
466             break;
467         case VIOC_AFS_SYSNAME & 0xffff:
468             lptr = (afs_int32 *)buffer;
469             if (ntoh_conv)
470                 *lptr = ntohl(*lptr);
471             else
472                 *lptr = htonl(*lptr);
473             break;
474         case VIOC_EXPORTAFS & 0xffff:
475             lptr = (afs_int32 *)buffer;
476             if (ntoh_conv)
477                 *lptr = ntohl(*lptr);
478             else
479                 *lptr = htonl(*lptr);
480             break;
481         case VIOCGETCACHEPARMS & 0xffff: 
482             lptr = (afs_int32 *)buffer;
483             for (i=0; i < MAXGCSIZE; i++, lptr++) {
484                 if (ntoh_conv)
485                     *lptr = ntohl(*lptr);
486                 else
487                     *lptr = htonl(*lptr);
488             }
489             break;
490         case VIOCUNLOG & 0xffff:
491         case VIOCCKSERV & 0xffff:       /* Already in network order */
492         case VIOCCKBACK & 0xffff:
493         case VIOCGETTIME & 0xffff:      /* Obsolete */
494         case VIOCWHEREIS & 0xffff:      /* Already in network order */
495         case VIOCPREFETCH & 0xffff:
496         case VIOCNOP & 0xffff:          /* Obsolete */
497         case VIOCENGROUP & 0xffff:      /* Obsolete */
498         case VIOCDISGROUP & 0xffff:     /* Obsolete */
499         case VIOCLISTGROUPS & 0xffff:   /* Obsolete */
500         case VIOCACCESS & 0xffff:
501         case VIOCUNPAG & 0xffff:
502         case VIOCWAITFOREVER & 0xffff:  /* Obsolete */
503         case VIOCSETCACHESIZE & 0xffff:
504         case VIOCFLUSHCB & 0xffff:
505         case VIOCNEWCELL & 0xffff:
506         case VIOCGETCELL & 0xffff:      /* Already in network order */
507         case VIOC_AFS_DELETE_MT_PT & 0xffff:
508         case VIOC_AFS_STAT_MT_PT & 0xffff:
509         case VIOC_FILE_CELL_NAME & 0xffff:      /* no need to convert */
510         case VIOC_GET_WS_CELL & 0xffff: /* no need to convert */
511         case VIOCGETFID & 0xffff:       /* nothing yet */
512         case VIOCSETAL & 0xffff:
513         case VIOCFLUSH & 0xffff:
514         case VIOCSTAT & 0xffff:
515         case VIOCSETTOK & 0xffff:
516         case VIOC_GET_PRIMARY_CELL & 0xffff:    /* The cell is returned here */
517         case VIOC_SETCELLSTATUS & 0xffff:
518         case VIOC_FLUSHVOLUME & 0xffff:
519             break;
520         default:
521             /* Note that new pioctls are supposed to be in network order! */
522             break;
523     }
524 }
525
526
527
528
529
530
531