src/venus/afsio.c

   1 /*
   2  * Copyright (c) 2007, Hartmut Reuter,
   3  * RZG, Max-Planck-Institut f. Plasmaphysik.
   4  * All Rights Reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions are met:
   8  *
   9  *   1. Redistributions of source code must retain the above copyright
  10  *      notice, this list of conditions and the following disclaimer.
  11  *   2. Redistributions in binary form must reproduce the above copyright
  12  *      notice, this list of conditions and the following disclaimer in
  13  *      the documentation and/or other materials provided with the
  14  *      distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
  17  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  18  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  22  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  23  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  24  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  25  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27 /*
  28  * Revised in 2010 by Chaz Chandler to enhance clientless operations.
  29  * Now utilizes libafscp by Chaskiel Grundman.
  30  * Work funded in part by Sine Nomine Associates (http://www.sinenomine.net/)
  31  */
  32
  33 #include <afsconfig.h>
  34 #include <afs/param.h>
  35 #include <afs/stds.h>
  36
  37 #include <roken.h>
  38
  39 #include <stdio.h>
  40 #ifdef AFS_NT40_ENV
  41 #include <windows.h>
  42 #define _CRT_RAND_S
  43 #include <process.h>
  44 #include <afs/smb_iocons.h>
  45 #include <afs/afsd.h>
  46 #include <afs/cm_ioctl.h>
  47 #include <afs/pioctl_nt.h>
  48 #include <WINNT/syscfg.h>
  49 #else
  50 #include <netdb.h>
  51 #include <afs/afsint.h>
  52 #define FSINT_COMMON_XG 1
  53 #endif
  54 #include <sys/stat.h>
  55 #include <afs/cmd.h>
  56 #include <afs/auth.h>
  57 #include <afs/vlserver.h>
  58 #include <afs/ihandle.h>
  59 #include <afs/com_err.h>
  60 #include <afs/afscp.h>
  61 #ifdef HAVE_DIRENT_H
  62 #include <dirent.h>
  63 #endif
  64 #ifdef HAVE_DIRECT_H
  65 #include <direct.h>
  66 #endif
  67 #ifdef AFS_DARWIN_ENV
  68 #include <sys/malloc.h>
  69 #else
  70 #include <malloc.h>
  71 #endif
  72 #include <hcrypto/md5.h>
  73 #ifdef AFS_PTHREAD_ENV
  74 #include <assert.h>
  75 pthread_key_t uclient_key;
  76 #endif
  77
  78 static int lockFile(struct cmd_syndesc *, void *);
  79 static int readFile(struct cmd_syndesc *, void *);
  80 static int writeFile(struct cmd_syndesc *, void *);
  81 static void printDatarate(void);
  82 static void summarizeDatarate(struct timeval *, const char *);
  83 static int CmdProlog(struct cmd_syndesc *, char **, char **,
  84                      char **, char **);
  85 static int ScanFid(char *, struct AFSFid *);
  86 static afs_int32 GetVenusFidByFid(char *, char *, int, struct afscp_venusfid **);
  87 static afs_int32 GetVenusFidByPath(char *, char *, struct afscp_venusfid **);
  88 static int BreakUpPath(char *, char *, char *);
  89
  90 static char pnp[AFSPATHMAX];    /* filename of this program when called */
  91 static int verbose = 0;         /* Set if -verbose option given */
  92 static int cellGiven = 0;       /* Set if -cell option given */
  93 static int force = 0;           /* Set if -force option given */
  94 static int readlock = 0;        /* Set if -readlock option given */
  95 static int waittime = 0;        /* Set if -waittime option given */
  96 static int useFid = 0;          /* Set if fidwrite/fidread/fidappend invoked */
  97 static int append = 0;          /* Set if append/fidappend invoked */
  98 static struct timeval starttime, opentime, readtime, writetime;
  99 static afs_uint64 xfered = 0;
 100 static struct timeval now;
 101 #ifdef AFS_NT40_ENV
 102 static int Timezone;            /* Roken gettimeofday ignores the timezone */
 103 #else
 104 static struct timezone Timezone;
 105 #endif
 106
 107 #define BUFFLEN 65536
 108 #define WRITEBUFLEN (BUFFLEN * 1024)
 109 #define MEGABYTE_F 1048576.0f
 110
 111 static MD5_CTX md5;
 112 static int md5sum = 0;          /* Set if -md5 option given */
 113
 114 struct wbuf {
 115     struct wbuf *next;
 116     afs_uint32 offset;          /* offset inside the buffer */
 117     afs_uint32 buflen;          /* total length == BUFFLEN */
 118     afs_uint32 used;            /* bytes used inside buffer */
 119     char buf[BUFFLEN];
 120 };
 121
 122 /*!
 123  *  returns difference in seconds between two times
 124  *
 125  *  \param[in]  from    start time
 126  *  \param[in]  to      end time
 127  *
 128  *  \post returns "to" minus "from" in seconds
 129  *
 130  */
 131 static_inline float
 132 time_elapsed(struct timeval *from, struct timeval *to)
 133 {
 134     return (float)(to->tv_sec + (to->tv_usec * 0.000001) - from->tv_sec -
 135                    (from->tv_usec * 0.000001));
 136 } /* time_elapsed */
 137
 138 /*!
 139  * prints current average data transfer rate at no less than 30-second intervals
 140  */
 141 static void
 142 printDatarate(void)
 143 {
 144     static float oldseconds = 0.0;
 145     static afs_uint64 oldxfered = 0;
 146     float seconds;
 147
 148     gettimeofday(&now, &Timezone);
 149     seconds = time_elapsed(&opentime, &now);
 150     if ((seconds - oldseconds) > 30) {
 151         fprintf(stderr, "%llu MB transferred, present data rate = %.3f MB/sec.\n", xfered >> 20,        /* total bytes transferred, in MB */
 152                 (xfered - oldxfered) / (seconds - oldseconds) / MEGABYTE_F);
 153         oldxfered = xfered;
 154         oldseconds = seconds;
 155     }
 156 } /* printDatarate */
 157
 158 /*!
 159  * prints overall average data transfer rate and elapsed time
 160  *
 161  * \param[in]   tvp             current time (to compare with file open time)
 162  * \param[in]   xfer_type       string identify transfer type ("read" or "write")
 163  */
 164 static void
 165 summarizeDatarate(struct timeval *tvp, const char *xfer_type)
 166 {
 167     float seconds = time_elapsed(&opentime, tvp);
 168
 169     fprintf(stderr, "Transfer of %llu bytes took %.3f sec.\n",
 170             xfered, seconds);
 171     fprintf(stderr, "Total data rate = %.03f MB/sec. for %s\n",
 172             xfered / seconds / MEGABYTE_F, xfer_type);
 173 } /* summarizeDatarate */
 174
 175 /*!
 176  * prints final MD5 sum of all file data transferred
 177  *
 178  * \param[in]   fname   file name or FID
 179  */
 180 static void
 181 summarizeMD5(char *fname)
 182 {
 183     afs_uint32 md5int[4];
 184     char *p;
 185
 186     MD5_Final((char *) &md5int[0], &md5);
 187     p = fname + strlen(fname);
 188     while (p > fname) {
 189         if (*(--p) == '/') {
 190             ++p;
 191             break;
 192         }
 193     }
 194     fprintf(stderr, "%08x%08x%08x%08x  %s\n", htonl(md5int[0]),
 195             htonl(md5int[1]), htonl(md5int[2]), htonl(md5int[3]), p);
 196 } /* summarizeMD5 */
 197
 198 /*!
 199  * parses all command-line arguments
 200  *
 201  * \param[in]  as       arguments list
 202  * \param[out] cellp    cell name
 203  * \param[out] realmp   realm name
 204  * \param[out] fnp      filename (either fid or path)
 205  * \param[out] slp      "synthesized" (made up) data given
 206  *
 207  * \post returns 0 on success or -1 on error
 208  *
 209  */
 210 static int
 211 CmdProlog(struct cmd_syndesc *as, char **cellp, char **realmp,
 212           char **fnp, char **slp)
 213 {
 214     int i;
 215     struct cmd_parmdesc *pdp;
 216
 217     if (as == NULL) {
 218         afs_com_err(pnp, EINVAL, "(syndesc is null)");
 219         return -1;
 220     }
 221
 222     /* determine which command was requested */
 223     if (strncmp(as->name, "fid", 3) == 0) /* fidread/fidwrite/fidappend */
 224         useFid = 1;
 225     if ( (strcmp(as->name, "append") == 0) ||
 226          (strcmp(as->name, "fidappend") == 0) )
 227         append = 1;             /* global */
 228
 229     /* attempts to ensure loop is bounded: */
 230     for (pdp = as->parms, i = 0; pdp && (i < as->nParms); i++, pdp++) {
 231         if (pdp->items != NULL) {
 232             if (strcmp(pdp->name, "-verbose") == 0)
 233                 verbose = 1;
 234             else if (strcmp(pdp->name, "-md5") == 0)
 235                 md5sum = 1;     /* global */
 236             else if (strcmp(pdp->name, "-cell") == 0) {
 237                 cellGiven = 1;  /* global */
 238                 *cellp = pdp->items->data;
 239             } else if ( (strcmp(pdp->name, "-file") == 0) ||
 240                         (strcmp(pdp->name, "-fid") == 0) ||
 241                         (strcmp(pdp->name, "-vnode") == 0) )
 242                 *fnp = pdp->items->data;
 243             else if (strcmp(pdp->name, "-force") == 0)
 244                 force = 1;      /* global */
 245             else if (strcmp(pdp->name, "-synthesize") == 0)
 246                 *slp = pdp->items->data;
 247             else if (strcmp(pdp->name, "-realm") == 0)
 248                 *realmp = pdp->items->data;
 249             else if (strcmp(pdp->name, "-wait") == 0)
 250                 waittime = atoi(pdp->items->data);
 251             else if (strcmp(pdp->name, "-readlock") == 0)
 252                 readlock = 1;
 253         }
 254     }
 255     return 0;
 256 }                               /* CmdProlog */
 257
 258 int
 259 main(int argc, char **argv)
 260 {
 261     afs_int32 code = 0;
 262     struct cmd_syndesc *ts;
 263     char baseName[AFSNAMEMAX];
 264
 265     /* try to get only the base name of this executable for use in logs */
 266     if (BreakUpPath(argv[0], NULL, baseName) > 0)
 267         strlcpy(pnp, baseName, AFSNAMEMAX);
 268     else
 269         strlcpy(pnp, argv[0], AFSPATHMAX);
 270
 271 #ifdef AFS_PTHREAD_ENV
 272     assert(pthread_key_create(&uclient_key, NULL) == 0);
 273 #endif
 274
 275     ts = cmd_CreateSyntax("lock", lockFile, (void *)LockWrite,
 276                           "lock a file in AFS");
 277     cmd_AddParm(ts, "-file", CMD_SINGLE, CMD_REQUIRED, "AFS-filename");
 278     cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "cellname");
 279     cmd_AddParm(ts, "-verbose", CMD_FLAG, CMD_OPTIONAL, (char *)0);
 280     cmd_Seek(ts, 4);
 281     cmd_AddParm(ts, "-realm", CMD_SINGLE, CMD_OPTIONAL, "REALMNAME");
 282     cmd_AddParm(ts, "-waitseconds", CMD_SINGLE, CMD_OPTIONAL, "seconds to wait before giving up");
 283     cmd_AddParm(ts, "-readlock", CMD_FLAG, CMD_OPTIONAL, "read lock only");
 284
 285     ts = cmd_CreateSyntax("fidlock", lockFile, (void *)LockWrite,
 286                           "lock by FID a file from AFS");
 287     cmd_IsAdministratorCommand(ts);
 288     cmd_AddParm(ts, "-fid", CMD_SINGLE, CMD_REQUIRED,
 289                 "volume.vnode.uniquifier");
 290     cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "cellname");
 291     cmd_AddParm(ts, "-verbose", CMD_FLAG, CMD_OPTIONAL, (char *)0);
 292     cmd_Seek(ts, 4);
 293     cmd_AddParm(ts, "-realm", CMD_SINGLE, CMD_OPTIONAL, "REALMNAME");
 294     cmd_AddParm(ts, "-waitseconds", CMD_SINGLE, CMD_OPTIONAL, "seconds to wait before giving up");
 295     cmd_AddParm(ts, "-readlock", CMD_FLAG, CMD_OPTIONAL, "read lock only");
 296
 297     ts = cmd_CreateSyntax("unlock", lockFile, (void *)LockRelease,
 298                           "unlock a file in AFS");
 299     cmd_AddParm(ts, "-file", CMD_SINGLE, CMD_REQUIRED, "AFS-filename");
 300     cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "cellname");
 301     cmd_AddParm(ts, "-verbose", CMD_FLAG, CMD_OPTIONAL, (char *)0);
 302     cmd_Seek(ts, 4);
 303     cmd_AddParm(ts, "-realm", CMD_SINGLE, CMD_OPTIONAL, "REALMNAME");
 304     cmd_AddParm(ts, "-waitseconds", CMD_SINGLE, CMD_OPTIONAL, "seconds to wait before giving up");
 305
 306     ts = cmd_CreateSyntax("fidunlock", lockFile, (void *)LockRelease,
 307                           "unlock by FID a file from AFS");
 308     cmd_IsAdministratorCommand(ts);
 309     cmd_AddParm(ts, "-fid", CMD_SINGLE, CMD_REQUIRED,
 310                 "volume.vnode.uniquifier");
 311     cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "cellname");
 312     cmd_AddParm(ts, "-verbose", CMD_FLAG, CMD_OPTIONAL, (char *)0);
 313     cmd_Seek(ts, 4);
 314     cmd_AddParm(ts, "-realm", CMD_SINGLE, CMD_OPTIONAL, "REALMNAME");
 315     cmd_AddParm(ts, "-waitseconds", CMD_SINGLE, CMD_OPTIONAL, "seconds to wait before giving up");
 316
 317     ts = cmd_CreateSyntax("read", readFile, NULL,
 318                           "read a file from AFS");
 319     cmd_AddParm(ts, "-file", CMD_SINGLE, CMD_REQUIRED, "AFS-filename");
 320     cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "cellname");
 321     cmd_AddParm(ts, "-verbose", CMD_FLAG, CMD_OPTIONAL, (char *)0);
 322     cmd_AddParm(ts, "-md5", CMD_FLAG, CMD_OPTIONAL, "calculate md5 checksum");
 323     cmd_AddParm(ts, "-realm", CMD_SINGLE, CMD_OPTIONAL, "REALMNAME");
 324
 325     ts = cmd_CreateSyntax("fidread", readFile, CMD_REQUIRED,
 326                           "read on a non AFS-client a file from AFS");
 327     cmd_IsAdministratorCommand(ts);
 328     cmd_AddParm(ts, "-fid", CMD_SINGLE, CMD_REQUIRED,
 329                 "volume.vnode.uniquifier");
 330     cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "cellname");
 331     cmd_AddParm(ts, "-verbose", CMD_FLAG, CMD_OPTIONAL, (char *)0);
 332     cmd_AddParm(ts, "-md5", CMD_FLAG, CMD_OPTIONAL, "calculate md5 checksum");
 333     cmd_AddParm(ts, "-realm", CMD_SINGLE, CMD_OPTIONAL, "REALMNAME");
 334
 335     ts = cmd_CreateSyntax("write", writeFile, NULL,
 336                           "write a file into AFS");
 337     cmd_AddParm(ts, "-file", CMD_SINGLE, CMD_REQUIRED, "AFS-filename");
 338     cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "cellname");
 339     cmd_AddParm(ts, "-verbose", CMD_FLAG, CMD_OPTIONAL, (char *)0);
 340     cmd_AddParm(ts, "-md5", CMD_FLAG, CMD_OPTIONAL, "calculate md5 checksum");
 341     cmd_AddParm(ts, "-force", CMD_FLAG, CMD_OPTIONAL,
 342                 "overwrite existing file");
 343     cmd_AddParm(ts, "-synthesize", CMD_SINGLE, CMD_OPTIONAL,
 344                 "create data pattern of specified length instead reading from stdin");
 345     cmd_AddParm(ts, "-realm", CMD_SINGLE, CMD_OPTIONAL, "REALMNAME");
 346
 347     ts = cmd_CreateSyntax("fidwrite", writeFile, CMD_REQUIRED,
 348                           "write a file into AFS");
 349     cmd_IsAdministratorCommand(ts);
 350     cmd_AddParm(ts, "-vnode", CMD_SINGLE, CMD_REQUIRED,
 351                 "volume.vnode.uniquifier");
 352     cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "cellname");
 353     cmd_AddParm(ts, "-verbose", CMD_FLAG, CMD_OPTIONAL, (char *)0);
 354     cmd_AddParm(ts, "-md5", CMD_FLAG, CMD_OPTIONAL, "calculate md5 checksum");
 355     cmd_AddParm(ts, "-force", CMD_FLAG, CMD_OPTIONAL,
 356                 "overwrite existing file");
 357     cmd_AddParm(ts, "-realm", CMD_SINGLE, CMD_OPTIONAL, "REALMNAME");
 358
 359     ts = cmd_CreateSyntax("append", writeFile, NULL,
 360                           "append to a file in AFS");
 361     cmd_AddParm(ts, "-file", CMD_SINGLE, CMD_REQUIRED, "AFS-filename");
 362     cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "cellname");
 363     cmd_AddParm(ts, "-verbose", CMD_FLAG, CMD_OPTIONAL, (char *)0);
 364     cmd_AddParm(ts, "-realm", CMD_SINGLE, CMD_OPTIONAL, "REALMNAME");
 365
 366     ts = cmd_CreateSyntax("fidappend", writeFile, NULL,
 367                           "append to a file in AFS");
 368     cmd_IsAdministratorCommand(ts);
 369     cmd_AddParm(ts, "-vnode", CMD_SINGLE, CMD_REQUIRED,
 370                 "volume.vnode.uniquifier");
 371     cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "cellname");
 372     cmd_AddParm(ts, "-verbose", CMD_FLAG, CMD_OPTIONAL, (char *)0);
 373     cmd_AddParm(ts, "-realm", CMD_SINGLE, CMD_OPTIONAL, "REALMNAME");
 374
 375     if (afscp_Init(NULL) != 0)
 376         exit(1);
 377
 378     code = cmd_Dispatch(argc, argv);
 379
 380     afscp_Finalize();
 381     exit(0);
 382 } /* main */
 383
 384 /*!
 385  * standardized way of parsing a File ID (FID) from command line input
 386  *
 387  * \param[in]   fidString       dot-delimited FID triple
 388  * \param[out]  fid             pointer to the AFSFid to fill in
 389  *
 390  * \post The FID pointed to by "fid" is filled in which the parsed Volume,
 391  *       Vnode, and Uniquifier data.  The string should be in the format
 392  *       of three numbers separated by dot (.) delimiters, representing
 393  *       (in order) the volume id, vnode number, and uniquifier.
 394  *       Example: "576821346.1.1"
 395  */
 396 static int
 397 ScanFid(char *fidString, struct AFSFid *fid)
 398 {
 399     int i = 0, code = 0;
 400     long unsigned int f1, f2, f3;
 401
 402     if (fidString) {
 403         i = sscanf(fidString, "%lu.%lu.%lu", &f1, &f2, &f3);
 404         fid->Volume = (afs_uint32) f1;
 405         fid->Vnode = (afs_uint32) f2;
 406         fid->Unique = (afs_uint32) f3;
 407     }
 408     if (i != 3) {
 409         fid->Volume = 0;
 410         fid->Vnode = 0;
 411         fid->Unique = 0;
 412         code = EINVAL;
 413         afs_com_err(pnp, code, "(invalid FID triple: %s)", fidString);
 414     }
 415
 416     return code;
 417 } /* ScanFid */
 418
 419 /*!
 420  * look up cell info and verify FID info from user input
 421  *
 422  * \param[in]   fidString       string containing FID info
 423  * \param[in]   cellName        cell name string
 424  * \param[in]   onlyRW          bool: 1 = RW vol only, 0 = any vol type
 425  * \param[out]  avfpp           pointer to venusfid info
 426  *
 427  * \post *avfpp will contain the VenusFid info found for the FID
 428  *       given by the used in the string fidString and zero is
 429  *       returned.  If not found, an appropriate afs error code
 430  *       is returned and *avfpp will be NULL.
 431  *
 432  * \note Any non-NULL avfpp returned should later be freed with
 433  *       afscp_FreeFid() when no longer needed.
 434  */
 435 static afs_int32
 436 GetVenusFidByFid(char *fidString, char *cellName, int onlyRW,
 437                  struct afscp_venusfid **avfpp)
 438 {
 439     afs_int32 code = 0;
 440     struct stat sbuf;
 441     struct afscp_volume *avolp;
 442
 443     if (*avfpp == NULL) {
 444         *avfpp = malloc(sizeof(struct afscp_venusfid));
 445         if ( *avfpp == NULL ) {
 446             code = ENOMEM;
 447             return code;
 448         }
 449     }
 450     memset(*avfpp, 0, sizeof(struct afscp_venusfid));
 451
 452     if (cellName == NULL) {
 453         (*avfpp)->cell = afscp_DefaultCell();
 454     } else {
 455         (*avfpp)->cell = afscp_CellByName(cellName, NULL);
 456     }
 457     if ((*avfpp)->cell == NULL) {
 458         if (afscp_errno == 0)
 459             code = EINVAL;
 460         else
 461             code = afscp_errno;
 462         return code;
 463     }
 464
 465     code = ScanFid(fidString, &((*avfpp)->fid));
 466     if (code != 0) {
 467         code = EINVAL;
 468         return code;
 469     }
 470
 471     avolp = afscp_VolumeById((*avfpp)->cell, (*avfpp)->fid.Volume);
 472     if (avolp == NULL) {
 473         if (afscp_errno == 0)
 474             code = ENOENT;
 475         else
 476             code = afscp_errno;
 477         afs_com_err(pnp, code, "(finding volume %lu)",
 478                     afs_printable_uint32_lu((*avfpp)->fid.Volume));
 479         return code;
 480     }
 481
 482     if ( onlyRW && (avolp->voltype != RWVOL) ) {
 483         avolp = afscp_VolumeByName((*avfpp)->cell, avolp->name, RWVOL);
 484         if (avolp == NULL) {
 485             if (afscp_errno == 0)
 486                 code = ENOENT;
 487             else
 488                 code = afscp_errno;
 489             afs_com_err(pnp, code, "(finding volume %lu)",
 490                         afs_printable_uint32_lu((*avfpp)->fid.Volume));
 491             return code;
 492         }
 493         (*avfpp)->fid.Volume = avolp->id; /* is this safe? */
 494     }
 495
 496     code = afscp_Stat((*avfpp), &sbuf);
 497     if (code != 0) {
 498         afs_com_err(pnp, code, "(stat failed with code %d)", code);
 499         return code;
 500     }
 501     return 0;
 502 } /* GetVenusFidByFid */
 503
 504 /*!
 505  * Split a full path up into dirName and baseName components
 506  *
 507  * \param[in]   fullPath        can be absolute, relative, or local
 508  * \param[out]  dirName         pointer to allocated char buffer or NULL
 509  * \param[out]  baseName        pointer to allocated char buffer or NULL
 510  *
 511  * \post To the fulleset extent possible, the rightmost full path
 512  *       component will be copied into baseName and all other
 513  *       components into dirName (minus the trailing path separator).
 514  *       If either dirName or baseName are NULL, only the non-NULL
 515  *       pointer will be filled in (but both can't be null or it would
 516  *       be pointless) -- so the caller can retrieve, say, only baseName
 517  *       if desired.  The return code is the number of strings copied:
 518  *       0 if neither dirName nor baseName could be filled in
 519  *       1 if either dirName or baseName were filled in
 520  *       2 if both dirName and baseName were filled in
 521  */
 522 static int
 523 BreakUpPath(char *fullPath, char *dirName, char *baseName)
 524 {
 525     char *lastSlash;
 526     size_t dirNameLen = 0;
 527     int code = 0, useDirName = 1, useBaseName = 1;
 528
 529     if (fullPath == NULL) {
 530         return code;
 531     }
 532
 533     if (dirName == NULL)
 534         useDirName = 0;
 535     if (baseName == NULL)
 536         useBaseName = 0;
 537     if (!useBaseName && !useDirName) {
 538         /* would be pointless to continue -- must be error in call */
 539         return code;
 540     }
 541 #ifdef AFS_NT40_ENV
 542     lastSlash = strrchr(fullPath, '\\');
 543 #else
 544     lastSlash = strrchr(fullPath, '/');
 545 #endif
 546     if (lastSlash != NULL) {
 547         /* then lastSlash points to the last path separator in fullPath */
 548         if (useDirName) {
 549             dirNameLen = strlen(fullPath) - strlen(lastSlash);
 550             strlcpy(dirName, fullPath, dirNameLen + 1);
 551             code++;
 552         }
 553         if (useBaseName) {
 554             lastSlash++;
 555             strlcpy(baseName, lastSlash, strlen(lastSlash) + 1);
 556             code++;
 557         }
 558     } else {
 559         /* there are no path separators in fullPath -- it's just a baseName */
 560         if (useBaseName) {
 561             strlcpy(baseName, fullPath, strlen(fullPath) + 1);
 562             code++;
 563         }
 564     }
 565     return code;
 566 } /* BreakUpPath */
 567
 568 /*!
 569  * Get the VenusFid info available for the file at AFS path 'fullPath'.
 570  * Works without pioctls/afsd by using libafscp.  Analogous to
 571  * get_file_cell() in the previous iteration of afsio.
 572  *
 573  * \param[in]   fullPath        the file name
 574  * \param[in]   cellName        the cell name to look up
 575  * \param[out]  avfpp           pointer to Venus FID info to be filled in
 576  *
 577  * \post If the path resolves successfully (using afscp_ResolvePath),
 578  *       then vfpp will contain the Venus FID info (cell info plus
 579  *       AFSFid) of the last path segment in fullPath.
 580  */
 581 static afs_int32
 582 GetVenusFidByPath(char *fullPath, char *cellName,
 583                   struct afscp_venusfid **avfpp)
 584 {
 585     afs_int32 code = 0;
 586
 587     if (fullPath == NULL) {
 588         return -1;
 589     }
 590
 591     if (cellName != NULL) {
 592         code = (afs_int32) afscp_SetDefaultCell(cellName);
 593         if (code != 0) {
 594             return code;
 595         }
 596     }
 597
 598     *avfpp = afscp_ResolvePath(fullPath);
 599     if (*avfpp == NULL) {
 600         if (afscp_errno == 0)
 601             code = ENOENT;
 602         else
 603             code = afscp_errno;
 604     }
 605
 606     return code;
 607 } /* GetVenusFidByPath */
 608
 609 static int
 610 lockFile(struct cmd_syndesc *as, void *arock)
 611 {
 612     char *fname = NULL;
 613     char *cell = NULL;
 614     char *realm = NULL;
 615     afs_int32 code = 0;
 616     struct AFSFetchStatus OutStatus;
 617     struct afscp_venusfid *avfp = NULL;
 618     char *buf = 0;
 619     char ipv4_addr[16];
 620     int locktype = (int)(intptr_t) arock;
 621
 622 #ifdef AFS_NT40_ENV
 623     /* stdout on Windows defaults to _O_TEXT mode */
 624     _setmode(1, _O_BINARY);
 625 #endif
 626
 627     gettimeofday(&starttime, &Timezone);
 628
 629     CmdProlog(as, &cell, &realm, &fname, NULL);
 630     afscp_AnonymousAuth(1);
 631
 632     if ((locktype == LockWrite) && readlock)
 633         locktype = LockRead;
 634
 635     if (realm != NULL)
 636         code = afscp_SetDefaultRealm(realm);
 637
 638     if (cell != NULL)
 639         code = afscp_SetDefaultCell(cell);
 640
 641     if (useFid)
 642         code = GetVenusFidByFid(fname, cell, 0, &avfp);
 643     else
 644         code = GetVenusFidByPath(fname, cell, &avfp);
 645     if (code != 0) {
 646         afs_com_err(pnp, code, "(file not found: %s)", fname);
 647         return code;
 648     }
 649
 650 retry:
 651     code = afscp_GetStatus(avfp, &OutStatus);
 652     if (code != 0) {
 653         afs_inet_ntoa_r(avfp->cell->fsservers[0]->addrs[0], ipv4_addr);
 654         afs_com_err(pnp, code, "(failed to get status of file %s from"
 655                     "server %s, code = %d)", fname, ipv4_addr, code);
 656         afscp_FreeFid(avfp);
 657         return code;
 658     }
 659
 660     if (locktype != LockRelease) {
 661         while (OutStatus.lockCount != 0) {
 662             code = afscp_WaitForCallback(avfp, waittime);
 663             if ((code == -1) && (afscp_errno == ETIMEDOUT))
 664                 break;
 665             if ((code = afscp_GetStatus(avfp, &OutStatus)) != 0)
 666                 break;
 667         }
 668     } else {
 669         if (OutStatus.lockCount == 0) {
 670             code = -1;
 671         }
 672     }
 673
 674     if (!code) {
 675         code = afscp_Lock(avfp, locktype);
 676         if ((code == -1) && (afscp_errno == EWOULDBLOCK))
 677             goto retry;
 678     }
 679     afscp_FreeFid(avfp);
 680
 681     if (buf != NULL)
 682         free(buf);
 683
 684     if (code != 0)
 685         afs_com_err(pnp, code, "(failed to change lock status: %d)", afscp_errno);
 686
 687     return code;
 688 } /* lockFile */
 689
 690 static int
 691 readFile(struct cmd_syndesc *as, void *unused)
 692 {
 693     char *fname = NULL;
 694     char *cell = NULL;
 695     char *realm = NULL;
 696     afs_int32 code = 0;
 697     struct AFSFetchStatus OutStatus;
 698     struct afscp_venusfid *avfp = NULL;
 699     afs_int64 Pos;
 700     afs_int32 len;
 701     afs_int64 length = 0, Len;
 702     int bytes;
 703     int worstCode = 0;
 704     char *buf = 0;
 705     char ipv4_addr[16];
 706     int bufflen = BUFFLEN;
 707
 708 #ifdef AFS_NT40_ENV
 709     /* stdout on Windows defaults to _O_TEXT mode */
 710     _setmode(1, _O_BINARY);
 711 #endif
 712
 713     gettimeofday(&starttime, &Timezone);
 714
 715     CmdProlog(as, &cell, &realm, &fname, NULL);
 716     afscp_AnonymousAuth(1);
 717
 718     if (md5sum)
 719         MD5_Init(&md5);
 720
 721     if (realm != NULL)
 722         code = afscp_SetDefaultRealm(realm);
 723
 724     if (cell != NULL)
 725         code = afscp_SetDefaultCell(cell);
 726
 727     if (useFid)
 728         code = GetVenusFidByFid(fname, cell, 0, &avfp);
 729     else
 730         code = GetVenusFidByPath(fname, cell, &avfp);
 731     if (code != 0) {
 732         afs_com_err(pnp, code, "(file not found: %s)", fname);
 733         return code;
 734     }
 735
 736     if (avfp->fid.Vnode & 1) {
 737         code = ENOENT;
 738         afs_com_err(pnp, code, "(%s is a directory, not a file)", fname);
 739         afscp_FreeFid(avfp);
 740         return code;
 741     }
 742
 743     code = afscp_GetStatus(avfp, &OutStatus);
 744     if (code != 0) {
 745         afs_inet_ntoa_r(avfp->cell->fsservers[0]->addrs[0], ipv4_addr);
 746         afs_com_err(pnp, code, "(failed to get status of file %s from"
 747                     "server %s, code = %d)", fname, ipv4_addr, code);
 748         afscp_FreeFid(avfp);
 749         return code;
 750     }
 751
 752     gettimeofday(&opentime, &Timezone);
 753     if (verbose)
 754         fprintf(stderr, "Startup to find the file took %.3f sec.\n",
 755                 time_elapsed(&starttime, &opentime));
 756     Len = OutStatus.Length_hi;
 757     Len <<= 32;
 758     Len += OutStatus.Length;
 759     ZeroInt64(Pos);
 760     buf = (char *) malloc(bufflen * sizeof(char));
 761     if (buf == NULL) {
 762         code = ENOMEM;
 763         afs_com_err(pnp, code, "(cannot allocate buffer)");
 764         afscp_FreeFid(avfp);
 765         return code;
 766     }
 767     memset(buf, 0, bufflen * sizeof(char));
 768     length = Len;
 769     while (!code && NonZeroInt64(length)) {
 770         if (length > bufflen)
 771             len = bufflen;
 772         else
 773             len = (afs_int32) length;
 774         bytes = afscp_PRead(avfp, buf, len, Pos);
 775         if (bytes != len)
 776             code = -3; /* what error name should we use here? */
 777         if (md5sum)
 778             MD5_Update(&md5, buf, len);
 779         if (code == 0) {
 780             len = write(1, buf, len); /* to stdout */
 781             if (len == 0)
 782                 code = errno;
 783         }
 784         length -= len;
 785         xfered += len;
 786         if (verbose)
 787             printDatarate();
 788         Pos += len;
 789         worstCode = code;
 790     }
 791     afscp_FreeFid(avfp);
 792
 793     gettimeofday(&readtime, &Timezone);
 794     if (md5sum)
 795         summarizeMD5(fname);
 796     if (verbose)
 797         summarizeDatarate(&readtime, "read");
 798     if (buf != NULL)
 799         free(buf);
 800
 801     return worstCode;
 802 } /* readFile */
 803
 804 static int
 805 writeFile(struct cmd_syndesc *as, void *unused)
 806 {
 807     char *fname = NULL;
 808     char *cell = NULL;
 809     char *sSynthLen = NULL;
 810     char *realm = NULL;
 811     afs_int32 code = 0;
 812     afs_int32 byteswritten;
 813     struct AFSFetchStatus OutStatus;
 814     struct AFSStoreStatus InStatus;
 815     struct afscp_venusfid *dirvfp = NULL, *newvfp = NULL;
 816     afs_int64 Pos;
 817     afs_int64 length, Len, synthlength = 0, offset = 0;
 818     afs_int64 bytes;
 819     int worstCode = 0;
 820     int synthesize = 0;
 821     int overWrite = 0;
 822     struct wbuf *bufchain = 0;
 823     struct wbuf *previous, *tbuf;
 824     char dirName[AFSPATHMAX];
 825     char baseName[AFSNAMEMAX];
 826     char ipv4_addr[16];
 827
 828 #ifdef AFS_NT40_ENV
 829     /* stdin on Windows defaults to _O_TEXT mode */
 830     _setmode(0, _O_BINARY);
 831 #endif
 832
 833     CmdProlog(as, &cell, &realm, &fname, &sSynthLen);
 834     afscp_AnonymousAuth(1);
 835
 836     if (realm != NULL)
 837         code = afscp_SetDefaultRealm(realm);
 838
 839     if (cell != NULL)
 840         code = afscp_SetDefaultCell(cell);
 841
 842     if (sSynthLen) {
 843         code = util_GetInt64(sSynthLen, &synthlength);
 844         if (code != 0) {
 845             afs_com_err(pnp, code, "(invalid value for synthesize length %s)",
 846                         sSynthLen);
 847             return code;
 848         }
 849         synthesize = 1;
 850     }
 851
 852     if (useFid) {
 853         code = GetVenusFidByFid(fname, cell, 1, &newvfp);
 854         if (code != 0) {
 855             afs_com_err(pnp, code, "(GetVenusFidByFid returned code %d)", code);
 856             return code;
 857         }
 858     } else {
 859         code = GetVenusFidByPath(fname, cell, &newvfp);
 860         if (code == 0) { /* file was found */
 861             if (force)
 862                 overWrite = 1;
 863             else if (!append) {
 864                 /*
 865                  * file cannot already exist if specified by path and not
 866                  * appending to it unless user forces overwrite
 867                  */
 868                 code = EEXIST;
 869                 afscp_FreeFid(newvfp);
 870                 afs_com_err(pnp, code, "(use -force to overwrite)");
 871                 return code;
 872             }
 873         } else { /* file not found */
 874             if (append) {
 875                 code = ENOENT;
 876                 afs_com_err(pnp, code, "(cannot append to non-existent file)");
 877                 return code;
 878             }
 879         }
 880         if (!append && !overWrite) { /* must create a new file in this case */
 881             if ( BreakUpPath(fname, dirName, baseName) != 2 ) {
 882                 code = EINVAL;
 883                 afs_com_err(pnp, code, "(must provide full AFS path)");
 884                 afscp_FreeFid(newvfp);
 885                 return code;
 886             }
 887
 888             code = GetVenusFidByPath(dirName, cell, &dirvfp);
 889             afscp_FreeFid(newvfp); /* release now-unneeded fid */
 890             newvfp = NULL;
 891             if (code != 0) {
 892                 afs_com_err(pnp, code, "(is dir %s in AFS?)", dirName);
 893                 return code;
 894             }
 895         }
 896     }
 897
 898     if ( (newvfp != NULL) && (newvfp->fid.Vnode & 1) ) {
 899         code = EISDIR;
 900         afs_com_err(pnp, code, "(%s is a directory, not a file)", fname);
 901         afscp_FreeFid(newvfp);
 902         afscp_FreeFid(dirvfp);
 903         return code;
 904     }
 905     gettimeofday(&starttime, &Timezone);
 906
 907     InStatus.UnixModeBits = 0644;
 908     InStatus.Mask = AFS_SETMODE + AFS_FSYNC;
 909     if (newvfp == NULL) {
 910         code = afscp_CreateFile(dirvfp, baseName, &InStatus, &newvfp);
 911         if (code != 0) {
 912             afs_com_err(pnp, code,
 913                         "(could not create file %s in directory %lu.%lu.%lu)",
 914                         baseName, afs_printable_uint32_lu(dirvfp->fid.Volume),
 915                         afs_printable_uint32_lu(dirvfp->fid.Vnode),
 916                         afs_printable_uint32_lu(dirvfp->fid.Unique));
 917             return code;
 918         }
 919     }
 920     code = afscp_GetStatus(newvfp, &OutStatus);
 921     if (code != 0) {
 922         afs_inet_ntoa_r(newvfp->cell->fsservers[0]->addrs[0], ipv4_addr);
 923         afs_com_err(pnp, code, "(failed to get status of file %s from"
 924                     "server %s, code = %d)", fname, ipv4_addr, code);
 925         afscp_FreeFid(newvfp);
 926         afscp_FreeFid(dirvfp);
 927         return code;
 928     }
 929
 930     if ( !append && !force &&
 931          (OutStatus.Length != 0 || OutStatus.Length_hi !=0 ) ) {
 932         /*
 933          * file exists, is of non-zero length, and we're not appending
 934          * to it: user must force overwrite
 935          * (covers fidwrite edge case)
 936          */
 937         code = EEXIST;
 938         afscp_FreeFid(newvfp);
 939         afscp_FreeFid(dirvfp);
 940         afs_com_err(pnp, code, "(use -force to overwrite)");
 941         return code;
 942     }
 943
 944     if (append) {
 945         Pos = OutStatus.Length_hi;
 946         Pos = (Pos << 32) | OutStatus.Length;
 947     } else
 948         Pos = 0;
 949     previous = (struct wbuf *)&bufchain;
 950     if (md5sum)
 951         MD5_Init(&md5);
 952
 953     /*
 954      * currently, these two while loops (1) read the whole source file in
 955      * before (2) writing any of it out, meaning that afsio can't deal with
 956      * files larger than the maximum amount of memory designated for
 957      * reading a file in (WRITEBUFLEN).
 958      * Consider going to a single loop, like in readFile(), though will
 959      * have implications on timing statistics (such as the "Startup to
 960      * find the file" time, below).
 961      */
 962     Len = 0;
 963     while (Len < WRITEBUFLEN) {
 964         tbuf = (struct wbuf *)malloc(sizeof(struct wbuf));
 965         if (tbuf == NULL) {
 966             if (!bufchain) {
 967                 code = ENOMEM;
 968                 afscp_FreeFid(newvfp);
 969                 afscp_FreeFid(dirvfp);
 970                 afs_com_err(pnp, code, "(cannot allocate buffer)");
 971                 return code;
 972             }
 973             break;
 974         }
 975         memset(tbuf, 0, sizeof(struct wbuf));
 976         tbuf->buflen = BUFFLEN;
 977         if (synthesize) {
 978             afs_int64 ll, l = tbuf->buflen;
 979             if (l > synthlength)
 980                 l = synthlength;
 981             for (ll = 0; ll < l; ll += 4096) {
 982                 sprintf(&tbuf->buf[ll], "Offset (0x%x, 0x%x)\n",
 983                         (unsigned int)((offset + ll) >> 32),
 984                         (unsigned int)((offset + ll) & 0xffffffff));
 985             }
 986             offset += l;
 987             synthlength -= l;
 988             tbuf->used = (afs_int32) l;
 989         } else
 990             tbuf->used = read(0, &tbuf->buf, tbuf->buflen); /* from stdin */
 991         if (tbuf->used == 0) {
 992             free(tbuf);
 993             break;
 994         }
 995         if (md5sum)
 996             MD5_Update(&md5, &tbuf->buf, tbuf->used);
 997         previous->next = tbuf;
 998         previous = tbuf;
 999         Len += tbuf->used;
1000     }
1001     gettimeofday(&opentime, &Timezone);
1002     if (verbose)
1003         fprintf(stderr, "Startup to find the file took %.3f sec.\n",
1004                 time_elapsed(&starttime, &opentime));
1005     bytes = Len;
1006     while (!code && bytes) {
1007         Len = bytes;
1008         length = Len;
1009         tbuf = bufchain;
1010         if (Len) {
1011             for (tbuf = bufchain; tbuf; tbuf = tbuf->next) {
1012                 if (tbuf->used == 0)
1013                     break;
1014                 byteswritten = afscp_PWrite(newvfp, tbuf->buf,
1015                                             tbuf->used, Pos + xfered);
1016                 if (byteswritten != tbuf->used) {
1017                     fprintf(stderr,"Only %d instead of %" AFS_INT64_FMT " bytes transferred by rx_Write()\n", byteswritten, length);
1018                     fprintf(stderr, "At %" AFS_UINT64_FMT " bytes from the end\n", length);
1019                     code = -4;
1020                     break;
1021                 }
1022                 xfered += tbuf->used;
1023                 if (verbose)
1024                     printDatarate();
1025                 length -= tbuf->used;
1026             }
1027         }
1028         Pos += Len;
1029         bytes = 0;
1030         if (!code) {
1031             for (tbuf = bufchain; tbuf; tbuf = tbuf->next) {
1032                 tbuf->offset = 0;
1033                 if (synthesize) {
1034                     afs_int64 ll, l = tbuf->buflen;
1035                     if (l > synthlength)
1036                         l = synthlength;
1037                     for (ll = 0; ll < l; ll += 4096) {
1038                         sprintf(&tbuf->buf[ll], "Offset (0x%x, 0x%x)\n",
1039                                 (unsigned int)((offset + ll) >> 32),
1040                                 (unsigned int)((offset + ll) & 0xffffffff));
1041                     }
1042                     offset += l;
1043                     synthlength -= l;
1044                     tbuf->used = (afs_int32) l;
1045                 } else
1046                     tbuf->used = read(0, &tbuf->buf, tbuf->buflen); /* from stdin */
1047                 if (!tbuf->used)
1048                     break;
1049                 if (md5sum)
1050                     MD5_Update(&md5, &tbuf->buf, tbuf->used);
1051                 Len += tbuf->used;
1052                 bytes += tbuf->used;
1053             }
1054         }
1055     }
1056     afscp_FreeFid(newvfp);
1057     afscp_FreeFid(dirvfp);
1058
1059     gettimeofday(&writetime, &Timezone);
1060     if (code) {
1061         afs_com_err(pnp, code, "(%s failed with code %d)", as->name,
1062                     code);
1063     } else if (verbose) {
1064         summarizeDatarate(&writetime, "write");
1065     }
1066     while (bufchain) {
1067         tbuf = bufchain;
1068         bufchain = tbuf->next;
1069         free(tbuf);
1070     }
1071
1072     if (md5sum)
1073         summarizeMD5(fname);
1074
1075     return worstCode;
1076 } /* writeFile */