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