src/viced/fsprobe.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
  14 #include <afs/stds.h>
  15 #include <afs/afsint.h>
  16 #include <sys/socket.h>
  17 #include <rx/rx_globals.h>
  18 #include <netinet/in.h>
  19 #include <arpa/inet.h>
  20 #include <netdb.h>
  21 #include <ubik.h>
  22 #include <string.h>
  23
  24 struct ubik_client *cstruct;
  25 struct rx_connection *serverconns[MAXSERVERS];
  26 char *(args[50]);
  27
  28 afs_int32
  29 pxclient_Initialize(int auth, afs_int32 serverAddr)
  30 {
  31     afs_int32 code;
  32     rx_securityIndex scIndex;
  33     struct rx_securityClass *sc;
  34
  35     code = rx_Init(htons(2115) /*0 */ );
  36     if (code) {
  37         fprintf(stderr, "pxclient_Initialize:  Could not initialize rx.\n");
  38         return code;
  39     }
  40     scIndex = RX_SECIDX_NULL;
  41     rx_SetRxDeadTime(50);
  42     sc = rxnull_NewClientSecurityObject();
  43     serverconns[0] =
  44         rx_NewConnection(serverAddr, htons(7000), 1, sc, scIndex);
  45
  46     code = ubik_ClientInit(serverconns, &cstruct);
  47
  48     if (code) {
  49         fprintf(stderr, "pxclient_Initialize: ubik client init failed.\n");
  50         return code;
  51     }
  52     return 0;
  53 }
  54
  55 /* main program */
  56
  57 #include "AFS_component_version_number.c"
  58
  59 int
  60 main(int argc, char **argv)
  61 {
  62     char **av = argv;
  63     struct sockaddr_in host;
  64     afs_int32 code;
  65     struct hostent *hp;
  66     char hnamebuf[200];
  67     struct timeval tv;
  68     int noAuth = 1;             /* Default is authenticated connections */
  69
  70     argc--, av++;
  71     if (argc < 1) {
  72         printf("usage: pxclient <serverHost>\n");
  73         exit(1);
  74     }
  75     memset(&host, 0, sizeof(struct sockaddr_in));
  76     host.sin_family = AF_INET;
  77     host.sin_addr.s_addr = inet_addr(av[0]);
  78 #ifdef STRUCT_SOCKADDR_HAS_SA_LEN
  79     host.sin_len = sizeof(struct sockaddr_in);
  80 #endif
  81     if (host.sin_addr.s_addr != -1) {
  82         strcpy(hnamebuf, av[0]);
  83     } else {
  84         hp = gethostbyname(av[0]);
  85         if (hp) {
  86             host.sin_family = hp->h_addrtype;
  87             memcpy((caddr_t) & host.sin_addr, hp->h_addr, hp->h_length);
  88         } else {
  89             printf("unknown server host %s\n", av[0]);
  90             exit(1);
  91         }
  92     }
  93     if ((code = pxclient_Initialize(noAuth, host.sin_addr.s_addr)) != 0) {
  94         printf("Couldn't initialize fs library (code=%d).\n", code);
  95         exit(1);
  96     }
  97
  98     code = ubik_Call(RXAFS_GetTime, cstruct, 0, &tv.tv_sec, &tv.tv_usec);
  99     if (!code)
 100         printf("AFS_GetTime on %s sec=%ld, usec=%ld\n", av[0], tv.tv_sec,
 101                (long int)tv.tv_usec);
 102     else
 103         printf("return code is %d\n", code);
 104
 105 #ifdef notdef
 106     while (1) {
 107         char line[500];
 108         int nargs;
 109
 110         printf("fs> ");
 111         if (fgets(line, 499, stdin) != NULL) {
 112             char *oper;
 113             char **argp = args;
 114             GetArgs(line, argp, &nargs);
 115             oper = &argp[0][0];
 116             ++argp, --nargs;
 117             if (!strcmp(oper, "probe")) {
 118                 code =
 119                     ubik_Call(RXAFS_GetTime, cstruct, 0, &tv.tv_sec,
 120                               &tv.tv_usec);
 121                 printf("return code is %d\n", code);
 122                 if (!code)
 123                     printf("sec=%d\n", tv.tv_sec);
 124             } else if (!strcmp(oper, "fsstats")) {
 125                 struct afsStatistics stats;
 126
 127                 code = ubik_AFS_GetStatistics(cstruct, 0, &stats);
 128                 printf("return code is %d\n", code);
 129             } else if (!strcmp(oper, "fd")) {
 130                 code = FetchData(argp);
 131                 printf("return code is %d\n", code);
 132             } else if (!strcmp(oper, "fs")) {
 133                 code = FetchStatus(argp);
 134                 printf("return code is %d\n", code);
 135             } else if (!strcmp(oper, "fa")) {
 136                 code = FetchACL(argp);
 137                 printf("return code is %d\n", code);
 138             } else if (!strcmp(oper, "sd")) {
 139                 code = StoreData(argp);
 140                 printf("return code is %d\n", code);
 141             } else if (!strcmp(oper, "ss")) {
 142                 code = StoreStatus(argp);
 143                 printf("return code is %d\n", code);
 144             } else if (!strcmp(oper, "sa")) {
 145                 code = StoreACL(argp);
 146                 printf("return code is %d\n", code);
 147             } else if (!strcmp(oper, "cf")) {
 148                 code = CreateFile(argp);
 149                 printf("return code is %d\n", code);
 150             } else if (!strcmp(oper, "rf")) {
 151                 code = RemoveFile(argp);
 152                 printf("return code is %d\n", code);
 153             } else if (!strcmp(oper, "rn")) {
 154                 code = Rename(argp);
 155                 printf("return code is %d\n", code);
 156             } else if (!strcmp(oper, "sl")) {
 157                 code = Symlink(argp);
 158                 printf("return code is %d\n", code);
 159             } else if (!strcmp(oper, "hl")) {
 160                 code = HardLink(argp);
 161                 printf("return code is %d\n", code);
 162             } else if (!strcmp(oper, "md")) {
 163                 code = MakeDir(argp);
 164                 printf("return code is %d\n", code);
 165             } else if (!strcmp(oper, "rd")) {
 166                 code = RemoveDir(argp);
 167                 printf("return code is %d\n", code);
 168             } else if (!strcmp(oper, "rdd")) {
 169                 code = Readdir(argp);
 170                 printf("return code is %d\n", code);
 171             } else if (!strcmp(oper, "mm")) {
 172                 code = MakeMountPoint(argp);
 173                 printf("return code is %d\n", code);
 174             } else if (!strcmp(oper, "rt")) {
 175                 code = ReleaseTokens(argp);
 176                 printf("return code is %d\n", code);
 177             } else if (!strcmp(oper, "bs")) {
 178                 code = BulkStatus(argp);
 179                 printf("return code is %d\n", code);
 180             } else if (!strcmp(oper, "lk")) {
 181                 code = Lookup(argp);
 182                 printf("return code is %d\n", code);
 183             } else if (!strcmp(oper, "gt")) {
 184                 code = GetToken(argp);
 185                 printf("return code is %d\n", code);
 186             } else if (!strcmp(oper, "ka")) {
 187                 code = KeepAlive(argp);
 188                 printf("return code is %d\n", code);
 189             } else if ((!strcmp(oper, "q")) || !strcmp(oper, "quit"))
 190                 exit(0);
 191             else {
 192                 printf("Unknown oper! Available operations: \n\n");
 193                 printf("fd <vnode> <unique> <pos> <len>\n");
 194                 printf("fs <vnode> <unique>\n");
 195                 printf("fa <vnode> <unique>\n");
 196                 printf
 197                     ("sd <vnode> <unique> <pos> <len> <flen> [<mode>|-1] [<owner>|-1] [<length>|-1] <string>\n");
 198                 printf
 199                     ("ss <vnode> <unique> [<mode>|-1] [<owner>|-1] [<length>|-1]\n");
 200                 printf("sa <vnode> <unique> <string>\n");
 201                 printf("rf <vnode> <unique> <name>\n");
 202                 printf
 203                     ("cf <vnode> <unique> <name> [<mode>|-1] [<owner>|-1] [<length>|-1]\n");
 204                 printf
 205                     ("rn <ovnode> <ounique> <oname> <nvnode> <nunique> <nname>\n");
 206                 printf
 207                     ("sl <vnode> <unique> <name> <contents> [<mode>|-1] [<owner>|-1] [<length>|-1]\n");
 208                 printf("hl <dvnode> <dunique> <name> <evnode> <eunique>\n");
 209                 printf
 210                     ("md <vnode> <unique> <name> [<mode>|-1] [<owner>|-1] [<length>|-1]\n");
 211                 printf("rd <vnode> <unique> <name>\n");
 212                 printf("rdd <vnode> <unique> <pos> <len>\n");
 213                 printf("lk <vnode> <unique> <name>\n");
 214                 printf("gt <vnode> <unique> <tokenID>\n");
 215                 printf("ka <vol.l> <vnode> <unique> <isExec> <kaTime>\n");
 216             }
 217         }
 218     }
 219 #endif
 220     return 0;
 221 }
 222
 223
 224 void
 225 GetArgs(char *line, char **args, int *nargs)
 226 {
 227     *nargs = 0;
 228     while (*line) {
 229         char *last = line;
 230         while (*line == ' ')
 231             line++;
 232         if (*last == ' ')
 233             *last = 0;
 234         if (!*line)
 235             break;
 236         *args++ = line, (*nargs)++;
 237         while (*line && *line != ' ')
 238             line++;
 239     }
 240 }
 241
 242 #ifdef notdef
 243 afs_int32
 244 FetchData(char **argp)
 245 {
 246     struct afsFetchStatus OutStatus;
 247     struct afsToken Token;
 248     struct afsVolSync tsync;
 249     struct afsFid fid;
 250     int vnode, unique, position, length;
 251     int code;
 252     struct rx_call *tcall;
 253
 254     sscanf(&(*argp)[0], "%d", &vnode);
 255     ++argp;
 256     sscanf(&(*argp)[0], "%d", &unique);
 257     ++argp;
 258     memset(&fid, 0, sizeof(struct afsFid));
 259     fid.Volume.low = 10;        /* XXX */
 260     fid.Vnode = vnode;
 261     fid.Unique = unique;
 262     sscanf(&(*argp)[0], "%d", &position);
 263     ++argp;
 264     sscanf(&(*argp)[0], "%d", &length);
 265     ++argp;
 266     tcall = rx_NewCall(cstruct->conns[0]);
 267     code = StartAFS_FetchData(tcall, &fid, &hyp0, position, length, 0);
 268     if (!code) {
 269         code = FetchProc(tcall);
 270     }
 271     if (!code) {
 272         code = EndAFS_FetchData(tcall, &OutStatus, &Token, &tsync);
 273     }
 274     code = rx_EndCall(tcall, code);
 275     return code;
 276 }
 277
 278
 279 static afs_int32
 280 FetchProc(struct rx_call *acall)
 281 {
 282     extern char *malloc();
 283     char *tbuffer;
 284     afs_int32 tlen, length, code;
 285
 286     code = rx_Read(acall, &length, sizeof(afs_int32));
 287     length = ntohl(length);
 288     if (code != sizeof(afs_int32))
 289         return -1;
 290     tbuffer = malloc(256);
 291     while (length > 0) {
 292         tlen = (length > 256 ? 256 : length);
 293         code = rx_Read(acall, tbuffer, tlen);
 294         if (code != tlen) {
 295             free(tbuffer);
 296             return -1;
 297         }
 298         length -= tlen;
 299     }
 300     free(tbuffer);
 301     return 0;
 302 }
 303
 304
 305 afs_int32
 306 FetchStatus(char **argp)
 307 {
 308     struct afsFetchStatus OutStatus;
 309     struct afsToken Token;
 310     struct afsVolSync tsync;
 311     struct afsFid fid;
 312     int vnode, unique;
 313     int code;
 314
 315     sscanf(&(*argp)[0], "%d", &vnode);
 316     ++argp;
 317     sscanf(&(*argp)[0], "%d", &unique);
 318     ++argp;
 319     memset(&fid, 0, sizeof(struct afsFid));
 320     fid.Volume.low = 10;        /* XXX */
 321     fid.Vnode = vnode;
 322     fid.Unique = unique;
 323     code =
 324         ubik_AFS_FetchStatus(cstruct, 0, &fid, &hyp0, 0, &OutStatus,
 325                   &Token, &tsync);
 326     return (code);
 327 }
 328
 329
 330 afs_int32
 331 FetchACL(char **argp)
 332 {
 333     struct afsFetchStatus OutStatus;
 334     struct afsACL AccessList;
 335     struct afsToken Token;
 336     struct afsVolSync tsync;
 337     struct afsFid fid;
 338     int vnode, unique;
 339     int code;
 340
 341     sscanf(&(*argp)[0], "%d", &vnode);
 342     ++argp;
 343     sscanf(&(*argp)[0], "%d", &unique);
 344     ++argp;
 345     memset(&fid, 0, sizeof(struct afsFid));
 346     fid.Volume.low = 10;        /* XXX */
 347     fid.Vnode = vnode;
 348     fid.Unique = unique;
 349     code =
 350         ubik_AFS_FetchACL(cstruct, 0, &fid, &hyp0, 0, &AccessList,
 351                   &OutStatus, &tsync);
 352     return (code);
 353 }
 354
 355
 356 afs_int32
 357 StoreData(char **argp)
 358 {
 359     struct afsStoreStatus InStatus;
 360     struct afsFetchStatus OutStatus;
 361     struct afsVolSync tsync;
 362     struct afsFid fid;
 363     int vnode, unique, position, length, filelength;
 364     int mode, owner, len;
 365     int code;
 366     char *string;
 367     struct rx_call *tcall;
 368
 369     sscanf(&(*argp)[0], "%d", &vnode);
 370     ++argp;
 371     sscanf(&(*argp)[0], "%d", &unique);
 372     ++argp;
 373     memset(&fid, 0, sizeof(struct afsFid));
 374     fid.Volume.low = 10;        /* XXX */
 375     fid.Vnode = vnode;
 376     fid.Unique = unique;
 377     sscanf(&(*argp)[0], "%d", &position);
 378     ++argp;
 379     sscanf(&(*argp)[0], "%d", &length);
 380     ++argp;
 381     sscanf(&(*argp)[0], "%d", &filelength);
 382     ++argp;
 383     memset(&InStatus, 0, sizeof(struct afsStoreStatus));
 384     sscanf(&(*argp)[0], "%d", &mode);
 385     ++argp;
 386     sscanf(&(*argp)[0], "%d", &owner);
 387     ++argp;
 388     sscanf(&(*argp)[0], "%d", &len);
 389     ++argp;
 390     if (mode != -1) {
 391         InStatus.mode = mode;
 392         InStatus.mask |= AFS_SETMODE;
 393     }
 394     if (owner != -1) {
 395         InStatus.owner = owner;
 396         InStatus.mask |= AFS_SETOWNER;
 397     }
 398     if (length != -1) {
 399         InStatus.length = length;
 400         InStatus.mask |= AFS_SETLENGTH;
 401     }
 402     string = &argp[0][0];
 403     ++argp;
 404
 405     tcall = rx_NewCall(cstruct->conns[0]);
 406     code =
 407         StartAFS_StoreData(tcall, &fid, &InStatus, position, length,
 408                            filelength, &hyp0, 0);
 409     if (!code) {
 410         code = StoreProc(tcall, string, length);
 411     }
 412     if (!code) {
 413         code = EndAFS_StoreData(tcall, &OutStatus, &tsync);
 414     }
 415     code = rx_EndCall(tcall, code);
 416     return (code);
 417 }
 418
 419
 420 static afs_int32
 421 StoreProc(struct rx_call *acall, char *string, int length)
 422 {
 423     afs_int32 tlen, code;
 424
 425     while (length > 0) {
 426         tlen = (length > 256 ? 256 : length);
 427         code = rx_Write(acall, string, tlen);
 428         if (code != tlen) {
 429             return -1;
 430         }
 431         length -= tlen;
 432     }
 433     return 0;
 434 }
 435
 436
 437 afs_int32
 438 StoreStatus(char **argp)
 439 {
 440     struct afsStoreStatus InStatus;
 441     struct afsFetchStatus OutStatus;
 442     struct afsVolSync tsync;
 443     struct afsFid fid;
 444     int vnode, unique, mode, owner, length;
 445     int code;
 446
 447     sscanf(&(*argp)[0], "%d", &vnode);
 448     ++argp;
 449     sscanf(&(*argp)[0], "%d", &unique);
 450     ++argp;
 451     memset(&fid, 0, sizeof(struct afsFid));
 452     fid.Volume.low = 10;        /* XXX */
 453     fid.Vnode = vnode;
 454     fid.Unique = unique;
 455     memset(&InStatus, 0, sizeof(struct afsStoreStatus));
 456     sscanf(&(*argp)[0], "%d", &mode);
 457     ++argp;
 458     sscanf(&(*argp)[0], "%d", &owner);
 459     ++argp;
 460     sscanf(&(*argp)[0], "%d", &length);
 461     ++argp;
 462     if (mode != -1) {
 463         InStatus.mode = mode;
 464         InStatus.mask |= AFS_SETMODE;
 465     }
 466     if (owner != -1) {
 467         InStatus.owner = owner;
 468         InStatus.mask |= AFS_SETOWNER;
 469     }
 470     if (length != -1) {
 471         InStatus.length = length;
 472         InStatus.mask |= AFS_SETLENGTH;
 473     }
 474     code =
 475         ubik_AFS_StoreStatus(cstruct, 0, &fid, &InStatus, &hyp0, 0,
 476                   &OutStatus, &tsync);
 477     return (code);
 478 }
 479
 480
 481 afs_int32
 482 StoreACL(char **argp)
 483 {
 484     struct afsFetchStatus OutStatus;
 485     struct afsACL AccessList;
 486     struct afsToken Token;
 487     struct afsVolSync tsync;
 488     struct afsFid fid;
 489     char *string;
 490     int vnode, unique;
 491     int code;
 492
 493     sscanf(&(*argp)[0], "%d", &vnode);
 494     ++argp;
 495     sscanf(&(*argp)[0], "%d", &unique);
 496     ++argp;
 497     memset(&fid, 0, sizeof(struct afsFid));
 498     fid.Volume.low = 10;        /* XXX */
 499     fid.Vnode = vnode;
 500     fid.Unique = unique;
 501     string = &argp[0][0];
 502     ++argp;
 503     AccessList.afsACL_len = strlen(string) + 1;
 504     AccessList.afsACL_val = string;
 505     code =
 506         ubik_AFS_StoreACL(cstruct, 0, &fid, &AccessList, &hyp0, 0,
 507                   &OutStatus, &tsync);
 508     return (code);
 509 }
 510
 511
 512 afs_int32
 513 RemoveFile(char **argp)
 514 {
 515     struct afsFetchStatus OutDirStatus, OutFidStatus;
 516     struct afsVolSync tsync;
 517     struct afsFidName nameFid;
 518     struct afsFid fid, outFid;
 519     char *name;
 520     int vnode, unique;
 521     int code;
 522
 523     sscanf(&(*argp)[0], "%d", &vnode);
 524     ++argp;
 525     sscanf(&(*argp)[0], "%d", &unique);
 526     ++argp;
 527     memset(&fid, 0, sizeof(struct afsFid));
 528     fid.Volume.low = 10;        /* XXX */
 529     fid.Vnode = vnode;
 530     fid.Unique = unique;
 531     name = &argp[0][0];
 532     ++argp;
 533     memset(&nameFid, 0, sizeof(struct afsFidName));
 534     strcpy(nameFid.name, name);
 535     code =
 536         ubik_AFS_RemoveFile(cstruct, 0, &fid, &nameFid, &hyp0, 0,
 537                   &OutDirStatus, &OutFidStatus, &outFid, &tsync);
 538     return (code);
 539 }
 540
 541
 542 afs_int32
 543 CreateFile(char **argp)
 544 {
 545     struct afsFetchStatus OutDirStatus, OutFidStatus;
 546     struct afsStoreStatus InStatus;
 547     struct afsVolSync tsync;
 548     struct afsFid fid, outFid;
 549     struct afsToken Token;
 550     char *name;
 551     int vnode, unique, mode, owner, length;
 552     int code;
 553
 554     sscanf(&(*argp)[0], "%d", &vnode);
 555     ++argp;
 556     sscanf(&(*argp)[0], "%d", &unique);
 557     ++argp;
 558     memset(&fid, 0, sizeof(struct afsFid));
 559     fid.Volume.low = 10;        /* XXX */
 560     fid.Vnode = vnode;
 561     fid.Unique = unique;
 562     name = &argp[0][0];
 563     ++argp;
 564     memset(&InStatus, 0, sizeof(struct afsStoreStatus));
 565     sscanf(&(*argp)[0], "%d", &mode);
 566     ++argp;
 567     sscanf(&(*argp)[0], "%d", &owner);
 568     ++argp;
 569     sscanf(&(*argp)[0], "%d", &length);
 570     ++argp;
 571     if (mode != -1) {
 572         InStatus.mode = mode;
 573         InStatus.mask |= AFS_SETMODE;
 574     }
 575     if (owner != -1) {
 576         InStatus.owner = owner;
 577         InStatus.mask |= AFS_SETOWNER;
 578     }
 579     if (length != -1) {
 580         InStatus.length = length;
 581         InStatus.mask |= AFS_SETLENGTH;
 582     }
 583     code =
 584         ubik_AFS_CreateFile(cstruct, 0, &fid, name, &InStatus, &hyp0, 0,
 585                   &outFid, &OutFidStatus, &OutDirStatus, &Token, &tsync);
 586     return (code);
 587 }
 588
 589
 590 afs_int32
 591 Rename(char **argp)
 592 {
 593     struct afsFetchStatus OutOldDirStatus, OutNewDirStatus;
 594     struct afsFetchStatus OutOldFileStatus, OutNewFileStatus;
 595     struct afsVolSync tsync;
 596     struct afsFid OldDirFid, NewDirFid, OutOldFileFid, OutNewFileFid;
 597     struct afsFidName OldName, NewName;
 598     char *oname, *nname;
 599     int ovnode, ounique, nvnode, nunique;
 600     int code;
 601
 602     sscanf(&(*argp)[0], "%d", &ovnode);
 603     ++argp;
 604     sscanf(&(*argp)[0], "%d", &ounique);
 605     ++argp;
 606     memset(&OldDirFid, 0, sizeof(struct afsFid));
 607     OldDirFid.Volume.low = 10;  /* XXX */
 608     OldDirFid.Vnode = ovnode;
 609     OldDirFid.Unique = ounique;
 610     oname = &argp[0][0];
 611     ++argp;
 612     memset(&OldName, 0, sizeof(struct afsFidName));
 613     strcpy(OldName.name, oname);
 614     sscanf(&(*argp)[0], "%d", &nvnode);
 615     ++argp;
 616     sscanf(&(*argp)[0], "%d", &nunique);
 617     ++argp;
 618     memset(&NewDirFid, 0, sizeof(struct afsFid));
 619     NewDirFid.Volume.low = 10;  /* XXX */
 620     NewDirFid.Vnode = nvnode;
 621     NewDirFid.Unique = nunique;
 622     nname = &argp[0][0];
 623     ++argp;
 624     memset(&NewName, 0, sizeof(struct afsFidName));
 625     strcpy(NewName.name, nname);
 626     code =
 627         ubik_AFS_Rename(cstruct, 0, &OldDirFid, &OldName, &NewDirFid,
 628                   &NewName, &hyp0, 0, &OutOldDirStatus, &OutNewDirStatus,
 629                   &OutOldFileFid, &OutOldFileStatus, &OutNewFileFid,
 630                   &OutNewFileStatus, &tsync);
 631     return (code);
 632 }
 633
 634
 635 afs_int32
 636 Symlink(char **argp)
 637 {
 638     struct afsFetchStatus OutDirStatus, OutFidStatus;
 639     struct afsStoreStatus InStatus;
 640     struct afsVolSync tsync;
 641     struct afsFid fid, outFid;
 642     struct afsToken Token;
 643     char *name, *linkcontents;
 644     int vnode, unique, mode, owner, length;
 645     int code;
 646
 647     sscanf(&(*argp)[0], "%d", &vnode);
 648     ++argp;
 649     sscanf(&(*argp)[0], "%d", &unique);
 650     ++argp;
 651     memset(&fid, 0, sizeof(struct afsFid));
 652     fid.Volume.low = 10;        /* XXX */
 653     fid.Vnode = vnode;
 654     fid.Unique = unique;
 655     name = &argp[0][0];
 656     ++argp;
 657     linkcontents = &argp[0][0];
 658     ++argp;
 659     memset(&InStatus, 0, sizeof(struct afsStoreStatus));
 660     sscanf(&(*argp)[0], "%d", &mode);
 661     ++argp;
 662     sscanf(&(*argp)[0], "%d", &owner);
 663     ++argp;
 664     sscanf(&(*argp)[0], "%d", &length);
 665     ++argp;
 666     if (mode != -1) {
 667         InStatus.mode = mode;
 668         InStatus.mask |= AFS_SETMODE;
 669     }
 670     if (owner != -1) {
 671         InStatus.owner = owner;
 672         InStatus.mask |= AFS_SETOWNER;
 673     }
 674     if (length != -1) {
 675         InStatus.length = length;
 676         InStatus.mask |= AFS_SETLENGTH;
 677     }
 678     code =
 679         ubik_AFS_Symlink(cstruct, 0, &fid, name, linkcontents,
 680                   &InStatus, &hyp0, 0, &outFid, &OutFidStatus, &OutDirStatus,
 681                   &Token, &tsync);
 682     return (code);
 683 }
 684
 685
 686 afs_int32
 687 HardLink(char **argp)
 688 {
 689     struct afsFetchStatus OutDirStatus, OutFidStatus;
 690     struct afsVolSync tsync;
 691     struct afsFid fid, existingFid;
 692     char *name;
 693     int vnode, unique;
 694     int code;
 695
 696     sscanf(&(*argp)[0], "%d", &vnode);
 697     ++argp;
 698     sscanf(&(*argp)[0], "%d", &unique);
 699     ++argp;
 700     memset(&fid, 0, sizeof(struct afsFid));
 701     fid.Volume.low = 10;        /* XXX */
 702     fid.Vnode = vnode;
 703     fid.Unique = unique;
 704     name = &argp[0][0];
 705     ++argp;
 706     sscanf(&(*argp)[0], "%d", &vnode);
 707     ++argp;
 708     sscanf(&(*argp)[0], "%d", &unique);
 709     ++argp;
 710     memset(&existingFid, 0, sizeof(struct afsFid));
 711     existingFid.Volume.low = 10;        /* XXX */
 712     existingFid.Vnode = vnode;
 713     existingFid.Unique = unique;
 714     code =
 715         ubik_AFS_HardLink(cstruct, 0, &fid, name, &existingFid, &hyp0,
 716                   0, &OutFidStatus, &OutDirStatus, &tsync);
 717     return (code);
 718 }
 719
 720
 721 afs_int32
 722 MakeDir(char **argp)
 723 {
 724     struct afsFetchStatus OutDirStatus, OutFidStatus;
 725     struct afsStoreStatus InStatus;
 726     struct afsVolSync tsync;
 727     struct afsFid fid, outFid;
 728     struct afsToken Token;
 729     char *name;
 730     int vnode, unique, mode, owner, length;
 731     int code;
 732
 733     sscanf(&(*argp)[0], "%d", &vnode);
 734     ++argp;
 735     sscanf(&(*argp)[0], "%d", &unique);
 736     ++argp;
 737     memset(&fid, 0, sizeof(struct afsFid));
 738     fid.Volume.low = 10;        /* XXX */
 739     fid.Vnode = vnode;
 740     fid.Unique = unique;
 741     name = &argp[0][0];
 742     ++argp;
 743     memset(&InStatus, 0, sizeof(struct afsStoreStatus));
 744     sscanf(&(*argp)[0], "%d", &mode);
 745     ++argp;
 746     sscanf(&(*argp)[0], "%d", &owner);
 747     ++argp;
 748     sscanf(&(*argp)[0], "%d", &length);
 749     ++argp;
 750     if (mode != -1) {
 751         InStatus.mode = mode;
 752         InStatus.mask |= AFS_SETMODE;
 753     }
 754     if (owner != -1) {
 755         InStatus.owner = owner;
 756         InStatus.mask |= AFS_SETOWNER;
 757     }
 758     if (length != -1) {
 759         InStatus.length = length;
 760         InStatus.mask |= AFS_SETLENGTH;
 761     }
 762     code =
 763         ubik_AFS_MakeDir(cstruct, 0, &fid, name, &InStatus, &hyp0, 0,
 764                   &outFid, &OutFidStatus, &OutDirStatus, &Token, &tsync);
 765     return (code);
 766 }
 767
 768
 769 afs_int32
 770 RemoveDir(char **argp)
 771 {
 772     struct afsFetchStatus OutDirStatus;
 773     struct afsVolSync tsync;
 774     struct afsFid fid, outFid;
 775     struct afsFidName nameFid;
 776     char *name;
 777     int vnode, unique;
 778     int code;
 779
 780     sscanf(&(*argp)[0], "%d", &vnode);
 781     ++argp;
 782     sscanf(&(*argp)[0], "%d", &unique);
 783     ++argp;
 784     memset(&fid, 0, sizeof(struct afsFid));
 785     fid.Volume.low = 10;        /* XXX */
 786     fid.Vnode = vnode;
 787     fid.Unique = unique;
 788     name = &argp[0][0];
 789     ++argp;
 790     memset(&nameFid, 0, sizeof(struct afsFidName));
 791     strcpy(nameFid.name, name);
 792     code =
 793         ubik_AFS_RemoveDir(cstruct, 0, &fid, &nameFid, &hyp0, 0,
 794                   &OutDirStatus, &outFid, &tsync);
 795     return (code);
 796 }
 797
 798
 799 afs_int32
 800 Readdir(char **argp)
 801 {
 802     struct afsFetchStatus OutDirStatus;
 803     struct afsVolSync tsync;
 804     struct afsFid fid;
 805     struct afsToken Token;
 806     char *name;
 807     struct rx_call *tcall;
 808     int vnode, unique, offset, length, NextOffset;
 809     int code;
 810
 811     sscanf(&(*argp)[0], "%d", &vnode);
 812     ++argp;
 813     sscanf(&(*argp)[0], "%d", &unique);
 814     ++argp;
 815     sscanf(&(*argp)[0], "%d", &offset);
 816     ++argp;
 817     sscanf(&(*argp)[0], "%d", &length);
 818     ++argp;
 819     memset(&fid, 0, sizeof(struct afsFid));
 820     fid.Volume.low = 10;        /* XXX */
 821     fid.Vnode = vnode;
 822     fid.Unique = unique;
 823     tcall = rx_NewCall(cstruct->conns[0]);
 824     code = StartAFS_Readdir(tcall, &fid, offset, length, &hyp0, 0);
 825     if (!code) {
 826         code = FetchDir(tcall);
 827     }
 828     if (!code) {
 829         code =
 830             EndAFS_FetchData(tcall, &NextOffset, &OutDirStatus, &Token,
 831                              &tsync);
 832     }
 833     code = rx_EndCall(tcall, code);
 834     return (code);
 835 }
 836
 837
 838 static afs_int32
 839 FetchDir(struct rx_call *acall)
 840 {
 841     extern char *malloc();
 842     char *tbuffer;
 843     afs_int32 tlen, length, code;
 844     struct dirent *dp;
 845
 846
 847     tbuffer = malloc(256);
 848     while (1) {
 849         code = rx_Read(acall, &length, sizeof(afs_int32));
 850         length = ntohl(length);
 851         if (code != sizeof(afs_int32))
 852             return -1;
 853         if (length == 0)
 854             break;
 855         tlen = (length > 8192 ? 8192 : length);
 856         code = rx_Read(acall, tbuffer, tlen);
 857         if (code != tlen) {
 858             free(tbuffer);
 859             return -1;
 860         }
 861         length -= tlen;
 862     }
 863     dp = (struct dirent *)dp;
 864     free(tbuffer);
 865     return 0;
 866 }
 867
 868
 869 afs_int32
 870 Lookup(char **argp)
 871 {
 872     struct afsFetchStatus OutDirStatus, OutFidStatus;
 873     struct afsVolSync tsync;
 874     struct afsFid fid, outFid;
 875     char *name;
 876     int vnode, unique;
 877     int code;
 878
 879     sscanf(&(*argp)[0], "%d", &vnode);
 880     ++argp;
 881     sscanf(&(*argp)[0], "%d", &unique);
 882     ++argp;
 883     memset(&fid, 0, sizeof(struct afsFid));
 884     fid.Volume.low = 10;        /* XXX */
 885     fid.Vnode = vnode;
 886     fid.Unique = unique;
 887     name = &argp[0][0];
 888     ++argp;
 889     code =
 890         ubik_AFS_Lookup(cstruct, 0, &fid, name, &hyp0, 0, &outFid,
 891                   &OutFidStatus, &OutDirStatus, &tsync);
 892     return (code);
 893 }
 894
 895
 896 afs_int32
 897 GetToken(char **argp)
 898 {
 899     struct afsFetchStatus OutStatus;
 900     struct afsVolSync tsync;
 901     struct afsToken MinToken, RealToken;
 902     struct afsFid fid;
 903     int vnode, unique, tokenId;
 904     int code;
 905
 906     sscanf(&(*argp)[0], "%d", &vnode);
 907     ++argp;
 908     sscanf(&(*argp)[0], "%d", &unique);
 909     ++argp;
 910     memset(&fid, 0, sizeof(struct afsFid));
 911     fid.Volume.low = 10;        /* XXX */
 912     fid.Vnode = vnode;
 913     fid.Unique = unique;
 914     sscanf(&(*argp)[0], "%d", &tokenId);
 915     ++argp;
 916     memset(&MinToken, 0, sizeof(struct afsToken));
 917     MinToken.tokenID.low = tokenId;     /* XXX */
 918     code =
 919         ubik_AFS_GetToken(cstruct, 0, &fid, &MinToken, &hyp0, 0,
 920                   &RealToken, &OutStatus, &tsync);
 921     return (code);
 922 }
 923
 924
 925 afs_int32
 926 MakeMountPoint(char **argp)
 927 {
 928 }
 929
 930
 931 afs_int32
 932 ReleaseTokens(char **argp)
 933 {
 934 }
 935
 936
 937 afs_int32
 938 BulkStatus(char **argp)
 939 {
 940 }
 941
 942 /*  printf("ka <vol.l> <vnode> <unique> <isExec> <kaTime>\n"); */
 943 afs_int32
 944 KeepAlive(char **argp)
 945 {
 946     struct afsBulkFEX fex;
 947     afs_uint32 numExec, spare4;
 948     struct afsFidExp fx;
 949     int code;
 950
 951     memset(&fx, 0, sizeof(struct afsFidExp));
 952     sscanf(&(*argp)[0], "%d", &fx.fid.Volume.low);
 953     ++argp;
 954     sscanf(&(*argp)[0], "%d", &fx.fid.Vnode);
 955     ++argp;
 956     sscanf(&(*argp)[0], "%d", &fx.fid.Unique);
 957     ++argp;
 958     sscanf(&(*argp)[0], "%d", &numExec);
 959     ++argp;
 960     sscanf(&(*argp)[0], "%d", &fx.keepAliveTime);
 961     memset(&fex, 0, sizeof(struct afsBulkFEX));
 962     fex.afsBulkFEX_val = &fx;
 963     fex.afsBulkFEX_len = 1;
 964     code =
 965         ubik_AFS_BulkKeepAlive(cstruct, 0, &fex, numExec, 0, 0, 0,
 966                   &spare4);
 967     return (code);
 968 }
 969 #endif /* notdef */