src/volser/vsutils.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 #include <afsconfig.h>
  11 #include <afs/param.h>
  12
  13 #include <roken.h>
  14
  15 #include <afs/stds.h>
  16 #include <string.h>
  17 #include <ctype.h>
  18 #ifdef AFS_NT40_ENV
  19 #include <fcntl.h>
  20 #include <winsock2.h>
  21 #else
  22 #include <sys/types.h>
  23 #include <sys/file.h>
  24 #include <netdb.h>
  25 #include <netinet/in.h>
  26 #endif /* AFS_NT40_ENV */
  27 #include <sys/stat.h>
  28 #ifdef AFS_AIX_ENV
  29 #include <sys/statfs.h>
  30 #endif
  31
  32 #include <errno.h>
  33 #include <lock.h>
  34 #include <rx/xdr.h>
  35 #include <rx/rx.h>
  36 #include <rx/rx_globals.h>
  37 #include <afs/nfs.h>
  38 #include <afs/vlserver.h>
  39 #include <afs/cellconfig.h>
  40 #include <afs/keys.h>
  41 #include <ubik.h>
  42 #include <afs/afsint.h>
  43 #include <afs/cmd.h>
  44 #include <rx/rxkad.h>
  45 #include "volser.h"
  46 #include "volint.h"
  47 #include "lockdata.h"
  48
  49 #include "vsutils_prototypes.h"
  50
  51 struct ubik_client *cstruct;
  52 static rxkad_level vsu_rxkad_level = rxkad_clear;
  53
  54 static void
  55 ovlentry_to_nvlentry(struct vldbentry *oentryp,
  56                      struct nvldbentry *nentryp)
  57 {
  58     int i;
  59
  60     memset(nentryp, 0, sizeof(struct nvldbentry));
  61     strncpy(nentryp->name, oentryp->name, sizeof(nentryp->name));
  62     for (i = 0; i < oentryp->nServers; i++) {
  63         nentryp->serverNumber[i] = oentryp->serverNumber[i];
  64         nentryp->serverPartition[i] = oentryp->serverPartition[i];
  65         nentryp->serverFlags[i] = oentryp->serverFlags[i];
  66     }
  67     nentryp->nServers = oentryp->nServers;
  68     for (i = 0; i < MAXTYPES; i++)
  69         nentryp->volumeId[i] = oentryp->volumeId[i];
  70     nentryp->cloneId = oentryp->cloneId;
  71     nentryp->flags = oentryp->flags;
  72 }
  73
  74 static int
  75 nvlentry_to_ovlentry(struct nvldbentry *nentryp,
  76                      struct vldbentry *oentryp)
  77 {
  78     int i;
  79
  80     memset(oentryp, 0, sizeof(struct vldbentry));
  81     strncpy(oentryp->name, nentryp->name, sizeof(oentryp->name));
  82     if (nentryp->nServers > OMAXNSERVERS) {
  83         /*
  84          * The alternative is to store OMAXSERVERS but it's always better
  85          * to know what's going on...
  86          */
  87         return VL_BADSERVER;
  88     }
  89     for (i = 0; i < nentryp->nServers; i++) {
  90         oentryp->serverNumber[i] = nentryp->serverNumber[i];
  91         oentryp->serverPartition[i] = nentryp->serverPartition[i];
  92         oentryp->serverFlags[i] = nentryp->serverFlags[i];
  93     }
  94     oentryp->nServers = i;
  95     for (i = 0; i < MAXTYPES; i++)
  96         oentryp->volumeId[i] = nentryp->volumeId[i];
  97     oentryp->cloneId = nentryp->cloneId;
  98     oentryp->flags = nentryp->flags;
  99     return 0;
 100 }
 101
 102 enum _vlserver_type {
 103     vltype_unknown = 0,
 104     vltype_old = 1,
 105     vltype_new = 2,
 106     vltype_uuid = 3
 107 };
 108
 109 static enum _vlserver_type newvlserver = vltype_unknown;
 110
 111 int
 112 VLDB_CreateEntry(struct nvldbentry *entryp)
 113 {
 114     struct vldbentry oentry;
 115     int code;
 116
 117     if (newvlserver == vltype_old) {
 118       tryold:
 119         code = nvlentry_to_ovlentry(entryp, &oentry);
 120         if (code)
 121             return code;
 122         code = ubik_VL_CreateEntry(cstruct, 0, &oentry);
 123         return code;
 124     }
 125     code = ubik_VL_CreateEntryN(cstruct, 0, entryp);
 126     if (newvlserver == vltype_unknown) {
 127         if (code == RXGEN_OPCODE) {
 128             newvlserver = vltype_old;   /* Doesn't support new interface */
 129             goto tryold;
 130         } else if (!code) {
 131             newvlserver = vltype_new;
 132         }
 133     }
 134     return code;
 135 }
 136
 137 int
 138 VLDB_GetEntryByID(afs_uint32 volid, afs_int32 voltype, struct nvldbentry *entryp)
 139 {
 140     struct vldbentry oentry;
 141     int code;
 142
 143     if (newvlserver == vltype_old) {
 144       tryold:
 145         code =
 146             ubik_VL_GetEntryByID(cstruct, 0, volid, voltype, &oentry);
 147         if (!code)
 148             ovlentry_to_nvlentry(&oentry, entryp);
 149         return code;
 150     }
 151     code = ubik_VL_GetEntryByIDN(cstruct, 0, volid, voltype, entryp);
 152     if (newvlserver == vltype_unknown) {
 153         if (code == RXGEN_OPCODE) {
 154             newvlserver = vltype_old;   /* Doesn't support new interface */
 155             goto tryold;
 156         } else if (!code) {
 157             newvlserver = vltype_new;
 158         }
 159     }
 160     return code;
 161 }
 162
 163 int
 164 VLDB_GetEntryByName(char *namep, struct nvldbentry *entryp)
 165 {
 166     struct vldbentry oentry;
 167     int code;
 168
 169     if (newvlserver == vltype_old) {
 170       tryold:
 171         code = ubik_VL_GetEntryByNameO(cstruct, 0, namep, &oentry);
 172         if (!code)
 173             ovlentry_to_nvlentry(&oentry, entryp);
 174         return code;
 175     }
 176     code = ubik_VL_GetEntryByNameN(cstruct, 0, namep, entryp);
 177     if (newvlserver == vltype_unknown) {
 178         if (code == RXGEN_OPCODE) {
 179             newvlserver = vltype_old;   /* Doesn't support new interface */
 180             goto tryold;
 181         } else if (!code) {
 182             newvlserver = vltype_new;
 183         }
 184     }
 185     return code;
 186 }
 187
 188 int
 189 VLDB_ReplaceEntry(afs_uint32 volid, afs_int32 voltype, struct nvldbentry *entryp, afs_int32 releasetype)
 190 {
 191     struct vldbentry oentry;
 192     int code;
 193
 194     if (newvlserver == vltype_old) {
 195       tryold:
 196         code = nvlentry_to_ovlentry(entryp, &oentry);
 197         if (code)
 198             return code;
 199         code =
 200             ubik_VL_ReplaceEntry(cstruct, 0, volid, voltype, &oentry,
 201                       releasetype);
 202         return code;
 203     }
 204     code =
 205         ubik_VL_ReplaceEntryN(cstruct, 0, volid, voltype, entryp,
 206                   releasetype);
 207     if (newvlserver == vltype_unknown) {
 208         if (code == RXGEN_OPCODE) {
 209             newvlserver = vltype_old;   /* Doesn't support new interface */
 210             goto tryold;
 211         } else if (!code) {
 212             newvlserver = vltype_new;
 213         }
 214     }
 215     return code;
 216 }
 217
 218 static void
 219 convertBulkToNBulk(bulkentries *bulk, nbulkentries *nbulk) {
 220     int i;
 221
 222     if (bulk->bulkentries_len == 0)
 223         return;
 224
 225     nbulk->nbulkentries_len = bulk->bulkentries_len;
 226     nbulk->nbulkentries_val =
 227         xdr_alloc(bulk->bulkentries_len * sizeof(struct nvldbentry));
 228
 229     for (i = 0; i < bulk->bulkentries_len; i++) {
 230         ovlentry_to_nvlentry(&bulk->bulkentries_val[i],
 231                              &nbulk->nbulkentries_val[i]);
 232     }
 233 }
 234
 235 int
 236 VLDB_ListAttributes(VldbListByAttributes *attrp,
 237                     afs_int32 *entriesp,
 238                     nbulkentries *blkentriesp)
 239 {
 240     bulkentries arrayEntries;
 241     int code;
 242
 243     if (newvlserver == vltype_old) {
 244       tryold:
 245         memset(&arrayEntries, 0, sizeof(arrayEntries));
 246         code =
 247             ubik_VL_ListAttributes(cstruct, 0, attrp, entriesp,
 248                       &arrayEntries);
 249
 250         if (code)
 251             return code;
 252
 253         /* Ensure the number of entries claimed matches the no. returned */
 254         if (*entriesp < 0)
 255             *entriesp = 0;
 256         if (*entriesp > arrayEntries.bulkentries_len)
 257             *entriesp = arrayEntries.bulkentries_len;
 258
 259         convertBulkToNBulk(&arrayEntries, blkentriesp);
 260
 261         xdr_free((xdrproc_t) xdr_bulkentries, &arrayEntries);
 262         return code;
 263     }
 264     code =
 265         ubik_VL_ListAttributesN(cstruct, 0, attrp, entriesp, blkentriesp);
 266     if (newvlserver == vltype_unknown) {
 267         if (code == RXGEN_OPCODE) {
 268             newvlserver = vltype_old;   /* Doesn't support new interface */
 269             goto tryold;
 270         } else if (!code) {
 271             newvlserver = vltype_new;
 272         }
 273     }
 274
 275     /* Ensure the number of entries claimed matches the no. returned */
 276     if (*entriesp < 0)
 277         *entriesp = 0;
 278     if (*entriesp > blkentriesp->nbulkentries_len)
 279         *entriesp = blkentriesp->nbulkentries_len;
 280
 281     return code;
 282 }
 283
 284 int
 285 VLDB_ListAttributesN2(VldbListByAttributes *attrp,
 286                       char *name,
 287                       afs_int32 thisindex,
 288                       afs_int32 *nentriesp,
 289                       nbulkentries *blkentriesp,
 290                       afs_int32 *nextindexp)
 291 {
 292     afs_int32 code = RXGEN_OPCODE;
 293
 294     if (newvlserver != vltype_old) {
 295         code =
 296             ubik_VL_ListAttributesN2(cstruct, 0, attrp, (name ? name : ""),
 297                                      thisindex, nentriesp, blkentriesp, nextindexp);
 298         if (code)
 299             return code;
 300
 301         /* Ensure the number of entries claimed matches the no. returned */
 302         if (*nentriesp < 0)
 303             *nentriesp = 0;
 304         if (*nentriesp > blkentriesp->nbulkentries_len)
 305             *nentriesp = blkentriesp->nbulkentries_len;
 306     }
 307     return code;
 308 }
 309
 310 struct cacheips {
 311     afs_uint32 server;
 312     afs_int32 count;
 313     afs_uint32 addrs[16];
 314 };
 315 /*
 316  * Increase cache size.  This avoids high CPU usage by the vlserver
 317  * in environments where there are more than 16 fileservers in the
 318  * cell.
 319  */
 320 #define GETADDRUCACHESIZE             64
 321 struct cacheips cacheips[GETADDRUCACHESIZE];
 322 int cacheip_index = 0;
 323
 324 int
 325 VLDB_IsSameAddrs(afs_uint32 serv1, afs_uint32 serv2, afs_int32 *errorp)
 326 {
 327     int code;
 328     ListAddrByAttributes attrs;
 329     bulkaddrs addrs;
 330     afs_uint32 *addrp, i, j, f1, f2;
 331     afs_int32 unique, nentries;
 332     afsUUID uuid;
 333     static int initcache = 0;
 334
 335     *errorp = 0;
 336
 337     if (serv1 == serv2)
 338         return 1;
 339     if (newvlserver == vltype_old || newvlserver == vltype_new) {
 340         return 0;
 341     }
 342     if (!initcache) {
 343         for (i = 0; i < GETADDRUCACHESIZE; i++) {
 344             cacheips[i].server = cacheips[i].count = 0;
 345         }
 346         initcache = 1;
 347     }
 348
 349     /* See if it's cached */
 350     for (i = 0; i < GETADDRUCACHESIZE; i++) {
 351         f1 = f2 = 0;
 352         for (j = 0; j < cacheips[i].count; j++) {
 353             if (serv1 == cacheips[i].addrs[j])
 354                 f1 = 1;
 355             else if (serv2 == cacheips[i].addrs[j])
 356                 f2 = 1;
 357
 358             if (f1 && f2)
 359                 return 1;
 360         }
 361         if (f1 || f2)
 362             return 0;
 363         if (cacheips[i].server == serv1)
 364             return 0;
 365     }
 366
 367     memset(&attrs, 0, sizeof(attrs));
 368     attrs.Mask = VLADDR_IPADDR;
 369     attrs.ipaddr = serv1;
 370     memset(&addrs, 0, sizeof(addrs));
 371     memset(&uuid, 0, sizeof(uuid));
 372     code =
 373         ubik_VL_GetAddrsU(cstruct, 0, &attrs, &uuid, &unique, &nentries,
 374                   &addrs);
 375     if (newvlserver == vltype_unknown) {
 376         if (code == RXGEN_OPCODE) {
 377             return 0;
 378         } else if (!code) {
 379             newvlserver = vltype_uuid;
 380         }
 381     }
 382     if (code == VL_NOENT)
 383         return 0;
 384     if (code) {
 385         *errorp = code;
 386         return 0;
 387     }
 388
 389     code = 0;
 390     if (nentries > GETADDRUCACHESIZE)
 391         nentries = GETADDRUCACHESIZE;   /* safety check; should not happen */
 392     if (++cacheip_index >= GETADDRUCACHESIZE)
 393         cacheip_index = 0;
 394     cacheips[cacheip_index].server = serv1;
 395     cacheips[cacheip_index].count = nentries;
 396     addrp = addrs.bulkaddrs_val;
 397     for (i = 0; i < nentries; i++, addrp++) {
 398         cacheips[cacheip_index].addrs[i] = *addrp;
 399         if (serv2 == *addrp) {
 400             code = 1;
 401         }
 402     }
 403     return code;
 404 }
 405
 406
 407 /*
 408   Set encryption.  If 'cryptflag' is nonzero, encrpytion is turned on
 409   for authenticated connections; if zero, encryption is turned off.
 410   Calling this function always results in a level of at least rxkad_auth;
 411   to get a rxkad_clear connection, simply don't call this.
 412 */
 413 void
 414 vsu_SetCrypt(int cryptflag)
 415 {
 416     if (cryptflag) {
 417         vsu_rxkad_level = rxkad_crypt;
 418     } else {
 419         vsu_rxkad_level = rxkad_auth;
 420     }
 421 }
 422
 423
 424 /*
 425   Get the appropriate type of ubik client structure out from the system.
 426 */
 427 afs_int32
 428 vsu_ClientInit(int noAuthFlag, const char *confDir, char *cellName, afs_int32 sauth,
 429                struct ubik_client **uclientp,
 430                int (*secproc)(struct rx_securityClass *, afs_int32))
 431 {
 432     return ugen_ClientInit(noAuthFlag, confDir, cellName, sauth, uclientp,
 433                            secproc, "vsu_ClientInit", vsu_rxkad_level,
 434                            VLDB_MAXSERVERS, AFSCONF_VLDBSERVICE, 90,
 435                            0, 0, USER_SERVICE_ID);
 436 }
 437
 438
 439 /*extract the name of volume <name> without readonly or backup suffixes
 440  * and return the result as <rname>.
 441  */
 442 int
 443 vsu_ExtractName(char rname[], char name[])
 444 {
 445     char sname[VOLSER_OLDMAXVOLNAME + 1];
 446     int total;
 447
 448     strncpy(sname, name, sizeof(sname));
 449     sname[sizeof(sname) - 1] = '\0';
 450     total = strlen(sname);
 451     if (!strcmp(&sname[total - 9], ".readonly")) {
 452         /*discard the last 8 chars */
 453         sname[total - 9] = '\0';
 454         strcpy(rname, sname);
 455         return 0;
 456     } else if (!strcmp(&sname[total - 7], ".backup")) {
 457         /*discard last 6 chars */
 458         sname[total - 7] = '\0';
 459         strcpy(rname, sname);
 460         return 0;
 461     } else {
 462         strncpy(rname, name, VOLSER_OLDMAXVOLNAME);
 463         rname[VOLSER_OLDMAXVOLNAME] = '\0';
 464         return -1;
 465     }
 466 }
 467
 468 /* returns 0 if failed */
 469 afs_uint32
 470 vsu_GetVolumeID(char *astring, struct ubik_client *acstruct, afs_int32 *errp)
 471 {
 472     char volname[VOLSER_OLDMAXVOLNAME + 1];
 473     struct nvldbentry entry;
 474     afs_int32 vcode = 0;
 475     int total;
 476
 477     *errp = 0;
 478
 479     if (isdigit(astring[0])) {
 480         char *end;
 481         afs_uint32 result;
 482         result = strtoul(astring, &end, 10);
 483         if (result != UINT_MAX && *end == '\0')
 484             return result;
 485     }
 486
 487     /* It was not a volume number but something else */
 488     total = strlen(astring);
 489     vsu_ExtractName(volname, astring);
 490     vcode = VLDB_GetEntryByName(volname, &entry);
 491     if (!vcode) {
 492       if ((total >= 9) && (!strcmp(&astring[total - 9], ".readonly")))
 493         return entry.volumeId[ROVOL];
 494       else if ((total >= 7) && (!strcmp(&astring[total - 7], ".backup")))
 495         return entry.volumeId[BACKVOL];
 496       else
 497         return (entry.volumeId[RWVOL]);
 498     }
 499     *errp = vcode;
 500     return 0;           /* can't find volume */
 501 }