src/WINNT/afsd/cm_ioctl.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 <afs/param.h>
  11 #include <afs/stds.h>
  12 #include <afs/cellconfig.h>
  13 #include <afs/ptserver.h>
  14 #include <ubik.h>
  15
  16 #include <windows.h>
  17 #include <errno.h>
  18 #include <stdlib.h>
  19 #include <malloc.h>
  20 #include <string.h>
  21 #include <stdio.h>
  22 #include <time.h>
  23
  24 #include <osi.h>
  25
  26 #include "afsd.h"
  27 #include "afsd_init.h"
  28 #include <WINNT\afsreg.h>
  29
  30 #include "smb.h"
  31
  32 #include <rx/rxkad.h>
  33 #include "afsrpc.h"
  34
  35 #include "cm_rpc.h"
  36 #include <strsafe.h>
  37 #include <winioctl.h>
  38 #include <rx\rx.h>
  39
  40 #include "cm_btree.h"
  41
  42 #ifdef _DEBUG
  43 #include <crtdbg.h>
  44 #endif
  45
  46 /* Copied from afs_tokens.h */
  47 #define PIOCTL_LOGON    0x1
  48 #define MAX_PATH 260
  49
  50 const char utf8_prefix[] = UTF8_PREFIX;
  51 const int  utf8_prefix_size = sizeof(utf8_prefix) -  sizeof(char);
  52
  53 osi_mutex_t cm_Afsdsbmt_Lock;
  54
  55 extern afs_int32 cryptall;
  56 extern char cm_NetbiosName[];
  57 extern clientchar_t cm_NetbiosNameC[];
  58
  59 extern void afsi_log(char *pattern, ...);
  60
  61 void cm_InitIoctl(void)
  62 {
  63     lock_InitializeMutex(&cm_Afsdsbmt_Lock, "AFSDSBMT.INI Access Lock");
  64 }
  65
  66 /*
  67  * Utility function.  (Not currently in use.)
  68  * This function forces all dirty buffers to the file server and
  69  * then discards the status info.
  70  */
  71 afs_int32
  72 cm_CleanFile(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp)
  73 {
  74     long code;
  75
  76     code = buf_CleanVnode(scp, userp, reqp);
  77     if (!code) {
  78         lock_ObtainWrite(&scp->rw);
  79         cm_DiscardSCache(scp);
  80         lock_ReleaseWrite(&scp->rw);
  81     }
  82     osi_Log2(afsd_logp,"cm_CleanFile scp 0x%x returns error: [%x]",scp, code);
  83     return code;
  84 }
  85
  86 /*
  87  * Utility function.  Used within this file.
  88  * scp must be held but not locked.
  89  */
  90 afs_int32
  91 cm_FlushFile(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp)
  92 {
  93     afs_int32 code;
  94
  95 #ifdef AFS_FREELANCE_CLIENT
  96     if ( scp->fid.cell == AFS_FAKE_ROOT_CELL_ID && scp->fid.volume == AFS_FAKE_ROOT_VOL_ID ) {
  97         cm_noteLocalMountPointChange();
  98         return 0;
  99     }
 100 #endif
 101
 102     code = buf_FlushCleanPages(scp, userp, reqp);
 103
 104     lock_ObtainWrite(&scp->rw);
 105     cm_DiscardSCache(scp);
 106     lock_ReleaseWrite(&scp->rw);
 107
 108     osi_Log2(afsd_logp,"cm_FlushFile scp 0x%x returns error: [%x]",scp, code);
 109     return code;
 110 }
 111
 112 /*
 113  * Utility function.  (Not currently in use)
 114  * IoctlPath must be parsed or skipped prior to calling.
 115  * scp must be held but not locked.
 116  */
 117 afs_int32
 118 cm_FlushParent(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp)
 119 {
 120     afs_int32 code = 0;
 121     cm_scache_t * pscp;
 122
 123     pscp = cm_FindSCacheParent(scp);
 124
 125     /* now flush the file */
 126     code = cm_FlushFile(pscp, userp, reqp);
 127     cm_ReleaseSCache(pscp);
 128
 129     return code;
 130 }
 131
 132 /*
 133  * Utility function.  Used within this function.
 134  */
 135 afs_int32
 136 cm_FlushVolume(cm_user_t *userp, cm_req_t *reqp, afs_uint32 cell, afs_uint32 volume)
 137 {
 138     afs_int32 code = 0;
 139     cm_scache_t *scp;
 140     int i;
 141
 142 #ifdef AFS_FREELANCE_CLIENT
 143     if ( cell == AFS_FAKE_ROOT_CELL_ID && volume == AFS_FAKE_ROOT_VOL_ID ) {
 144         cm_noteLocalMountPointChange();
 145         return 0;
 146     }
 147 #endif
 148
 149     lock_ObtainWrite(&cm_scacheLock);
 150     for (i=0; i<cm_data.scacheHashTableSize; i++) {
 151         for (scp = cm_data.scacheHashTablep[i]; scp; scp = scp->nextp) {
 152             if (scp->fid.volume == volume && scp->fid.cell == cell) {
 153                 cm_HoldSCacheNoLock(scp);
 154                 lock_ReleaseWrite(&cm_scacheLock);
 155
 156                 /* now flush the file */
 157                 code = cm_FlushFile(scp, userp, reqp);
 158                 lock_ObtainWrite(&cm_scacheLock);
 159                 cm_ReleaseSCacheNoLock(scp);
 160             }
 161         }
 162     }
 163     lock_ReleaseWrite(&cm_scacheLock);
 164
 165     return code;
 166 }
 167
 168 /*
 169  * Utility function.  Used within this file.
 170  * Invalidate ACL info for a user that has just obtained or lost tokens.
 171  */
 172 void
 173 cm_ResetACLCache(cm_user_t *userp)
 174 {
 175     cm_scache_t *scp;
 176     int hash;
 177
 178     lock_ObtainWrite(&cm_scacheLock);
 179     for (hash=0; hash < cm_data.scacheHashTableSize; hash++) {
 180         for (scp=cm_data.scacheHashTablep[hash]; scp; scp=scp->nextp) {
 181             cm_HoldSCacheNoLock(scp);
 182             lock_ReleaseWrite(&cm_scacheLock);
 183             lock_ObtainWrite(&scp->rw);
 184             cm_InvalidateACLUser(scp, userp);
 185             lock_ReleaseWrite(&scp->rw);
 186             lock_ObtainWrite(&cm_scacheLock);
 187             cm_ReleaseSCacheNoLock(scp);
 188         }
 189     }
 190     lock_ReleaseWrite(&cm_scacheLock);
 191 }
 192
 193 /*
 194  *  TranslateExtendedChars - This is a fix for TR 54482.
 195  *
 196  *  If an extended character (80 - FF) is entered into a file
 197  *  or directory name in Windows, the character is translated
 198  *  into the OEM character map before being passed to us.
 199  *  The pioctl functions must match
 200  *  this translation for paths given via our own commands (like
 201  *  fs).  If we do not do this, then we will try to perform an
 202  *  operation on a non-translated path, which we will fail to
 203  *  find, since the path was created with the translated chars.
 204  *  This function performs the required translation.
 205  *
 206  *  OEM character code pages are used by the non-Unicode SMB
 207  *  mode.  Do not use if the CM_IOCTLFLAG_USEUTF8 is set.
 208  */
 209 void
 210 TranslateExtendedChars(char *str)
 211 {
 212     if (!str || !*str)
 213         return;
 214
 215     CharToOemA(str, str);
 216 }
 217
 218 void cm_SkipIoctlPath(cm_ioctl_t *ioctlp)
 219 {
 220     size_t temp;
 221
 222     temp = strlen(ioctlp->inDatap) + 1;
 223     ioctlp->inDatap += temp;
 224 }
 225
 226
 227 clientchar_t * cm_ParseIoctlStringAlloc(cm_ioctl_t *ioctlp, const char * ext_instrp)
 228 {
 229     clientchar_t * rs = NULL;
 230     const char * instrp;
 231
 232     instrp = (ext_instrp)?ext_instrp:ioctlp->inDatap;
 233
 234     if ((ioctlp->flags & CM_IOCTLFLAG_USEUTF8) == CM_IOCTLFLAG_USEUTF8) {
 235         rs = cm_Utf8ToClientStringAlloc(instrp, -1, NULL);
 236     } else {
 237         int cch;
 238
 239         /* Not a UTF-8 string */
 240         if (smb_StoreAnsiFilenames) {
 241             cch = cm_AnsiToClientString(instrp, -1, NULL, 0);
 242 #ifdef DEBUG
 243             osi_assert(cch > 0);
 244 #endif
 245             rs = malloc(cch * sizeof(clientchar_t));
 246             cm_AnsiToClientString(instrp, -1, rs, cch);
 247         } else {
 248             cch = cm_OemToClientString(instrp, -1, NULL, 0);
 249 #ifdef DEBUG
 250             osi_assert(cch > 0);
 251 #endif
 252             rs = malloc(cch * sizeof(clientchar_t));
 253             cm_OemToClientString(instrp, -1, rs, cch);
 254         }
 255     }
 256
 257     if (ext_instrp == NULL) {
 258         ioctlp->inDatap += strlen(ioctlp->inDatap) + 1;
 259     }
 260     return rs;
 261 }
 262
 263 int cm_UnparseIoctlString(cm_ioctl_t *ioctlp,
 264                           char * ext_outp,
 265                           const clientchar_t * cstr, int cchlen)
 266 {
 267     char *outp;
 268     int cchout;
 269
 270     outp = ((ext_outp == NULL)? ioctlp->outDatap : ext_outp);
 271
 272     if ((ioctlp->flags & CM_IOCTLFLAG_USEUTF8) == CM_IOCTLFLAG_USEUTF8) {
 273         cchout = cm_ClientStringToUtf8(cstr, cchlen, outp,
 274                                        SMB_IOCTL_MAXDATA - (outp - ioctlp->outAllocp));
 275     } else {
 276         if (smb_StoreAnsiFilenames) {
 277             cchout = WideCharToMultiByte(CP_ACP, 0, cstr, cchlen,
 278                                          outp,
 279                                          SMB_IOCTL_MAXDATA - (outp - ioctlp->outAllocp),
 280                                          NULL, NULL);
 281         } else {
 282             cchout = WideCharToMultiByte(CP_OEMCP, 0, cstr, cchlen,
 283                                          outp,
 284                                          SMB_IOCTL_MAXDATA - (outp - ioctlp->outAllocp),
 285                                          NULL, NULL);
 286         }
 287     }
 288
 289     if (cchout > 0 && ext_outp == NULL) {
 290         ioctlp->outDatap += cchout;
 291     }
 292
 293     return cchout;
 294 }
 295
 296 /*
 297  * Must be called before XXX_ParseIoctlPath or cm_SkipIoctlPath
 298  */
 299 cm_ioctlQueryOptions_t *
 300 cm_IoctlGetQueryOptions(struct cm_ioctl *ioctlp, struct cm_user *userp)
 301 {
 302     afs_uint32 pathlen = strlen(ioctlp->inDatap) + 1;
 303     char *p = ioctlp->inDatap + pathlen;
 304     cm_ioctlQueryOptions_t * optionsp = NULL;
 305
 306     if (ioctlp->inCopied > p - ioctlp->inAllocp) {
 307         optionsp = (cm_ioctlQueryOptions_t *)p;
 308         if (optionsp->size < 12 /* minimum size of struct */)
 309             optionsp = NULL;
 310     }
 311
 312     return optionsp;
 313 }
 314
 315 /*
 316  * Must be called after smb_ParseIoctlPath or cm_SkipIoctlPath
 317  * or any other time that ioctlp->inDatap points at the
 318  * cm_ioctlQueryOptions_t object.
 319  */
 320 void
 321 cm_IoctlSkipQueryOptions(struct cm_ioctl *ioctlp, struct cm_user *userp)
 322 {
 323     cm_ioctlQueryOptions_t * optionsp = (cm_ioctlQueryOptions_t *)ioctlp->inDatap;
 324     ioctlp->inDatap += optionsp->size;
 325 }
 326
 327 /* format the specified path to look like "/afs/<cellname>/usr", by
 328  * adding "/afs" (if necessary) in front, changing any \'s to /'s, and
 329  * removing any trailing "/"'s. One weirdo caveat: "/afs" will be
 330  * intentionally returned as "/afs/"--this makes submount manipulation
 331  * easier (because we can always jump past the initial "/afs" to find
 332  * the AFS path that should be written into afsdsbmt.ini).
 333  */
 334 void
 335 cm_NormalizeAfsPath(clientchar_t *outpathp, long cchlen, clientchar_t *inpathp)
 336 {
 337     clientchar_t *cp;
 338     clientchar_t bslash_mountRoot[256];
 339
 340     cm_ClientStrCpy(bslash_mountRoot, lengthof(bslash_mountRoot), cm_mountRootC);
 341     bslash_mountRoot[0] = '\\';
 342
 343     if (!cm_ClientStrCmpNI(inpathp, cm_mountRootC, cm_mountRootCLen))
 344         cm_ClientStrCpy(outpathp, cchlen, inpathp);
 345     else if (!cm_ClientStrCmpNI(inpathp, bslash_mountRoot,
 346                                 cm_ClientStrLen(bslash_mountRoot)))
 347         cm_ClientStrCpy(outpathp, cchlen, inpathp);
 348     else if ((inpathp[0] == '/') || (inpathp[0] == '\\'))
 349         cm_ClientStrPrintfN(outpathp, cchlen, _C("%s%s"), cm_mountRootC, inpathp);
 350     else // inpathp looks like "<cell>/usr"
 351         cm_ClientStrPrintfN(outpathp, cchlen, _C("%s/%s"), cm_mountRootC, inpathp);
 352
 353     for (cp = outpathp; *cp != 0; ++cp) {
 354         if (*cp == '\\')
 355             *cp = '/';
 356     }
 357
 358     if (cm_ClientStrLen(outpathp) && (outpathp[cm_ClientStrLen(outpathp)-1] == '/')) {
 359         outpathp[cm_ClientStrLen(outpathp)-1] = 0;
 360     }
 361
 362     if (!cm_ClientStrCmpI(outpathp, cm_mountRootC)) {
 363         cm_ClientStrCpy(outpathp, cchlen, cm_mountRootC);
 364     }
 365 }
 366
 367 void cm_NormalizeAfsPathAscii(char *outpathp, long outlen, char *inpathp)
 368 {
 369     char *cp;
 370     char bslash_mountRoot[256];
 371
 372     strncpy(bslash_mountRoot, cm_mountRoot, sizeof(bslash_mountRoot) - 1);
 373     bslash_mountRoot[0] = '\\';
 374
 375     if (!strnicmp (inpathp, cm_mountRoot, strlen(cm_mountRoot)))
 376         StringCbCopy(outpathp, outlen, inpathp);
 377     else if (!strnicmp (inpathp, bslash_mountRoot, strlen(bslash_mountRoot)))
 378         StringCbCopy(outpathp, outlen, inpathp);
 379     else if ((inpathp[0] == '/') || (inpathp[0] == '\\'))
 380         StringCbPrintfA(outpathp, outlen, "%s%s", cm_mountRoot, inpathp);
 381     else // inpathp looks like "<cell>/usr"
 382         StringCbPrintfA(outpathp, outlen, "%s/%s", cm_mountRoot, inpathp);
 383
 384     for (cp = outpathp; *cp != 0; ++cp) {
 385         if (*cp == '\\')
 386             *cp = '/';
 387     }
 388
 389     if (strlen(outpathp) && (outpathp[strlen(outpathp)-1] == '/')) {
 390         outpathp[strlen(outpathp)-1] = 0;
 391     }
 392
 393     if (!strcmpi (outpathp, cm_mountRoot)) {
 394         StringCbCopy(outpathp, outlen, cm_mountRoot);
 395     }
 396 }
 397
 398
 399 /*
 400  * VIOCGETAL internals.
 401  *
 402  * Assumes that pioctl path has been parsed or skipped.
 403  * scp is held but not locked.
 404  */
 405 afs_int32
 406 cm_IoctlGetACL(cm_ioctl_t *ioctlp, cm_user_t *userp, cm_scache_t *scp, cm_req_t *reqp)
 407 {
 408     afs_int32 code;
 409     cm_conn_t *connp;
 410     AFSOpaque acl;
 411     AFSFetchStatus fileStatus;
 412     AFSVolSync volSync;
 413     AFSFid afid;
 414     int tlen;
 415     struct rx_connection * rxconnp;
 416
 417     /* now make the get acl call */
 418 #ifdef AFS_FREELANCE_CLIENT
 419     if ( scp->fid.cell == AFS_FAKE_ROOT_CELL_ID && scp->fid.volume == AFS_FAKE_ROOT_VOL_ID ) {
 420         code = 0;
 421         ioctlp->outDatap[0] ='\0';
 422     } else
 423 #endif
 424     {
 425         afid.Volume = scp->fid.volume;
 426         afid.Vnode = scp->fid.vnode;
 427         afid.Unique = scp->fid.unique;
 428         do {
 429             acl.AFSOpaque_val = ioctlp->outDatap;
 430             acl.AFSOpaque_len = 0;
 431             code = cm_ConnFromFID(&scp->fid, userp, reqp, &connp);
 432             if (code)
 433                 continue;
 434
 435             rxconnp = cm_GetRxConn(connp);
 436             code = RXAFS_FetchACL(rxconnp, &afid, &acl, &fileStatus, &volSync);
 437             rx_PutConnection(rxconnp);
 438
 439         } while (cm_Analyze(connp, userp, reqp, &scp->fid, &volSync, NULL, NULL, code));
 440         code = cm_MapRPCError(code, reqp);
 441
 442         if (code)
 443             return code;
 444     }
 445     /* skip over return data */
 446     tlen = (int)strlen(ioctlp->outDatap) + 1;
 447     ioctlp->outDatap += tlen;
 448
 449     /* and return success */
 450     return 0;
 451 }
 452
 453
 454 /*
 455  * VIOC_FILE_CELL_NAME internals.
 456  *
 457  * Assumes that pioctl path has been parsed or skipped.
 458  * scp is held but not locked.
 459  */
 460 afs_int32
 461 cm_IoctlGetFileCellName(struct cm_ioctl *ioctlp, struct cm_user *userp, cm_scache_t *scp, cm_req_t *reqp)
 462 {
 463     afs_int32 code;
 464     cm_cell_t *cellp;
 465
 466 #ifdef AFS_FREELANCE_CLIENT
 467     if ( cm_freelanceEnabled &&
 468          scp->fid.cell==AFS_FAKE_ROOT_CELL_ID &&
 469          scp->fid.volume==AFS_FAKE_ROOT_VOL_ID &&
 470          scp->fid.vnode==0x1 && scp->fid.unique==0x1 ) {
 471         StringCbCopyA(ioctlp->outDatap, SMB_IOCTL_MAXDATA - (ioctlp->outDatap - ioctlp->outAllocp), "Freelance.Local.Root");
 472         ioctlp->outDatap += strlen(ioctlp->outDatap) + 1;
 473         code = 0;
 474     } else
 475 #endif /* AFS_FREELANCE_CLIENT */
 476     {
 477         cellp = cm_FindCellByID(scp->fid.cell, CM_FLAG_NOPROBE);
 478         if (cellp) {
 479             clientchar_t * cellname;
 480
 481             cellname = cm_FsStringToClientStringAlloc(cellp->name, -1, NULL);
 482             cm_UnparseIoctlString(ioctlp, NULL, cellname, -1);
 483             free(cellname);
 484             code = 0;
 485         } else
 486             code = CM_ERROR_NOSUCHCELL;
 487     }
 488
 489     return code;
 490 }
 491
 492
 493 /*
 494  * VIOCSETAL internals.
 495  *
 496  * Assumes that pioctl path has been parsed or skipped.
 497  * scp is held but not locked.
 498  */
 499 afs_int32
 500 cm_IoctlSetACL(struct cm_ioctl *ioctlp, struct cm_user *userp, cm_scache_t *scp, cm_req_t *reqp)
 501 {
 502     afs_int32 code;
 503     cm_conn_t *connp;
 504     AFSOpaque acl;
 505     AFSFetchStatus fileStatus;
 506     AFSVolSync volSync;
 507     AFSFid fid;
 508     struct rx_connection * rxconnp;
 509
 510 #ifdef AFS_FREELANCE_CLIENT
 511     if ( scp->fid.cell == AFS_FAKE_ROOT_CELL_ID && scp->fid.volume == AFS_FAKE_ROOT_VOL_ID ) {
 512         code = CM_ERROR_NOACCESS;
 513     } else
 514 #endif
 515     {
 516         /* now make the get acl call */
 517         fid.Volume = scp->fid.volume;
 518         fid.Vnode = scp->fid.vnode;
 519         fid.Unique = scp->fid.unique;
 520         do {
 521             acl.AFSOpaque_val = ioctlp->inDatap;
 522             acl.AFSOpaque_len = (u_int)strlen(ioctlp->inDatap)+1;
 523             code = cm_ConnFromFID(&scp->fid, userp, reqp, &connp);
 524             if (code)
 525                 continue;
 526
 527             rxconnp = cm_GetRxConn(connp);
 528             code = RXAFS_StoreACL(rxconnp, &fid, &acl, &fileStatus, &volSync);
 529             rx_PutConnection(rxconnp);
 530
 531         } while (cm_Analyze(connp, userp, reqp, &scp->fid, &volSync, NULL, NULL, code));
 532         code = cm_MapRPCError(code, reqp);
 533
 534         /* invalidate cache info, since we just trashed the ACL cache */
 535         lock_ObtainWrite(&scp->rw);
 536         cm_DiscardSCache(scp);
 537         lock_ReleaseWrite(&scp->rw);
 538     }
 539
 540     return code;
 541 }
 542
 543 /*
 544  * VIOC_FLUSHALL internals.
 545  *
 546  * Assumes that pioctl path has been parsed or skipped.
 547  */
 548 afs_int32
 549 cm_IoctlFlushAllVolumes(struct cm_ioctl *ioctlp, struct cm_user *userp, cm_req_t *reqp)
 550 {
 551     afs_int32 code;
 552     cm_scache_t *scp;
 553     int i;
 554
 555     lock_ObtainWrite(&cm_scacheLock);
 556     for (i=0; i<cm_data.scacheHashTableSize; i++) {
 557         for (scp = cm_data.scacheHashTablep[i]; scp; scp = scp->nextp) {
 558             cm_HoldSCacheNoLock(scp);
 559             lock_ReleaseWrite(&cm_scacheLock);
 560
 561             /* now flush the file */
 562             code = cm_FlushFile(scp, userp, reqp);
 563             lock_ObtainWrite(&cm_scacheLock);
 564             cm_ReleaseSCacheNoLock(scp);
 565         }
 566     }
 567     lock_ReleaseWrite(&cm_scacheLock);
 568
 569     return code;
 570 }
 571
 572 /*
 573  * VIOC_FLUSHVOLUME internals.
 574  *
 575  * Assumes that pioctl path has been parsed or skipped.
 576  * scp is held but not locked.
 577  */
 578 afs_int32
 579 cm_IoctlFlushVolume(struct cm_ioctl *ioctlp, struct cm_user *userp, cm_scache_t *scp, cm_req_t *reqp)
 580 {
 581     afs_int32 code;
 582     afs_uint32 volume;
 583     afs_uint32 cell;
 584
 585 #ifdef AFS_FREELANCE_CLIENT
 586     if ( scp->fid.cell == AFS_FAKE_ROOT_CELL_ID && scp->fid.volume == AFS_FAKE_ROOT_VOL_ID ) {
 587         code = CM_ERROR_NOACCESS;
 588     } else
 589 #endif
 590     {
 591         volume = scp->fid.volume;
 592         cell = scp->fid.cell;
 593         code = cm_FlushVolume(userp, reqp, cell, volume);
 594     }
 595     return code;
 596 }
 597
 598 /*
 599  * VIOCFLUSH internals.
 600  *
 601  * Assumes that pioctl path has been parsed or skipped.
 602  * scp is held but not locked.
 603  */
 604 afs_int32
 605 cm_IoctlFlushFile(struct cm_ioctl *ioctlp, struct cm_user *userp, cm_scache_t *scp, cm_req_t *reqp)
 606 {
 607     afs_int32 code;
 608
 609 #ifdef AFS_FREELANCE_CLIENT
 610     if ( scp->fid.cell == AFS_FAKE_ROOT_CELL_ID && scp->fid.volume == AFS_FAKE_ROOT_VOL_ID ) {
 611         code = CM_ERROR_NOACCESS;
 612     } else
 613 #endif
 614     {
 615         cm_FlushFile(scp, userp, reqp);
 616     }
 617     return 0;
 618 }
 619
 620
 621 /*
 622  * VIOCSETVOLSTAT internals.
 623  *
 624  * Assumes that pioctl path has been parsed or skipped.
 625  * scp is held but not locked.
 626  */
 627 afs_int32
 628 cm_IoctlSetVolumeStatus(struct cm_ioctl *ioctlp, struct cm_user *userp, cm_scache_t *scp, cm_req_t *reqp)
 629 {
 630     afs_int32 code;
 631     char volName[32];
 632     char offLineMsg[256];
 633     char motd[256];
 634     cm_conn_t *tcp;
 635     AFSFetchVolumeStatus volStat;
 636     AFSStoreVolumeStatus storeStat;
 637     cm_volume_t *tvp;
 638     cm_cell_t *cellp;
 639     char *cp;
 640     clientchar_t *strp;
 641     struct rx_connection * rxconnp;
 642
 643 #ifdef AFS_FREELANCE_CLIENT
 644     if ( scp->fid.cell == AFS_FAKE_ROOT_CELL_ID && scp->fid.volume == AFS_FAKE_ROOT_VOL_ID ) {
 645         code = CM_ERROR_NOACCESS;
 646     } else
 647 #endif
 648     {
 649         cellp = cm_FindCellByID(scp->fid.cell, 0);
 650         osi_assertx(cellp, "null cm_cell_t");
 651
 652         if (scp->flags & CM_SCACHEFLAG_RO)
 653             return CM_ERROR_READONLY;
 654
 655         code = cm_FindVolumeByID(cellp, scp->fid.volume, userp, reqp,
 656                                  CM_GETVOL_FLAG_CREATE, &tvp);
 657         if (code)
 658             return code;
 659
 660         cm_PutVolume(tvp);
 661
 662         /* Copy the junk out, using cp as a roving pointer. */
 663         memcpy((char *)&volStat, ioctlp->inDatap, sizeof(AFSFetchVolumeStatus));
 664         ioctlp->inDatap += sizeof(AFSFetchVolumeStatus);
 665
 666         strp = cm_ParseIoctlStringAlloc(ioctlp, NULL);
 667         cm_ClientStringToFsString(strp, -1, volName, lengthof(volName));
 668         free(strp);
 669
 670         strp = cm_ParseIoctlStringAlloc(ioctlp, NULL);
 671         cm_ClientStringToFsString(strp, -1, offLineMsg, lengthof(offLineMsg));
 672         free(strp);
 673
 674         strp = cm_ParseIoctlStringAlloc(ioctlp, NULL);
 675         cm_ClientStringToFsString(strp, -1, motd, lengthof(motd));
 676         free(strp);
 677
 678         strp = NULL;
 679
 680         storeStat.Mask = 0;
 681         if (volStat.MinQuota != -1) {
 682             storeStat.MinQuota = volStat.MinQuota;
 683             storeStat.Mask |= AFS_SETMINQUOTA;
 684         }
 685         if (volStat.MaxQuota != -1) {
 686             storeStat.MaxQuota = volStat.MaxQuota;
 687             storeStat.Mask |= AFS_SETMAXQUOTA;
 688         }
 689
 690         do {
 691             code = cm_ConnFromFID(&scp->fid, userp, reqp, &tcp);
 692             if (code)
 693                 continue;
 694
 695             rxconnp = cm_GetRxConn(tcp);
 696             code = RXAFS_SetVolumeStatus(rxconnp, scp->fid.volume,
 697                                          &storeStat, volName, offLineMsg, motd);
 698             rx_PutConnection(rxconnp);
 699
 700         } while (cm_Analyze(tcp, userp, reqp, &scp->fid, NULL, NULL, NULL, code));
 701         code = cm_MapRPCError(code, reqp);
 702     }
 703
 704     /* return on failure */
 705     if (code)
 706         return code;
 707
 708     /* we are sending parms back to make compat. with prev system.  should
 709      * change interface later to not ask for current status, just set
 710      * new status
 711      */
 712     cp = ioctlp->outDatap;
 713     memcpy(cp, (char *)&volStat, sizeof(VolumeStatus));
 714     cp += sizeof(VolumeStatus);
 715     StringCbCopyA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), volName);
 716     cp += strlen(volName)+1;
 717     StringCbCopyA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), offLineMsg);
 718     cp += strlen(offLineMsg)+1;
 719     StringCbCopyA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), motd);
 720     cp += strlen(motd)+1;
 721
 722     /* now return updated return data pointer */
 723     ioctlp->outDatap = cp;
 724
 725     return 0;
 726 }
 727
 728
 729 /*
 730  * VIOCGETVOLSTAT internals.
 731  *
 732  * Assumes that pioctl path has been parsed or skipped.
 733  * scp is held but not locked.
 734  */
 735 afs_int32
 736 cm_IoctlGetVolumeStatus(struct cm_ioctl *ioctlp, struct cm_user *userp, cm_scache_t *scp, cm_req_t *reqp)
 737 {
 738     afs_int32 code;
 739     char volName[32]="(unknown)";
 740     char offLineMsg[256]="server temporarily inaccessible";
 741     char motd[256]="server temporarily inaccessible";
 742     cm_conn_t *connp;
 743     AFSFetchVolumeStatus volStat;
 744     char *cp;
 745     char *Name;
 746     char *OfflineMsg;
 747     char *MOTD;
 748     struct rx_connection * rxconnp;
 749
 750 #ifdef AFS_FREELANCE_CLIENT
 751     if ( scp->fid.cell == AFS_FAKE_ROOT_CELL_ID && scp->fid.volume == AFS_FAKE_ROOT_VOL_ID ) {
 752         code = 0;
 753         strncpy(volName, "Freelance.Local.Root", sizeof(volName));
 754         offLineMsg[0] = '\0';
 755         strncpy(motd, "Freelance mode in use.", sizeof(motd));
 756         volStat.Vid = scp->fid.volume;
 757         volStat.MaxQuota = 0;
 758         volStat.BlocksInUse = 100;
 759         volStat.PartBlocksAvail = 0;
 760         volStat.PartMaxBlocks = 100;
 761     } else
 762 #endif
 763     {
 764         Name = volName;
 765         OfflineMsg = offLineMsg;
 766         MOTD = motd;
 767         do {
 768             code = cm_ConnFromFID(&scp->fid, userp, reqp, &connp);
 769             if (code) continue;
 770
 771             rxconnp = cm_GetRxConn(connp);
 772             code = RXAFS_GetVolumeStatus(rxconnp, scp->fid.volume,
 773                                          &volStat, &Name, &OfflineMsg, &MOTD);
 774             rx_PutConnection(rxconnp);
 775
 776         } while (cm_Analyze(connp, userp, reqp, &scp->fid, NULL, NULL, NULL, code));
 777         code = cm_MapRPCError(code, reqp);
 778     }
 779
 780     if (code)
 781         return code;
 782
 783     /* Copy all this junk into msg->im_data, keeping track of the lengths. */
 784     cp = ioctlp->outDatap;
 785     memcpy(cp, (char *)&volStat, sizeof(AFSFetchVolumeStatus));
 786     cp += sizeof(AFSFetchVolumeStatus);
 787     StringCbCopyA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), volName);
 788     cp += strlen(volName)+1;
 789     StringCbCopyA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), offLineMsg);
 790     cp += strlen(offLineMsg)+1;
 791     StringCbCopyA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), motd);
 792     cp += strlen(motd)+1;
 793
 794     /* return new size */
 795     ioctlp->outDatap = cp;
 796
 797     return 0;
 798 }
 799
 800 /*
 801  * VIOCGETFID internals.
 802  *
 803  * Assumes that pioctl path has been parsed or skipped.
 804  * scp is held but not locked.
 805  */
 806 afs_int32
 807 cm_IoctlGetFid(struct cm_ioctl *ioctlp, struct cm_user *userp, cm_scache_t *scp, cm_req_t *reqp)
 808 {
 809     char *cp;
 810     cm_fid_t fid;
 811
 812     memset(&fid, 0, sizeof(cm_fid_t));
 813     fid.cell   = scp->fid.cell;
 814     fid.volume = scp->fid.volume;
 815     fid.vnode  = scp->fid.vnode;
 816     fid.unique = scp->fid.unique;
 817
 818     /* Copy all this junk into msg->im_data, keeping track of the lengths. */
 819     cp = ioctlp->outDatap;
 820     memcpy(cp, (char *)&fid, sizeof(cm_fid_t));
 821     cp += sizeof(cm_fid_t);
 822
 823     /* return new size */
 824     ioctlp->outDatap = cp;
 825
 826     return 0;
 827 }
 828
 829 /*
 830  * VIOC_GETFILETYPE internals.
 831  *
 832  * Assumes that pioctl path has been parsed or skipped.
 833  * scp is held but not locked.
 834  */
 835 afs_int32
 836 cm_IoctlGetFileType(struct cm_ioctl *ioctlp, struct cm_user *userp, cm_scache_t *scp, cm_req_t *reqp)
 837 {
 838     afs_int32 code = 0;
 839     char *cp;
 840     afs_uint32 fileType = 0;
 841
 842     if (scp->fileType == 0) {
 843         lock_ObtainWrite(&scp->rw);
 844         code = cm_SyncOp(scp, NULL, userp, reqp, 0,
 845                          CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
 846         if (code == 0)
 847             cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
 848         lock_ReleaseWrite(&scp->rw);
 849     }
 850
 851     if (code == 0) {
 852         fileType = scp->fileType;
 853
 854         /* Copy all this junk into msg->im_data, keeping track of the lengths. */
 855         cp = ioctlp->outDatap;
 856         memcpy(cp, (char *)&fileType, sizeof(fileType));
 857         cp += sizeof(fileType);
 858
 859         /* return new size */
 860         ioctlp->outDatap = cp;
 861     }
 862     return code;
 863 }
 864
 865 /*
 866  * VIOCGETOWNER internals.
 867  *
 868  * Assumes that pioctl path has been parsed or skipped.
 869  * scp is held but not locked.
 870  */
 871 afs_int32
 872 cm_IoctlGetOwner(struct cm_ioctl *ioctlp, struct cm_user *userp, cm_scache_t *scp, cm_req_t *reqp)
 873 {
 874     afs_int32 code = 0;
 875     char *cp;
 876
 877     lock_ObtainWrite(&scp->rw);
 878     code = cm_SyncOp(scp, NULL, userp, reqp, 0,
 879                       CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
 880     if (code == 0)
 881         cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
 882     lock_ReleaseWrite(&scp->rw);
 883
 884     if (code == 0) {
 885         /* Copy all this junk into msg->im_data, keeping track of the lengths. */
 886         cp = ioctlp->outDatap;
 887         memcpy(cp, (char *)&scp->owner, sizeof(afs_uint32));
 888         cp += sizeof(afs_uint32);
 889         memcpy(cp, (char *)&scp->group, sizeof(afs_uint32));
 890         cp += sizeof(afs_uint32);
 891
 892         /* return new size */
 893         ioctlp->outDatap = cp;
 894     }
 895     return code;
 896 }
 897
 898
 899 /*
 900  * VIOCWHEREIS internals.
 901  *
 902  * Assumes that pioctl path has been parsed or skipped.
 903  * scp is held but not locked.
 904  */
 905 afs_int32
 906 cm_IoctlWhereIs(struct cm_ioctl *ioctlp, struct cm_user *userp, cm_scache_t *scp, cm_req_t *reqp)
 907 {
 908     afs_int32 code;
 909     cm_cell_t *cellp;
 910     cm_volume_t *tvp;
 911     cm_serverRef_t **tsrpp, *current;
 912     cm_server_t *tsp;
 913     afs_uint32 volume;
 914     char *cp;
 915
 916     volume = scp->fid.volume;
 917
 918     cellp = cm_FindCellByID(scp->fid.cell, 0);
 919
 920     if (!cellp)
 921         return CM_ERROR_NOSUCHCELL;
 922
 923 #ifdef AFS_FREELANCE_CLIENT
 924     if ( cellp->cellID == AFS_FAKE_ROOT_CELL_ID) {
 925         struct in_addr addr;
 926
 927         addr.s_net = 127;
 928         addr.s_host = 0;
 929         addr.s_lh = 0;
 930         addr.s_impno = 1;
 931
 932         cp = ioctlp->outDatap;
 933
 934         memcpy(cp, (char *)&addr, sizeof(addr));
 935         cp += sizeof(addr);
 936
 937         /* still room for terminating NULL, add it on */
 938         addr.s_addr = 0;
 939         memcpy(cp, (char *)&addr, sizeof(addr));
 940         cp += sizeof(addr);
 941
 942         ioctlp->outDatap = cp;
 943     } else
 944 #endif
 945     {
 946         code = cm_FindVolumeByID(cellp, volume, userp, reqp, CM_GETVOL_FLAG_CREATE, &tvp);
 947         if (code)
 948             return code;
 949
 950         cp = ioctlp->outDatap;
 951
 952         tsrpp = cm_GetVolServers(tvp, volume);
 953         lock_ObtainRead(&cm_serverLock);
 954         for (current = *tsrpp; current; current = current->next) {
 955             tsp = current->server;
 956             memcpy(cp, (char *)&tsp->addr.sin_addr.s_addr, sizeof(long));
 957             cp += sizeof(long);
 958         }
 959         lock_ReleaseRead(&cm_serverLock);
 960         cm_FreeServerList(tsrpp, 0);
 961
 962         /* still room for terminating NULL, add it on */
 963         volume = 0;     /* reuse vbl */
 964         memcpy(cp, (char *)&volume, sizeof(long));
 965         cp += sizeof(long);
 966
 967         ioctlp->outDatap = cp;
 968         cm_PutVolume(tvp);
 969     }
 970     return 0;
 971 }
 972
 973 /*
 974  * VIOC_AFS_STAT_MT_PT internals.
 975  *
 976  * Assumes that pioctl path has been parsed or skipped.
 977  * scp is held but not locked.
 978  */
 979 afs_int32
 980 cm_IoctlStatMountPoint(struct cm_ioctl *ioctlp, struct cm_user *userp, cm_scache_t *dscp, cm_req_t *reqp)
 981 {
 982     afs_int32 code;
 983     cm_scache_t *scp;
 984     clientchar_t *cp;
 985
 986     cp = cm_ParseIoctlStringAlloc(ioctlp, NULL);
 987     code = cm_Lookup(dscp, cp, CM_FLAG_NOMOUNTCHASE, userp, reqp, &scp);
 988     if (code)
 989         goto done_2;
 990
 991     lock_ObtainWrite(&scp->rw);
 992     code = cm_SyncOp(scp, NULL, userp, reqp, 0,
 993                       CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
 994     if (code == 0)
 995         cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
 996     else
 997         goto done;
 998
 999     /* now check that this is a real mount point */
1000     if (scp->fileType != CM_SCACHETYPE_MOUNTPOINT) {
1001         code = CM_ERROR_INVAL;
1002         goto done;
1003     }
1004
1005     code = cm_ReadMountPoint(scp, userp, reqp);
1006     if (code == 0) {
1007         char * strp;
1008         strp = ioctlp->outDatap;
1009         StringCbCopyA(strp, SMB_IOCTL_MAXDATA - (strp - ioctlp->outAllocp), scp->mountPointStringp);
1010         strp += strlen(strp) + 1;
1011         ioctlp->outDatap = strp;
1012     }
1013
1014   done:
1015     lock_ReleaseWrite(&scp->rw);
1016     cm_ReleaseSCache(scp);
1017
1018  done_2:
1019     if (cp)
1020         free(cp);
1021
1022     return code;
1023 }
1024
1025 /*
1026  * VIOC_AFS_DELETE_MT_PT internals.
1027  *
1028  * Assumes that pioctl path has been parsed or skipped.
1029  * scp is held but not locked.
1030  */
1031 afs_int32
1032 cm_IoctlDeleteMountPoint(struct cm_ioctl *ioctlp, struct cm_user *userp, cm_scache_t *dscp, cm_req_t *reqp)
1033 {
1034     afs_int32 code;
1035     cm_scache_t *scp;
1036     clientchar_t *cp = NULL;
1037     fschar_t *originalName = NULL;
1038     cm_dirOp_t dirop;
1039
1040     cp = cm_ParseIoctlStringAlloc(ioctlp, NULL);
1041
1042     code = cm_Lookup(dscp, cp, CM_FLAG_NOMOUNTCHASE, userp, reqp, &scp);
1043
1044     /* if something went wrong, bail out now */
1045     if (code)
1046         goto done3;
1047
1048     lock_ObtainWrite(&scp->rw);
1049     code = cm_SyncOp(scp, NULL, userp, reqp, 0,
1050                      CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
1051     if (code)
1052         goto done2;
1053
1054     /* now check that this is a real mount point */
1055     if (scp->fileType != CM_SCACHETYPE_MOUNTPOINT) {
1056         code = CM_ERROR_INVAL;
1057         goto done1;
1058     }
1059
1060     /* time to make the RPC, so drop the lock */
1061     lock_ReleaseWrite(&scp->rw);
1062
1063 #ifdef USE_BPLUS
1064     code = cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_READ, &dirop);
1065     if (code == 0) {
1066         code = cm_BPlusDirLookupOriginalName(&dirop, cp, &originalName);
1067         /* The cm_Dir* functions can't be used to lookup the
1068            originalName.  Those functions only know of the original
1069            name. */
1070         cm_EndDirOp(&dirop);
1071     }
1072 #endif
1073
1074     /* If this name doesn't have a non-normalized name associated with
1075        it, we assume that what we had is what is actually present on
1076        the file server. */
1077
1078     if (originalName == NULL) {
1079         originalName = cm_ClientStringToFsStringAlloc(cp, -1, NULL);
1080     }
1081
1082     /* cp is a normalized name.  originalName is the actual name we
1083        saw on the fileserver. */
1084 #ifdef AFS_FREELANCE_CLIENT
1085     if (cm_freelanceEnabled && dscp == cm_data.rootSCachep) {
1086         /* we are removing the mount point to the root dir., so call
1087          * the freelance code to do the deletion. */
1088         osi_Log0(afsd_logp,"IoctlDeleteMountPoint from Freelance root dir");
1089         code = cm_FreelanceRemoveMount(originalName);
1090     } else
1091 #endif
1092     {
1093         /* easier to do it this way */
1094         code = cm_Unlink(dscp, originalName, cp, userp, reqp);
1095     }
1096     if (code == 0 && (dscp->flags & CM_SCACHEFLAG_ANYWATCH))
1097         smb_NotifyChange(FILE_ACTION_REMOVED,
1098                          FILE_NOTIFY_CHANGE_DIR_NAME,
1099                          dscp, cp, NULL, TRUE);
1100
1101     lock_ObtainWrite(&scp->rw);
1102   done1:
1103     cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
1104
1105   done2:
1106     cm_DiscardSCache(scp);
1107     lock_ReleaseWrite(&scp->rw);
1108     cm_ReleaseSCache(scp);
1109
1110   done3:
1111     if (originalName != NULL)
1112         free(originalName);
1113
1114     if (cp != NULL)
1115         free(cp);
1116
1117     return code;
1118 }
1119
1120 /*
1121  * VIOCCKSERV internals.
1122  *
1123  * Assumes that pioctl path has been parsed or skipped.
1124  */
1125 afs_int32
1126 cm_IoctlCheckServers(struct cm_ioctl *ioctlp, struct cm_user *userp)
1127 {
1128     cm_cell_t *cellp;
1129     chservinfo_t csi;
1130     char *tp;
1131     char *cp;
1132     long temp;
1133     cm_server_t *tsp;
1134     int haveCell;
1135
1136     tp = ioctlp->inDatap;
1137     haveCell = 0;
1138
1139     memcpy(&temp, tp, sizeof(temp));
1140     if (temp == 0x12345678) {   /* For afs3.3 version */
1141         memcpy(&csi, tp, sizeof(csi));
1142         if (csi.tinterval >= 0) {
1143             cp = ioctlp->outDatap;
1144             memcpy(cp, (char *)&cm_daemonCheckDownInterval, sizeof(long));
1145             ioctlp->outDatap += sizeof(long);
1146             if (csi.tinterval > 0) {
1147                 if (!smb_SUser(userp))
1148                     return CM_ERROR_NOACCESS;
1149                 cm_daemonCheckDownInterval = csi.tinterval;
1150             }
1151             return 0;
1152         }
1153         if (csi.tsize)
1154             haveCell = 1;
1155         temp = csi.tflags;
1156         cp = csi.tbuffer;
1157     } else {    /* For pre afs3.3 versions */
1158         memcpy((char *)&temp, ioctlp->inDatap, sizeof(long));
1159         ioctlp->inDatap = cp = ioctlp->inDatap + sizeof(long);
1160         if (cp - ioctlp->inAllocp < ioctlp->inCopied)   /* still more data available */
1161             haveCell = 1;
1162     }
1163
1164     /*
1165      * 1: fast check, don't contact servers.
1166      * 2: local cell only.
1167      */
1168     if (haveCell) {
1169         /* have cell name, too */
1170         cellp = cm_GetCell(cp, (temp & 1) ? CM_FLAG_NOPROBE : 0);
1171         if (!cellp)
1172             return CM_ERROR_NOSUCHCELL;
1173     }
1174     else
1175         cellp = (cm_cell_t *) 0;
1176     if (!cellp && (temp & 2)) {
1177         /* use local cell */
1178         fschar_t wscell[CELL_MAXNAMELEN+1];
1179         cm_GetRootCellName(wscell);
1180         cellp = cm_GetCell(wscell, 0);
1181     }
1182     if (!(temp & 1)) {  /* if not fast, call server checker routine */
1183         /* check down servers */
1184         cm_CheckServers(CM_FLAG_CHECKDOWNSERVERS | CM_FLAG_CHECKUPSERVERS, cellp);
1185     }
1186
1187     /* now return the current down server list */
1188     cp = ioctlp->outDatap;
1189     lock_ObtainRead(&cm_serverLock);
1190     for (tsp = cm_allServersp; tsp; tsp=tsp->allNextp) {
1191         if (cellp && tsp->cellp != cellp)
1192             continue;   /* cell spec'd and wrong */
1193         if ((tsp->flags & CM_SERVERFLAG_DOWN)
1194             && tsp->type == CM_SERVER_FILE) {
1195             memcpy(cp, (char *)&tsp->addr.sin_addr.s_addr, sizeof(long));
1196             cp += sizeof(long);
1197         }
1198     }
1199     lock_ReleaseRead(&cm_serverLock);
1200
1201     ioctlp->outDatap = cp;
1202     return 0;
1203 }
1204
1205 /*
1206  * VIOCCKBACK internals.
1207  *
1208  * Assumes that pioctl path has been parsed or skipped.
1209  */
1210 afs_int32
1211 cm_IoctlCheckVolumes(cm_ioctl_t *ioctlp, cm_user_t *userp)
1212 {
1213     cm_RefreshVolumes();
1214     return 0;
1215 }
1216
1217 /*
1218  * VIOCSETCACHESIZE internals.
1219  *
1220  * Assumes that pioctl path has been parsed or skipped.
1221  *
1222  * This function is no longer meaningful in the current day world
1223  * of persistent caches.  The buf_SetNBuffers() function will
1224  * inevitably fail.
1225  */
1226 afs_int32
1227 cm_IoctlSetCacheSize(struct cm_ioctl *ioctlp, struct cm_user *userp)
1228 {
1229     afs_int32 code;
1230     afs_uint64 temp;
1231
1232     memcpy(&temp, ioctlp->inDatap, sizeof(temp));
1233     if (temp == 0)
1234         temp = cm_data.buf_nOrigBuffers;
1235     else {
1236         /* temp is in 1K units, convert to # of buffers */
1237         temp = temp / (cm_data.buf_blockSize / 1024);
1238     }
1239
1240     /* now adjust the cache size */
1241     code = buf_SetNBuffers(temp);
1242
1243     return code;
1244 }
1245
1246 /*
1247  * VIOC_TRACECTL internals.
1248  *
1249  * Assumes that pioctl path has been parsed or skipped.
1250  */
1251 afs_int32
1252 cm_IoctlTraceControl(cm_ioctl_t *ioctlp, cm_user_t *userp)
1253 {
1254     afs_uint32 inValue;
1255
1256     memcpy(&inValue, ioctlp->inDatap, sizeof(afs_uint32));
1257
1258     /* print trace */
1259     if (inValue & 8) {
1260         afsd_ForceTrace(FALSE);
1261         buf_ForceTrace(FALSE);
1262     }
1263
1264     if (inValue & 2) {
1265         /* set tracing value to low order bit */
1266         if ((inValue & 1) == 0) {
1267             /* disable tracing */
1268             osi_LogDisable(afsd_logp);
1269             rx_DebugOnOff(FALSE);
1270         }
1271         else {
1272             /* enable tracing */
1273             osi_LogEnable(afsd_logp);
1274             rx_DebugOnOff(TRUE);
1275         }
1276     }
1277
1278     /* see if we're supposed to do a reset, too */
1279     if (inValue & 4) {
1280         osi_LogReset(afsd_logp);
1281     }
1282
1283     /* and copy out tracing flag */
1284     inValue = afsd_logp->enabled;       /* use as a temp vbl */
1285     memcpy(ioctlp->outDatap, &inValue, sizeof(afs_uint32));
1286     ioctlp->outDatap += sizeof(afs_uint32);
1287     return 0;
1288 }
1289
1290 /*
1291  * VIOCGETCACHEPARMS internals.
1292  *
1293  * Assumes that pioctl path has been parsed or skipped.
1294  */
1295 afs_int32
1296 cm_IoctlGetCacheParms(struct cm_ioctl *ioctlp, struct cm_user *userp)
1297 {
1298     cm_cacheParms_t parms;
1299
1300     memset(&parms, 0, sizeof(parms));
1301
1302     /* first we get, in 1K units, the cache size */
1303     parms.parms[0] = cm_data.buf_nbuffers * (cm_data.buf_blockSize / 1024);
1304
1305     /* and then the actual # of buffers in use (not in the free list, I guess,
1306      * will be what we do).
1307      */
1308     parms.parms[1] = (cm_data.buf_nbuffers - buf_CountFreeList()) * (cm_data.buf_blockSize / 1024);
1309
1310     memcpy(ioctlp->outDatap, &parms, sizeof(parms));
1311     ioctlp->outDatap += sizeof(parms);
1312
1313     return 0;
1314 }
1315
1316 /*
1317  * VIOCGETCELL internals.
1318  *
1319  * Assumes that pioctl path has been parsed or skipped.
1320  */
1321 afs_int32
1322 cm_IoctlGetCell(struct cm_ioctl *ioctlp, struct cm_user *userp)
1323 {
1324     long whichCell;
1325     long magic = 0;
1326     cm_cell_t *tcellp;
1327     cm_serverRef_t *serverRefp;
1328     cm_server_t *serverp;
1329     long i;
1330     char *cp;
1331     char *tp;
1332     char *basep;
1333
1334     tp = ioctlp->inDatap;
1335
1336     memcpy((char *)&whichCell, tp, sizeof(long));
1337     tp += sizeof(long);
1338
1339     /* see if more than one long passed in, ignoring the null pathname (the -1) */
1340     if (ioctlp->inCopied-1 > sizeof(afs_uint32)) {
1341         memcpy((char *)&magic, tp, sizeof(afs_uint32));
1342     }
1343
1344     lock_ObtainRead(&cm_cellLock);
1345     for (tcellp = cm_data.allCellsp; tcellp; tcellp = tcellp->allNextp) {
1346         if (whichCell == 0)
1347             break;
1348         whichCell--;
1349     }
1350     lock_ReleaseRead(&cm_cellLock);
1351     if (tcellp) {
1352         int max = 8;
1353         clientchar_t * cellnamep;
1354
1355         cp = ioctlp->outDatap;
1356
1357         if (magic == 0x12345678) {
1358             memcpy(cp, (char *)&magic, sizeof(long));
1359             max = 13;
1360         }
1361         memset(cp, 0, max * sizeof(long));
1362         basep = cp;
1363         lock_ObtainRead(&cm_serverLock);        /* for going down server list */
1364         for (i=0, serverRefp = tcellp->vlServersp;
1365              serverRefp && i<max;
1366              i++, serverRefp = serverRefp->next) {
1367             serverp = serverRefp->server;
1368             memcpy(cp, &serverp->addr.sin_addr.s_addr, sizeof(long));
1369             cp += sizeof(long);
1370         }
1371         lock_ReleaseRead(&cm_serverLock);
1372         ioctlp->outDatap = basep + max * sizeof(afs_int32);
1373
1374         cellnamep = cm_FsStringToClientStringAlloc(tcellp->name, -1, NULL);
1375         cm_UnparseIoctlString(ioctlp, NULL, cellnamep, -1);
1376         free(cellnamep);
1377     }
1378
1379     if (tcellp)
1380         return 0;
1381     else
1382         return CM_ERROR_NOMORETOKENS;   /* mapped to EDOM */
1383 }
1384
1385
1386 /*
1387  * VIOCNEWCELL internals.
1388  *
1389  * Assumes that pioctl path has been parsed or skipped.
1390  */
1391 afs_int32
1392 cm_IoctlNewCell(struct cm_ioctl *ioctlp, struct cm_user *userp)
1393 {
1394     /*
1395      * All that needs to be done is to refresh server information for all cells that
1396      * are already loaded.
1397
1398      * cell list will be cm_CellLock and cm_ServerLock will be held for write.
1399      */
1400
1401     cm_cell_t *cp;
1402     cm_cell_rock_t rock;
1403
1404     lock_ObtainWrite(&cm_cellLock);
1405
1406     for (cp = cm_data.allCellsp; cp; cp=cp->allNextp)
1407     {
1408         afs_int32 code;
1409         lock_ObtainMutex(&cp->mx);
1410         /* delete all previous server lists - cm_FreeServerList will ask for write on cm_ServerLock*/
1411         cm_FreeServerList(&cp->vlServersp, CM_FREESERVERLIST_DELETE);
1412         cp->vlServersp = NULL;
1413         rock.cellp = cp;
1414         rock.flags = 0;
1415         code = cm_SearchCellFile(cp->name, cp->name, cm_AddCellProc, &rock);
1416 #ifdef AFS_AFSDB_ENV
1417         if (code) {
1418             if (cm_dnsEnabled) {
1419                 int ttl;
1420                 code = cm_SearchCellByDNS(cp->name, cp->name, &ttl, cm_AddCellProc, &rock);
1421                 if ( code == 0 ) { /* got cell from DNS */
1422                     cp->flags |= CM_CELLFLAG_DNS;
1423                     cp->flags &= ~CM_CELLFLAG_VLSERVER_INVALID;
1424                     cp->timeout = time(0) + ttl;
1425                 }
1426             }
1427         }
1428         else {
1429             cp->flags &= ~CM_CELLFLAG_DNS;
1430         }
1431 #endif /* AFS_AFSDB_ENV */
1432         if (code) {
1433             cp->flags |= CM_CELLFLAG_VLSERVER_INVALID;
1434         }
1435         else {
1436             cp->flags &= ~CM_CELLFLAG_VLSERVER_INVALID;
1437             cm_RandomizeServer(&cp->vlServersp);
1438         }
1439         lock_ReleaseMutex(&cp->mx);
1440     }
1441
1442     lock_ReleaseWrite(&cm_cellLock);
1443     return 0;
1444 }
1445
1446 /*
1447  * VIOC_GET_WS_CELL internals.
1448  *
1449  * Assumes that pioctl path has been parsed or skipped.
1450  */
1451 afs_int32
1452 cm_IoctlGetWsCell(cm_ioctl_t *ioctlp, cm_user_t *userp)
1453 {
1454     afs_int32 code = 0;
1455
1456     if (cm_freelanceEnabled) {
1457         if (cm_GetRootCellName(ioctlp->outDatap))
1458             StringCbCopyA(ioctlp->outDatap, SMB_IOCTL_MAXDATA - (ioctlp->outDatap - ioctlp->outAllocp), "Freelance.Local.Root");
1459         ioctlp->outDatap += strlen(ioctlp->outDatap) +1;
1460     } else if (cm_data.rootCellp) {
1461         clientchar_t * cellnamep = cm_FsStringToClientStringAlloc(cm_data.rootCellp->name, -1, NULL);
1462         /* return the default cellname to the caller */
1463         cm_UnparseIoctlString(ioctlp, NULL, cellnamep, -1);
1464         free(cellnamep);
1465     } else {
1466         /* if we don't know our default cell, return failure */
1467         code = CM_ERROR_NOSUCHCELL;
1468     }
1469
1470     return code;
1471 }
1472
1473 /*
1474  * VIOC_AFS_SYSNAME internals.
1475  *
1476  * Assumes that pioctl path has been parsed or skipped.
1477  */
1478 afs_int32
1479 cm_IoctlSysName(struct cm_ioctl *ioctlp, struct cm_user *userp)
1480 {
1481     afs_uint32 setSysName;
1482     char *cp, *cp2;
1483     clientchar_t *inname = NULL;
1484     int t, count;
1485
1486     memcpy(&setSysName, ioctlp->inDatap, sizeof(afs_uint32));
1487     ioctlp->inDatap += sizeof(afs_uint32);
1488
1489     if (setSysName) {
1490         /* check my args */
1491         if ( setSysName < 0 || setSysName > MAXNUMSYSNAMES )
1492             return EINVAL;
1493         cp2 = ioctlp->inDatap;
1494         for ( cp=ioctlp->inDatap, count = 0; count < setSysName; count++ ) {
1495             /* won't go past end of ioctlp->inDatap since
1496                maxsysname*num < ioctlp->inDatap length */
1497             t = (int)strlen(cp);
1498             if (t >= MAXSYSNAME || t <= 0)
1499                 return EINVAL;
1500             /* check for names that can shoot us in the foot */
1501             if (*cp == '.' && (cp[1] == 0 || (cp[1] == '.' && cp[2] == 0)))
1502                 return EINVAL;
1503             cp += t + 1;
1504         }
1505         /* args ok */
1506
1507         /* inname gets first entry in case we're being a translator */
1508         /* (we are never a translator) */
1509         inname = cm_ParseIoctlStringAlloc(ioctlp, NULL);
1510     }
1511
1512     /* Not xlating, so local case */
1513     if (!cm_sysName)
1514         osi_panic("cm_IoctlSysName: !cm_sysName\n", __FILE__, __LINE__);
1515
1516     if (setSysName) {
1517         /* Local guy; only root can change sysname */
1518         /* clear @sys entries from the dnlc, once afs_lookup can
1519          * do lookups of @sys entries and thinks it can trust them */
1520         /* privs ok, store the entry, ... */
1521
1522         cm_ClientStrCpy(cm_sysName, lengthof(cm_sysName), inname);
1523         cm_ClientStrCpy(cm_sysNameList[0], MAXSYSNAME, inname);
1524
1525         if (setSysName > 1) {       /* ... or list */
1526             for (count = 1; count < setSysName; ++count) {
1527                 clientchar_t * newsysname;
1528
1529                 if (!cm_sysNameList[count])
1530                     osi_panic("cm_IoctlSysName: no cm_sysNameList entry to write\n",
1531                               __FILE__, __LINE__);
1532
1533                 newsysname = cm_ParseIoctlStringAlloc(ioctlp, NULL);
1534                 cm_ClientStrCpy(cm_sysNameList[count], MAXSYSNAME, newsysname);
1535                 free(newsysname);
1536             }
1537         }
1538         cm_sysNameCount = setSysName;
1539     } else {
1540         afs_int32 i32;
1541
1542         /* return the sysname to the caller */
1543         i32 = cm_sysNameCount;
1544         memcpy(ioctlp->outDatap, &i32, sizeof(afs_int32));
1545         ioctlp->outDatap += sizeof(afs_int32);  /* skip found flag */
1546
1547         if (cm_sysNameCount) {
1548             for ( count=0; count < cm_sysNameCount ; ++count) {   /* ... or list */
1549                 if ( !cm_sysNameList[count] || *cm_sysNameList[count] == _C('\0'))
1550                     osi_panic("cm_IoctlSysName: no cm_sysNameList entry to read\n",
1551                               __FILE__, __LINE__);
1552                 cm_UnparseIoctlString(ioctlp, NULL, cm_sysNameList[count], -1);
1553             }
1554         }
1555     }
1556
1557     if (inname) {
1558         free(inname);
1559         inname = NULL;
1560     }
1561
1562     /* done: success */
1563     return 0;
1564 }
1565
1566 /*
1567  * VIOC_GETCELLSTATUS internals.
1568  *
1569  * Assumes that pioctl path has been parsed or skipped.
1570  */
1571 afs_int32
1572 cm_IoctlGetCellStatus(struct cm_ioctl *ioctlp, struct cm_user *userp)
1573 {
1574     afs_uint32 temp;
1575     cm_cell_t *cellp;
1576     clientchar_t * cellnamep;
1577     fschar_t     * fscellnamep;
1578
1579     cellnamep = cm_ParseIoctlStringAlloc(ioctlp, NULL);
1580     fscellnamep = cm_ClientStringToFsStringAlloc(cellnamep, -1, NULL);
1581     cellp = cm_GetCell(fscellnamep, 0);
1582     free(fscellnamep);
1583     free(cellnamep);
1584
1585     if (!cellp)
1586         return CM_ERROR_NOSUCHCELL;
1587
1588     temp = 0;
1589     lock_ObtainMutex(&cellp->mx);
1590     if (cellp->flags & CM_CELLFLAG_SUID)
1591         temp |= CM_SETCELLFLAG_SUID;
1592     lock_ReleaseMutex(&cellp->mx);
1593
1594     /* now copy out parm */
1595     memcpy(ioctlp->outDatap, &temp, sizeof(afs_uint32));
1596     ioctlp->outDatap += sizeof(afs_uint32);
1597
1598     return 0;
1599 }
1600
1601 /*
1602  * VIOC_SETCELLSTATUS internals.
1603  *
1604  * Assumes that pioctl path has been parsed or skipped.
1605  */
1606 afs_int32
1607 cm_IoctlSetCellStatus(struct cm_ioctl *ioctlp, struct cm_user *userp)
1608 {
1609     afs_uint32 flags;
1610     cm_cell_t *cellp;
1611     clientchar_t *temp;
1612     fschar_t * cellnamep;
1613
1614     temp = cm_ParseIoctlStringAlloc(ioctlp, ioctlp->inDatap + 2*sizeof(afs_uint32));
1615     cellnamep = cm_ClientStringToFsStringAlloc(temp, -1, NULL);
1616     cellp = cm_GetCell(cellnamep, 0);
1617     free(temp);
1618     free(cellnamep);
1619
1620     if (!cellp)
1621         return CM_ERROR_NOSUCHCELL;
1622
1623     memcpy((char *)&flags, ioctlp->inDatap, sizeof(afs_uint32));
1624
1625     lock_ObtainMutex(&cellp->mx);
1626     if (flags & CM_SETCELLFLAG_SUID)
1627         cellp->flags |= CM_CELLFLAG_SUID;
1628     else
1629         cellp->flags &= ~CM_CELLFLAG_SUID;
1630     lock_ReleaseMutex(&cellp->mx);
1631
1632     return 0;
1633 }
1634
1635 /*
1636  * VIOC_SETSPREFS internals.
1637  *
1638  * Assumes that pioctl path has been parsed or skipped.
1639  */
1640 afs_int32
1641 cm_IoctlSetSPrefs(struct cm_ioctl *ioctlp, struct cm_user *userp)
1642 {
1643     cm_SSetPref_t     *spin;    /* input */
1644     cm_SPref_t        *srvin;   /* one input component */
1645     cm_server_t       *tsp;
1646     int                i, vlonly, noServers, type;
1647     struct sockaddr_in tmp;
1648     unsigned short     rank;
1649
1650     spin           = (cm_SSetPref_t *)ioctlp->inDatap;
1651     noServers  = spin->num_servers;
1652     vlonly     = spin->flags;
1653     if ( vlonly )
1654         type = CM_SERVER_VLDB;
1655     else
1656         type = CM_SERVER_FILE;
1657
1658     for ( i=0; i < noServers; i++)
1659     {
1660         srvin          = &(spin->servers[i]);
1661         rank           = srvin->rank + (rand() & 0x000f);
1662         tmp.sin_addr   = srvin->host;
1663         tmp.sin_family = AF_INET;
1664
1665         tsp = cm_FindServer(&tmp, type);
1666         if ( tsp )              /* an existing server - ref count increased */
1667         {
1668             tsp->ipRank = rank; /* no need to protect by mutex*/
1669
1670             if (type == CM_SERVER_FILE)
1671             {   /* fileserver */
1672                 /* find volumes which might have RO copy
1673                 /* on server and change the ordering of
1674                  * their RO list
1675                  */
1676                 cm_ChangeRankVolume(tsp);
1677             }
1678             else
1679             {
1680                 /* set preferences for an existing vlserver */
1681                 cm_ChangeRankCellVLServer(tsp);
1682             }
1683         }
1684         else    /* add a new server without a cell */
1685         {
1686             tsp = cm_NewServer(&tmp, type, NULL, CM_FLAG_NOPROBE); /* refcount = 1 */
1687             tsp->ipRank = rank;
1688         }
1689         lock_ObtainMutex(&tsp->mx);
1690         tsp->flags |= CM_SERVERFLAG_PREF_SET;
1691         lock_ReleaseMutex(&tsp->mx);
1692         cm_PutServer(tsp);  /* decrease refcount */
1693     }
1694     return 0;
1695 }
1696
1697 /*
1698  * VIOC_GETSPREFS internals.
1699  *
1700  * Assumes that pioctl path has been parsed or skipped.
1701  */
1702 afs_int32
1703 cm_IoctlGetSPrefs(struct cm_ioctl *ioctlp, struct cm_user *userp)
1704 {
1705     cm_SPrefRequest_t *spin; /* input */
1706     cm_SPrefInfo_t    *spout;   /* output */
1707     cm_SPref_t        *srvout;   /* one output component */
1708     cm_server_t       *tsp;
1709     int                   i, vlonly, noServers;
1710
1711     spin      = (cm_SPrefRequest_t *)ioctlp->inDatap;
1712     spout     = (cm_SPrefInfo_t *) ioctlp->outDatap;
1713     srvout    = spout->servers;
1714     noServers = spin->num_servers;
1715     vlonly    = spin->flags & CM_SPREF_VLONLY;
1716     spout->num_servers = 0;
1717
1718     lock_ObtainRead(&cm_serverLock); /* get server lock */
1719
1720     for (tsp=cm_allServersp, i=0; tsp && noServers; tsp=tsp->allNextp,i++){
1721         if (spin->offset > i) {
1722             continue;    /* catch up to where we left off */
1723         }
1724
1725         if ( vlonly && (tsp->type == CM_SERVER_FILE) )
1726             continue;   /* ignore fileserver for -vlserver option*/
1727         if ( !vlonly && (tsp->type == CM_SERVER_VLDB) )
1728             continue;   /* ignore vlservers */
1729
1730         srvout->host = tsp->addr.sin_addr;
1731         srvout->rank = tsp->ipRank;
1732         srvout++;
1733         spout->num_servers++;
1734         noServers--;
1735     }
1736     lock_ReleaseRead(&cm_serverLock); /* release server lock */
1737
1738     if ( tsp )  /* we ran out of space in the output buffer */
1739         spout->next_offset = i;
1740     else
1741         spout->next_offset = 0;
1742     ioctlp->outDatap += sizeof(cm_SPrefInfo_t) +
1743         (spout->num_servers -1 ) * sizeof(cm_SPref_t) ;
1744     return 0;
1745 }
1746
1747
1748 /*
1749  * VIOC_AFS_CREATE_MT_PT internals.
1750  *
1751  * Assumes that pioctl path has been parsed or skipped.
1752  * dscp is held but not locked.
1753  */
1754 afs_int32
1755 cm_IoctlCreateMountPoint(struct cm_ioctl *ioctlp, struct cm_user *userp, cm_scache_t *dscp, cm_req_t *reqp, clientchar_t *leaf)
1756 {
1757     afs_int32 code;
1758     cm_attr_t tattr;
1759     clientchar_t *cp;
1760     fschar_t mpInfo[512];           /* mount point string */
1761     fschar_t fullCell[CELL_MAXNAMELEN];
1762     fschar_t *fscell = NULL;
1763     fschar_t *fsvolume = NULL;
1764     clientchar_t volume[VL_MAXNAMELEN];
1765     clientchar_t *mpp = NULL;
1766     clientchar_t *cell = NULL;
1767     cm_volume_t *volp = NULL;
1768     cm_cell_t *cellp = NULL;
1769     size_t len;
1770
1771    /*
1772      * The fs command allows the user to specify partial cell names on NT.  These must
1773      * be expanded to the full cell name for mount points so that the mount points will
1774      * work on UNIX clients.
1775      */
1776
1777     /* Extract the possibly partial cell name */
1778     mpp = cm_ParseIoctlStringAlloc(ioctlp, NULL);
1779     cell = cm_ClientCharNext(mpp);
1780     if (cp = cm_ClientStrChr(cell, ':')) {
1781
1782         /* Extract the volume name */
1783         *cp = 0;
1784         cm_ClientStrCpy(volume, lengthof(volume), cm_ClientCharNext(cp));
1785
1786         fscell = cm_ClientStringToFsStringAlloc(cell, -1, NULL);
1787         fsvolume = cm_ClientStringToFsStringAlloc(volume, -1, NULL);
1788
1789         /* Get the full name for this cell */
1790         cellp = cm_GetCell_Gen(fscell, fullCell, CM_FLAG_NOPROBE);
1791         if (!cellp) {
1792             code = CM_ERROR_NOSUCHCELL;
1793             goto done;
1794         }
1795
1796         StringCbPrintfA(mpInfo, sizeof(mpInfo), "%c%s:%s", (char) *mpp,
1797                         fullCell, fsvolume);
1798
1799     } else {
1800         /* No cell name specified, so cell points at the volume instead. */
1801         fsvolume = cm_ClientStringToFsStringAlloc(cell, -1, NULL);
1802         cm_ClientStringToFsString(mpp, -1, mpInfo, lengthof(mpInfo));
1803         cellp = cm_FindCellByID(dscp->fid.cell, CM_FLAG_NOPROBE);
1804     }
1805
1806     /* remove the trailing dot if it is present */
1807     len = strlen(fsvolume);
1808     if (len > 1 && fsvolume[len-1] == '.')
1809         fsvolume[len-1] = '\0';
1810
1811     /* validate the target info */
1812     if (cm_VolNameIsID(fsvolume)) {
1813         code = cm_FindVolumeByID(cellp, atoi(fsvolume), userp, reqp,
1814                                 CM_GETVOL_FLAG_CREATE, &volp);
1815     } else {
1816         code = cm_FindVolumeByName(cellp, fsvolume, userp, reqp,
1817                                   CM_GETVOL_FLAG_CREATE, &volp);
1818     }
1819     if (code)
1820         goto done;
1821
1822 #ifdef AFS_FREELANCE_CLIENT
1823     if (cm_freelanceEnabled && dscp == cm_data.rootSCachep) {
1824         /* we are adding the mount point to the root dir, so call
1825          * the freelance code to do the add. */
1826         fschar_t * fsleaf = cm_ClientStringToFsStringAlloc(leaf, -1, NULL);
1827         osi_Log0(afsd_logp,"IoctlCreateMountPoint within Freelance root dir");
1828         code = cm_FreelanceAddMount(fsleaf, fullCell, fsvolume, *mpInfo == '%', NULL);
1829         free(fsleaf);
1830     } else
1831 #endif
1832     {
1833         /* create the symlink with mode 644.  The lack of X bits tells
1834          * us that it is a mount point.
1835          */
1836         tattr.mask = CM_ATTRMASK_UNIXMODEBITS | CM_ATTRMASK_CLIENTMODTIME;
1837         tattr.unixModeBits = 0644;
1838         tattr.clientModTime = time(NULL);
1839
1840         code = cm_SymLink(dscp, leaf, mpInfo, 0, &tattr, userp, reqp);
1841     }
1842
1843     if (code == 0 && (dscp->flags & CM_SCACHEFLAG_ANYWATCH))
1844         smb_NotifyChange(FILE_ACTION_ADDED,
1845                          FILE_NOTIFY_CHANGE_DIR_NAME,
1846                          dscp, leaf, NULL, TRUE);
1847
1848   done:
1849     if (volp)
1850         cm_PutVolume(volp);
1851     if (mpp)
1852         free(mpp);
1853     if (fscell)
1854         free(fscell);
1855     if (fsvolume)
1856         free(fsvolume);
1857
1858     return code;
1859 }
1860
1861 /*
1862  * VIOC_SYMLINK internals.
1863  *
1864  * Assumes that pioctl path has been parsed or skipped.
1865  * dscp is held but not locked.
1866  */
1867 afs_int32
1868 cm_IoctlSymlink(struct cm_ioctl *ioctlp, struct cm_user *userp, cm_scache_t *dscp, cm_req_t *reqp, clientchar_t *leaf)
1869 {
1870     afs_int32 code;
1871     cm_attr_t tattr;
1872     char *cp;
1873     char *symlp;
1874     int free_syml = FALSE;
1875
1876     if (!(ioctlp->flags & CM_IOCTLFLAG_USEUTF8)) {
1877         /* Translate chars for the linked to name */
1878         TranslateExtendedChars(ioctlp->inDatap);
1879     }
1880
1881     cp = symlp = ioctlp->inDatap;               /* contents of link */
1882
1883 #ifdef AFS_FREELANCE_CLIENT
1884     if (cm_freelanceEnabled && dscp == cm_data.rootSCachep) {
1885         /* we are adding the symlink to the root dir., so call
1886          * the freelance code to do the add. */
1887         fschar_t *fsleaf;
1888
1889         if (cp[0] == cp[1] && cp[1] == '\\' &&
1890             !_strnicmp(cm_NetbiosName,cp+2,strlen(cm_NetbiosName)))
1891         {
1892             /* skip \\AFS\ or \\AFS\all\ */
1893             char * p;
1894             p = cp + 2 + strlen(cm_NetbiosName) + 1;
1895             if ( !_strnicmp("all", p, 3) )
1896                 p += 4;
1897             cp = p;
1898         }
1899
1900         osi_Log0(afsd_logp,"IoctlCreateSymlink within Freelance root dir");
1901         fsleaf = cm_ClientStringToFsStringAlloc(leaf, -1, NULL);
1902         code = cm_FreelanceAddSymlink(fsleaf, cp, NULL);
1903         free(fsleaf);
1904     } else
1905 #endif
1906     {
1907         /* Create symlink with mode 0755. */
1908         tattr.mask = CM_ATTRMASK_UNIXMODEBITS;
1909         tattr.unixModeBits = 0755;
1910
1911         code = cm_SymLink(dscp, leaf, cp, 0, &tattr, userp, reqp);
1912     }
1913
1914     if (code == 0 && (dscp->flags & CM_SCACHEFLAG_ANYWATCH))
1915         smb_NotifyChange(FILE_ACTION_ADDED,
1916                           FILE_NOTIFY_CHANGE_FILE_NAME
1917                           | FILE_NOTIFY_CHANGE_DIR_NAME,
1918                           dscp, leaf, NULL, TRUE);
1919     return code;
1920 }
1921
1922
1923 /*
1924  * VIOC_LISTSYMLINK internals.
1925  *
1926  * Assumes that pioctl path has been parsed or skipped.
1927  * dscp is held but not locked.
1928  */
1929 afs_int32
1930 cm_IoctlListlink(struct cm_ioctl *ioctlp, struct cm_user *userp, cm_scache_t *dscp, cm_req_t *reqp)
1931 {
1932     afs_int32 code;
1933     cm_scache_t *scp;
1934     char *cp;
1935     cm_space_t *spacep;
1936     cm_scache_t *newRootScp;
1937     clientchar_t *clientp;
1938
1939     if (!(ioctlp->flags & CM_IOCTLFLAG_USEUTF8)) {
1940         /* Translate chars for the link name */
1941         TranslateExtendedChars(ioctlp->inDatap);
1942     }
1943     cp = ioctlp->inDatap;
1944
1945     clientp = cm_Utf8ToClientStringAlloc(cp, -1, NULL);
1946     code = cm_Lookup(dscp, clientp, CM_FLAG_NOMOUNTCHASE, userp, reqp, &scp);
1947     free(clientp);
1948     if (code)
1949         return code;
1950
1951     /* Check that it's a real symlink */
1952     if (scp->fileType != CM_SCACHETYPE_SYMLINK &&
1953         scp->fileType != CM_SCACHETYPE_DFSLINK &&
1954         scp->fileType != CM_SCACHETYPE_INVALID) {
1955         cm_ReleaseSCache(scp);
1956         return CM_ERROR_INVAL;
1957     }
1958
1959     code = cm_AssembleLink(scp, "", &newRootScp, &spacep, userp, reqp);
1960     cm_ReleaseSCache(scp);
1961     if (code == 0) {
1962         char * linkstr;
1963         cp = ioctlp->outDatap;
1964         if (newRootScp != NULL) {
1965             StringCbCopyA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), cm_mountRoot);
1966             StringCbCatA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), "/");
1967             cp += strlen(cp);
1968         }
1969
1970         linkstr = cm_ClientStringToFsStringAlloc(spacep->wdata, -1, NULL);
1971         StringCbCopyA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), linkstr);
1972         cp += strlen(cp) + 1;
1973         ioctlp->outDatap = cp;
1974         cm_FreeSpace(spacep);
1975         free(linkstr);
1976         if (newRootScp != NULL)
1977             cm_ReleaseSCache(newRootScp);
1978         code = 0;
1979     } else if (code == CM_ERROR_PATH_NOT_COVERED &&
1980                 scp->fileType == CM_SCACHETYPE_DFSLINK ||
1981                code == CM_ERROR_NOSUCHPATH &&
1982                 scp->fileType == CM_SCACHETYPE_INVALID) {
1983
1984         cp = ioctlp->outDatap;
1985         StringCbCopyA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), scp->mountPointStringp);
1986         cp += strlen(cp) + 1;
1987         ioctlp->outDatap = cp;
1988         code = 0;
1989     }
1990
1991     return code;
1992 }
1993
1994 /*
1995  * VIOC_ISSYMLINK internals.
1996  *
1997  * Assumes that pioctl path has been parsed or skipped.
1998  * dscp is held but not locked.
1999  */
2000 afs_int32
2001 cm_IoctlIslink(struct cm_ioctl *ioctlp, struct cm_user *userp, cm_scache_t *dscp, cm_req_t *reqp)
2002 {/*CHECK FOR VALID SYMLINK*/
2003     afs_int32 code;
2004     cm_scache_t *scp;
2005     char *cp;
2006     clientchar_t *clientp;
2007
2008     if (!(ioctlp->flags & CM_IOCTLFLAG_USEUTF8)) {
2009         /* Translate chars for the link name */
2010         TranslateExtendedChars(ioctlp->inDatap);
2011     }
2012     cp = ioctlp->inDatap;
2013     osi_LogEvent("cm_IoctlListlink",NULL," name[%s]",cp);
2014
2015     clientp = cm_Utf8ToClientStringAlloc(cp, -1, NULL);
2016     code = cm_Lookup(dscp, clientp, CM_FLAG_NOMOUNTCHASE, userp, reqp, &scp);
2017     free(clientp);
2018     if (code)
2019         return code;
2020
2021     /* Check that it's a real symlink */
2022     if (scp->fileType != CM_SCACHETYPE_SYMLINK &&
2023         scp->fileType != CM_SCACHETYPE_DFSLINK &&
2024         scp->fileType != CM_SCACHETYPE_INVALID)
2025         code = CM_ERROR_INVAL;
2026     cm_ReleaseSCache(scp);
2027     return code;
2028 }
2029
2030 /*
2031  * VIOC_DELSYMLINK internals.
2032  *
2033  * Assumes that pioctl path has been parsed or skipped.
2034  * dscp is held but not locked.
2035  */
2036 afs_int32
2037 cm_IoctlDeletelink(struct cm_ioctl *ioctlp, struct cm_user *userp, cm_scache_t *dscp, cm_req_t *reqp)
2038 {
2039     afs_int32 code;
2040     cm_scache_t *scp;
2041     char *cp;
2042     char * originalName = NULL;
2043     cm_dirOp_t dirop;
2044     clientchar_t *clientp;
2045
2046     if (!(ioctlp->flags & CM_IOCTLFLAG_USEUTF8)) {
2047         /* Translate chars for the link name */
2048         TranslateExtendedChars(ioctlp->inDatap);
2049     }
2050     cp = ioctlp->inDatap;
2051
2052     clientp = cm_Utf8ToClientStringAlloc(cp, -1, NULL);
2053     code = cm_Lookup(dscp, clientp, CM_FLAG_NOMOUNTCHASE, userp, reqp, &scp);
2054
2055     /* if something went wrong, bail out now */
2056     if (code)
2057         goto done3;
2058
2059     lock_ObtainWrite(&scp->rw);
2060     code = cm_SyncOp(scp, NULL, userp, reqp, 0,
2061                       CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
2062     if (code)
2063         goto done2;
2064
2065     /* now check that this is a real symlink */
2066     if (scp->fileType != CM_SCACHETYPE_SYMLINK &&
2067         scp->fileType != CM_SCACHETYPE_DFSLINK &&
2068         scp->fileType != CM_SCACHETYPE_INVALID) {
2069         code = CM_ERROR_INVAL;
2070         goto done1;
2071     }
2072
2073     /* time to make the RPC, so drop the lock */
2074     lock_ReleaseWrite(&scp->rw);
2075
2076 #ifdef USE_BPLUS
2077     code = cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_READ, &dirop);
2078     if (code == 0) {
2079         code = cm_BPlusDirLookupOriginalName(&dirop, clientp, &originalName);
2080         /* cm_Dir*() functions can't be used to lookup the original
2081            name since those functions only know of the original
2082            name. */
2083         cm_EndDirOp(&dirop);
2084     }
2085 #endif
2086
2087     /* If this name doesn't have a non-normalized name associated with
2088        it, we assume that what we had is what is actually present on
2089        the file server. */
2090
2091     if (originalName == NULL)
2092         originalName = cp;
2093
2094     /* cp is a normalized name.  originalName is the actual name we
2095        saw on the fileserver. */
2096
2097
2098 #ifdef AFS_FREELANCE_CLIENT
2099     if (cm_freelanceEnabled && dscp == cm_data.rootSCachep) {
2100         /* we are adding the mount point to the root dir., so call
2101          * the freelance code to do the add. */
2102         osi_Log0(afsd_logp,"IoctlDeletelink from Freelance root dir");
2103         code = cm_FreelanceRemoveSymlink(originalName);
2104     } else
2105 #endif
2106     {
2107         /* easier to do it this way */
2108         code = cm_Unlink(dscp, originalName, clientp, userp, reqp);
2109     }
2110     if (code == 0 && (dscp->flags & CM_SCACHEFLAG_ANYWATCH))
2111         smb_NotifyChange(FILE_ACTION_REMOVED,
2112                           FILE_NOTIFY_CHANGE_FILE_NAME
2113                           | FILE_NOTIFY_CHANGE_DIR_NAME,
2114                           dscp, clientp, NULL, TRUE);
2115
2116     if (originalName != NULL && originalName != cp) {
2117         free(originalName);
2118         originalName = NULL;
2119     }
2120
2121     lock_ObtainWrite(&scp->rw);
2122   done1:
2123     cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
2124
2125   done2:
2126     cm_DiscardSCache(scp);
2127     lock_ReleaseWrite(&scp->rw);
2128     cm_ReleaseSCache(scp);
2129
2130   done3:
2131     free(clientp);
2132
2133     return code;
2134 }
2135
2136 #ifdef QUERY_AFSID
2137 /* Utility function.  Not currently used.
2138  * This function performs a PTS lookup which has traditionally
2139  * not been performed by the cache manager.
2140  */
2141 afs_int32
2142 cm_UsernameToId(char *uname, cm_ucell_t * ucellp, afs_uint32* uid)
2143 {
2144     afs_int32 code;
2145     namelist lnames;
2146     idlist lids;
2147     static struct afsconf_cell info;
2148     struct rx_connection *serverconns[MAXSERVERS];
2149     struct rx_securityClass *sc[3];
2150     afs_int32 scIndex = 2;      /* authenticated - we have a token */
2151     struct ubik_client *pruclient = NULL;
2152     struct afsconf_dir *tdir;
2153     int i;
2154     char * p, * r;
2155
2156     tdir = afsconf_Open(AFSDIR_CLIENT_ETC_DIRPATH);
2157     code = afsconf_GetCellInfo(tdir, ucellp->cellp->name, "afsprot", &info);
2158     afsconf_Close(tdir);
2159
2160     sc[0] = 0;
2161     sc[1] = 0;
2162     sc[2] = 0;
2163
2164     /* we have the token that was given to us in the settoken
2165      * call.   we just have to use it.
2166      */
2167     scIndex = 2;        /* kerberos ticket */
2168     sc[2] = rxkad_NewClientSecurityObject(rxkad_clear, &ucellp->sessionKey,
2169                                           ucellp->kvno, ucellp->ticketLen,
2170                                           ucellp->ticketp);
2171
2172     memset(serverconns, 0, sizeof(serverconns));        /* terminate list!!! */
2173     for (i = 0; i < info.numServers; i++)
2174         serverconns[i] =
2175             rx_NewConnection(info.hostAddr[i].sin_addr.s_addr,
2176                              info.hostAddr[i].sin_port, PRSRV, sc[scIndex],
2177                              scIndex);
2178
2179     code = ubik_ClientInit(serverconns, &pruclient);
2180     if (code) {
2181         return code;
2182     }
2183
2184     code = rxs_Release(sc[scIndex]);
2185
2186     lids.idlist_len = 0;
2187     lids.idlist_val = 0;
2188     lnames.namelist_len = 1;
2189     lnames.namelist_val = (prname *) malloc(PR_MAXNAMELEN);
2190     strncpy(lnames.namelist_val[0], uname, PR_MAXNAMELEN);
2191     lnames.namelist_val[0][PR_MAXNAMELEN-1] = '\0';
2192     for ( p=lnames.namelist_val[0], r=NULL; *p; p++ ) {
2193         if (isupper(*p))
2194             *p = tolower(*p);
2195         if (*p == '@')
2196             r = p;
2197     }
2198     if (r && !cm_stricmp_utf8(r+1,ucellp->cellp->name))
2199         *r = '\0';
2200
2201     code = ubik_PR_NameToID(pruclient, 0, &lnames, &lids);
2202     if (lids.idlist_val) {
2203         *uid = *lids.idlist_val;
2204         free(lids.idlist_val);
2205     }
2206     if (lnames.namelist_val)
2207         free(lnames.namelist_val);
2208
2209     if ( pruclient ) {
2210         ubik_ClientDestroy(pruclient);
2211         pruclient = NULL;
2212     }
2213
2214     return 0;
2215 }
2216 #endif /* QUERY_AFSID */
2217
2218 #if 0
2219 /* This has been copied to smb_IoctlSetToken in its entirety.
2220  * An equivalent version will need to be produced for the
2221  * redirector and some extensive refactoring might be required.
2222  */
2223 afs_int32
2224 cm_IoctlSetToken(struct cm_ioctl *ioctlp, struct cm_user *userp)
2225 {
2226     char *saveDataPtr;
2227     char *tp;
2228     int ticketLen;
2229     char *ticket;
2230     int ctSize;
2231     struct ClearToken ct;
2232     cm_cell_t *cellp;
2233     cm_ucell_t *ucellp;
2234     char *uname = NULL;
2235     afs_uuid_t uuid;
2236     int flags;
2237     char sessionKey[8];
2238     char *smbname;
2239     int release_userp = 0;
2240     char * wdir = NULL;
2241
2242     saveDataPtr = ioctlp->inDatap;
2243
2244     cm_SkipIoctlPath(ioctlp);
2245
2246     tp = ioctlp->inDatap;
2247
2248     /* ticket length */
2249     memcpy(&ticketLen, tp, sizeof(ticketLen));
2250     tp += sizeof(ticketLen);
2251     if (ticketLen < MINKTCTICKETLEN || ticketLen > MAXKTCTICKETLEN)
2252         return CM_ERROR_INVAL;
2253
2254     /* remember ticket and skip over it for now */
2255     ticket = tp;
2256     tp += ticketLen;
2257
2258     /* clear token size */
2259     memcpy(&ctSize, tp, sizeof(ctSize));
2260     tp += sizeof(ctSize);
2261     if (ctSize != sizeof(struct ClearToken))
2262         return CM_ERROR_INVAL;
2263
2264     /* clear token */
2265     memcpy(&ct, tp, ctSize);
2266     tp += ctSize;
2267     if (ct.AuthHandle == -1)
2268         ct.AuthHandle = 999;    /* more rxvab compat stuff */
2269
2270     /* more stuff, if any */
2271     if (ioctlp->inCopied > tp - saveDataPtr) {
2272         /* flags:  logon flag */
2273         memcpy(&flags, tp, sizeof(int));
2274         tp += sizeof(int);
2275
2276         /* cell name */
2277         cellp = cm_GetCell(tp, CM_FLAG_CREATE | CM_FLAG_NOPROBE);
2278         if (!cellp)
2279             return CM_ERROR_NOSUCHCELL;
2280         tp += strlen(tp) + 1;
2281
2282         /* user name */
2283         uname = tp;
2284         tp += strlen(tp) + 1;
2285
2286         if (flags & PIOCTL_LOGON) {
2287             /* SMB user name with which to associate tokens */
2288             smbname = tp;
2289             osi_Log2(smb_logp,"cm_IoctlSetToken for user [%s] smbname [%s]",
2290                      osi_LogSaveString(smb_logp,uname), osi_LogSaveString(smb_logp,smbname));
2291             fprintf(stderr, "SMB name = %s\n", smbname);
2292             tp += strlen(tp) + 1;
2293         } else {
2294             osi_Log1(smb_logp,"cm_IoctlSetToken for user [%s]",
2295                      osi_LogSaveString(smb_logp, uname));
2296         }
2297
2298                 /* uuid */
2299         memcpy(&uuid, tp, sizeof(uuid));
2300         if (!cm_FindTokenEvent(uuid, sessionKey))
2301             return CM_ERROR_INVAL;
2302     } else {
2303         cellp = cm_data.rootCellp;
2304         osi_Log0(smb_logp,"cm_IoctlSetToken - no name specified");
2305     }
2306
2307     if (flags & PIOCTL_LOGON) {
2308         userp = smb_FindCMUserByName(smbname, ioctlp->fidp->vcp->rname,
2309                                      SMB_FLAG_CREATE|SMB_FLAG_AFSLOGON);
2310         release_userp = 1;
2311     }
2312
2313     /* store the token */
2314     lock_ObtainMutex(&userp->mx);
2315     ucellp = cm_GetUCell(userp, cellp);
2316     osi_Log1(smb_logp,"cm_IoctlSetToken ucellp %lx", ucellp);
2317     ucellp->ticketLen = ticketLen;
2318     if (ucellp->ticketp)
2319         free(ucellp->ticketp);  /* Discard old token if any */
2320     ucellp->ticketp = malloc(ticketLen);
2321     memcpy(ucellp->ticketp, ticket, ticketLen);
2322     /*
2323      * Get the session key from the RPC, rather than from the pioctl.
2324      */
2325     /*
2326     memcpy(&ucellp->sessionKey, ct.HandShakeKey, sizeof(ct.HandShakeKey));
2327     */
2328     memcpy(ucellp->sessionKey.data, sessionKey, sizeof(sessionKey));
2329     ucellp->kvno = ct.AuthHandle;
2330     ucellp->expirationTime = ct.EndTimestamp;
2331     ucellp->gen++;
2332 #ifdef QUERY_AFSID
2333     ucellp->uid = ANONYMOUSID;
2334 #endif
2335     if (uname) {
2336         StringCbCopyA(ucellp->userName, MAXKTCNAMELEN, uname);
2337 #ifdef QUERY_AFSID
2338         cm_UsernameToId(uname, ucellp, &ucellp->uid);
2339 #endif
2340     }
2341     ucellp->flags |= CM_UCELLFLAG_RXKAD;
2342     lock_ReleaseMutex(&userp->mx);
2343
2344     if (flags & PIOCTL_LOGON) {
2345         ioctlp->flags |= CM_IOCTLFLAG_LOGON;
2346     }
2347
2348     cm_ResetACLCache(userp);
2349
2350     if (release_userp)
2351         cm_ReleaseUser(userp);
2352
2353     return 0;
2354 }
2355 #endif
2356
2357 /*
2358  * VIOC_GETTOK internals.
2359  *
2360  * Assumes that pioctl path has been parsed or skipped.
2361  */
2362 afs_int32
2363 cm_IoctlGetTokenIter(struct cm_ioctl *ioctlp, struct cm_user *userp)
2364 {
2365     char *tp, *cp;
2366     int iterator;
2367     int temp;
2368     cm_ucell_t *ucellp;
2369     struct ClearToken ct;
2370
2371     tp = ioctlp->inDatap;
2372     cp = ioctlp->outDatap;
2373
2374     /* iterator */
2375     memcpy(&iterator, tp, sizeof(iterator));
2376     tp += sizeof(iterator);
2377
2378     lock_ObtainMutex(&userp->mx);
2379
2380     /* look for token */
2381     for (;;iterator++) {
2382         ucellp = cm_FindUCell(userp, iterator);
2383         if (!ucellp) {
2384             lock_ReleaseMutex(&userp->mx);
2385             return CM_ERROR_NOMORETOKENS;
2386         }
2387         if (ucellp->flags & CM_UCELLFLAG_RXKAD)
2388             break;
2389     }
2390
2391     /* new iterator */
2392     temp = ucellp->iterator + 1;
2393     memcpy(cp, &temp, sizeof(temp));
2394     cp += sizeof(temp);
2395
2396     /* ticket length */
2397     memcpy(cp, &ucellp->ticketLen, sizeof(ucellp->ticketLen));
2398     cp += sizeof(ucellp->ticketLen);
2399
2400     /* ticket */
2401     memcpy(cp, ucellp->ticketp, ucellp->ticketLen);
2402     cp += ucellp->ticketLen;
2403
2404     /* clear token size */
2405     temp = sizeof(ct);
2406     memcpy(cp, &temp, sizeof(temp));
2407     cp += sizeof(temp);
2408
2409     /* clear token */
2410     ct.AuthHandle = ucellp->kvno;
2411
2412     /*
2413      * This field is supposed to hold the session key
2414      * but we don't want to make it easier for someone
2415      * to attack the cache.  The user gave us the session
2416      * key in the first place.
2417      */
2418     memset(ct.HandShakeKey, 0, sizeof(ct.HandShakeKey));
2419     ct.ViceId = 37;                     /* XXX */
2420     ct.BeginTimestamp = 0;              /* XXX */
2421     ct.EndTimestamp = ucellp->expirationTime;
2422     memcpy(cp, &ct, sizeof(ct));
2423     cp += sizeof(ct);
2424
2425     /* Primary flag (unused) */
2426     temp = 0;
2427     memcpy(cp, &temp, sizeof(temp));
2428     cp += sizeof(temp);
2429
2430     /* cell name */
2431     StringCbCopyA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), ucellp->cellp->name);
2432     cp += strlen(cp) + 1;
2433
2434     /* user name */
2435     StringCbCopyA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), ucellp->userName);
2436     cp += strlen(cp) + 1;
2437
2438     ioctlp->outDatap = cp;
2439
2440     lock_ReleaseMutex(&userp->mx);
2441
2442     return 0;
2443 }
2444
2445 /*
2446  * VIOC_NEWGETTOK internals.
2447  *
2448  * Assumes that pioctl path has been parsed or skipped.
2449  */
2450 afs_int32
2451 cm_IoctlGetToken(struct cm_ioctl *ioctlp, struct cm_user *userp)
2452 {
2453     char *cp;
2454     int temp;
2455     cm_cell_t *cellp;
2456     cm_ucell_t *ucellp;
2457     struct ClearToken ct;
2458     char *tp;
2459     afs_uuid_t uuid;
2460
2461     tp = ioctlp->inDatap;
2462
2463     cp = ioctlp->outDatap;
2464
2465     /* cell name is right here */
2466     cellp = cm_GetCell(tp, 0);
2467     if (!cellp)
2468         return CM_ERROR_NOSUCHCELL;
2469     tp += strlen(tp) + 1;
2470
2471     /* uuid */
2472     memcpy(&uuid, tp, sizeof(uuid));
2473
2474     lock_ObtainMutex(&userp->mx);
2475
2476     ucellp = cm_GetUCell(userp, cellp);
2477     if (!ucellp || !(ucellp->flags & CM_UCELLFLAG_RXKAD)) {
2478         lock_ReleaseMutex(&userp->mx);
2479         return CM_ERROR_NOMORETOKENS;
2480     }
2481
2482     /* ticket length */
2483     memcpy(cp, &ucellp->ticketLen, sizeof(ucellp->ticketLen));
2484     cp += sizeof(ucellp->ticketLen);
2485
2486     /* ticket */
2487     memcpy(cp, ucellp->ticketp, ucellp->ticketLen);
2488     cp += ucellp->ticketLen;
2489
2490     /* clear token size */
2491     temp = sizeof(ct);
2492     memcpy(cp, &temp, sizeof(temp));
2493     cp += sizeof(temp);
2494
2495     /* clear token */
2496     ct.AuthHandle = ucellp->kvno;
2497
2498     /* do not give out the session key */
2499     memset(ct.HandShakeKey, 0, sizeof(ct.HandShakeKey));
2500     ct.ViceId = 37;                     /* XXX */
2501     ct.BeginTimestamp = 0;              /* XXX */
2502     ct.EndTimestamp = ucellp->expirationTime;
2503     memcpy(cp, &ct, sizeof(ct));
2504     cp += sizeof(ct);
2505
2506     /* Primary flag (unused) */
2507     temp = 0;
2508     memcpy(cp, &temp, sizeof(temp));
2509     cp += sizeof(temp);
2510
2511     /* cell name */
2512     StringCbCopyA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), ucellp->cellp->name);
2513     cp += strlen(cp) + 1;
2514
2515     /* user name */
2516     StringCbCopyA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), ucellp->userName);
2517     cp += strlen(cp) + 1;
2518
2519     ioctlp->outDatap = cp;
2520
2521     lock_ReleaseMutex(&userp->mx);
2522
2523     cm_RegisterNewTokenEvent(uuid, ucellp->sessionKey.data);
2524
2525     return 0;
2526 }
2527
2528 /*
2529  * VIOCDELTOK internals.
2530  *
2531  * Assumes that pioctl path has been parsed or skipped.
2532  */
2533 afs_int32
2534 cm_IoctlDelToken(struct cm_ioctl *ioctlp, struct cm_user *userp)
2535 {
2536     char *cp;
2537     cm_cell_t *cellp;
2538     cm_ucell_t *ucellp;
2539
2540     cp = ioctlp->outDatap;
2541
2542     /* cell name is right here */
2543     cellp = cm_GetCell(ioctlp->inDatap, 0);
2544     if (!cellp)
2545         return CM_ERROR_NOSUCHCELL;
2546
2547     lock_ObtainMutex(&userp->mx);
2548
2549     ucellp = cm_GetUCell(userp, cellp);
2550     if (!ucellp) {
2551         lock_ReleaseMutex(&userp->mx);
2552         return CM_ERROR_NOMORETOKENS;
2553     }
2554
2555     osi_Log1(smb_logp,"cm_IoctlDelToken ucellp %lx", ucellp);
2556
2557     if (ucellp->ticketp) {
2558         free(ucellp->ticketp);
2559         ucellp->ticketp = NULL;
2560     }
2561     ucellp->ticketLen = 0;
2562     memset(ucellp->sessionKey.data, 0, 8);
2563     ucellp->kvno = 0;
2564     ucellp->expirationTime = 0;
2565     ucellp->userName[0] = '\0';
2566     ucellp->flags &= ~CM_UCELLFLAG_RXKAD;
2567     ucellp->gen++;
2568
2569     lock_ReleaseMutex(&userp->mx);
2570
2571     cm_ResetACLCache(userp);
2572
2573     return 0;
2574 }
2575
2576 /*
2577  * VIOCDELALLTOK internals.
2578  *
2579  * Assumes that pioctl path has been parsed or skipped.
2580  */
2581 afs_int32
2582 cm_IoctlDelAllToken(struct cm_ioctl *ioctlp, struct cm_user *userp)
2583 {
2584     cm_ucell_t *ucellp;
2585
2586     lock_ObtainMutex(&userp->mx);
2587
2588     for (ucellp = userp->cellInfop; ucellp; ucellp = ucellp->nextp) {
2589         osi_Log1(smb_logp,"cm_IoctlDelAllToken ucellp %lx", ucellp);
2590
2591         if (ucellp->ticketp) {
2592             free(ucellp->ticketp);
2593             ucellp->ticketp = NULL;
2594         }
2595         ucellp->ticketLen = 0;
2596         memset(ucellp->sessionKey.data, 0, 8);
2597         ucellp->kvno = 0;
2598         ucellp->expirationTime = 0;
2599         ucellp->userName[0] = '\0';
2600         ucellp->flags &= ~CM_UCELLFLAG_RXKAD;
2601         ucellp->gen++;
2602     }
2603
2604     lock_ReleaseMutex(&userp->mx);
2605
2606     cm_ResetACLCache(userp);
2607
2608     return 0;
2609 }
2610
2611 /*
2612  * VIOC_MAKESUBMOUNT internals.  (This function should be deprecated)
2613  *
2614  * Assumes that pioctl path has been parsed or skipped.
2615  */
2616 afs_int32
2617 cm_IoctlMakeSubmount(cm_ioctl_t *ioctlp, cm_user_t *userp)
2618 {
2619     char afspath[MAX_PATH];
2620     char *submountreqp;
2621     int nextAutoSubmount;
2622     HKEY hkSubmounts;
2623     DWORD dwType, dwSize;
2624     DWORD status;
2625     DWORD dwIndex;
2626     DWORD dwSubmounts;
2627
2628     /* Serialize this one, to prevent simultaneous mods
2629      * to afsdsbmt.ini
2630      */
2631     lock_ObtainMutex(&cm_Afsdsbmt_Lock);
2632
2633     /* Parse the input parameters--first the required afs path,
2634      * then the requested submount name (which may be "").
2635      */
2636     cm_NormalizeAfsPathAscii(afspath, sizeof(afspath), ioctlp->inDatap);
2637     submountreqp = ioctlp->inDatap + (strlen(ioctlp->inDatap)+1);
2638
2639     /* If the caller supplied a suggested submount name, see if
2640      * that submount name is in use... if so, the submount's path
2641      * has to match our path.
2642      */
2643
2644     RegCreateKeyEx( HKEY_LOCAL_MACHINE,
2645                     AFSREG_CLT_OPENAFS_SUBKEY "\\Submounts",
2646                     0,
2647                     "AFS",
2648                     REG_OPTION_NON_VOLATILE,
2649                     KEY_READ|KEY_WRITE|KEY_QUERY_VALUE,
2650                     NULL,
2651                     &hkSubmounts,
2652                     NULL );
2653
2654     if (submountreqp && *submountreqp) {
2655         char submountPath[MAX_PATH];
2656
2657         dwSize = sizeof(submountPath);
2658         status = RegQueryValueEx( hkSubmounts, submountreqp, 0,
2659                                   &dwType, submountPath, &dwSize);
2660
2661         if (status != ERROR_SUCCESS) {
2662
2663             /* The suggested submount name isn't in use now--
2664              * so we can safely map the requested submount name
2665              * to the supplied path. Remember not to write the
2666              * leading "/afs" when writing out the submount.
2667              */
2668             RegSetValueEx( hkSubmounts, submountreqp, 0,
2669                            REG_EXPAND_SZ,
2670                            (strlen(&afspath[strlen(cm_mountRoot)])) ?
2671                            &afspath[strlen(cm_mountRoot)]:"/",
2672                            (strlen(&afspath[strlen(cm_mountRoot)])) ?
2673                            (DWORD)strlen(&afspath[strlen(cm_mountRoot)])+1:2);
2674
2675             RegCloseKey( hkSubmounts );
2676             StringCbCopyA(ioctlp->outDatap, SMB_IOCTL_MAXDATA - (ioctlp->outDatap - ioctlp->outAllocp), submountreqp);
2677             ioctlp->outDatap += strlen(ioctlp->outDatap) +1;
2678             lock_ReleaseMutex(&cm_Afsdsbmt_Lock);
2679             return 0;
2680         }
2681
2682         /* The suggested submount name is already in use--if the
2683          * supplied path matches the submount's path, we can still
2684          * use the suggested submount name.
2685          */
2686         if (!strcmp (submountPath, afspath)) {
2687             StringCbCopyA(ioctlp->outDatap, SMB_IOCTL_MAXDATA - (ioctlp->outDatap - ioctlp->outAllocp), submountreqp);
2688             ioctlp->outDatap += strlen(ioctlp->outDatap) +1;
2689             RegCloseKey( hkSubmounts );
2690             lock_ReleaseMutex(&cm_Afsdsbmt_Lock);
2691             return 0;
2692         }
2693     }
2694
2695     RegQueryInfoKey( hkSubmounts,
2696                      NULL,  /* lpClass */
2697                      NULL,  /* lpcClass */
2698                      NULL,  /* lpReserved */
2699                      NULL,  /* lpcSubKeys */
2700                      NULL,  /* lpcMaxSubKeyLen */
2701                      NULL,  /* lpcMaxClassLen */
2702                      &dwSubmounts, /* lpcValues */
2703                      NULL,  /* lpcMaxValueNameLen */
2704                      NULL,  /* lpcMaxValueLen */
2705                      NULL,  /* lpcbSecurityDescriptor */
2706                      NULL   /* lpftLastWriteTime */
2707                      );
2708
2709
2710     /* Having obtained a list of all available submounts, start
2711      * searching that list for a path which matches the requested
2712      * AFS path. We'll also keep track of the highest "auto15"/"auto47"
2713      * submount, in case we need to add a new one later.
2714      */
2715
2716     nextAutoSubmount = 1;
2717
2718     for ( dwIndex = 0; dwIndex < dwSubmounts; dwIndex ++ ) {
2719         char submountPath[MAX_PATH] = "";
2720         DWORD submountPathLen = sizeof(submountPath);
2721         char submountName[MAX_PATH];
2722         DWORD submountNameLen = sizeof(submountName);
2723
2724         dwType = 0;
2725         RegEnumValue( hkSubmounts, dwIndex, submountName, &submountNameLen, NULL,
2726                       &dwType, submountPath, &submountPathLen);
2727         if (dwType == REG_EXPAND_SZ) {
2728             char buf[MAX_PATH];
2729             StringCbCopyA(buf, MAX_PATH, submountPath);
2730             submountPathLen = ExpandEnvironmentStrings(buf, submountPath, MAX_PATH);
2731             if (submountPathLen > MAX_PATH)
2732                 continue;
2733         }
2734
2735         /* If this is an Auto### submount, remember its ### value */
2736         if ((!strnicmp (submountName, "auto", 4)) &&
2737              (isdigit (submountName[strlen("auto")]))) {
2738             int thisAutoSubmount;
2739             thisAutoSubmount = atoi (&submountName[strlen("auto")]);
2740             nextAutoSubmount = max (nextAutoSubmount,
2741                                      thisAutoSubmount+1);
2742         }
2743
2744         if ((submountPathLen == 0) ||
2745              (submountPathLen == sizeof(submountPath) - 1)) {
2746             continue;
2747         }
2748
2749         /* See if the path for this submount matches the path
2750          * that our caller specified. If so, we can return
2751          * this submount.
2752          */
2753         if (!strcmp (submountPath, afspath)) {
2754             StringCbCopyA(ioctlp->outDatap, SMB_IOCTL_MAXDATA - (ioctlp->outDatap - ioctlp->outAllocp), submountName);
2755             ioctlp->outDatap += strlen(ioctlp->outDatap) +1;
2756             RegCloseKey(hkSubmounts);
2757             lock_ReleaseMutex(&cm_Afsdsbmt_Lock);
2758             return 0;
2759
2760         }
2761     }
2762
2763     /* We've been through the entire list of existing submounts, and
2764      * didn't find any which matched the specified path. So, we'll
2765      * just have to add one. Remember not to write the leading "/afs"
2766      * when writing out the submount.
2767      */
2768
2769     StringCbPrintfA(ioctlp->outDatap, SMB_IOCTL_MAXDATA - (ioctlp->outDatap - ioctlp->outAllocp), "auto%ld", nextAutoSubmount);
2770
2771     RegSetValueEx( hkSubmounts,
2772                    ioctlp->outDatap,
2773                    0,
2774                    REG_EXPAND_SZ,
2775                    (strlen(&afspath[strlen(cm_mountRoot)])) ?
2776                    &afspath[strlen(cm_mountRoot)]:"/",
2777                    (strlen(&afspath[strlen(cm_mountRoot)])) ?
2778                    (DWORD)strlen(&afspath[strlen(cm_mountRoot)])+1:2);
2779
2780     ioctlp->outDatap += strlen(ioctlp->outDatap) +1;
2781     RegCloseKey(hkSubmounts);
2782     lock_ReleaseMutex(&cm_Afsdsbmt_Lock);
2783     return 0;
2784 }
2785
2786 /*
2787  * VIOC_GETRXKCRYPT internals.
2788  *
2789  * Assumes that pioctl path has been parsed or skipped.
2790  */
2791 afs_int32
2792 cm_IoctlGetRxkcrypt(cm_ioctl_t *ioctlp, cm_user_t *userp)
2793 {
2794     memcpy(ioctlp->outDatap, &cryptall, sizeof(cryptall));
2795     ioctlp->outDatap += sizeof(cryptall);
2796
2797     return 0;
2798 }
2799
2800 /*
2801  * VIOC_SETRXKCRYPT internals.
2802  *
2803  * Assumes that pioctl path has been parsed or skipped.
2804  */
2805 afs_int32
2806 cm_IoctlSetRxkcrypt(cm_ioctl_t *ioctlp, cm_user_t *userp)
2807 {
2808     afs_int32 c = cryptall;
2809
2810     memcpy(&cryptall, ioctlp->inDatap, sizeof(cryptall));
2811
2812     if (c != cryptall) {
2813         if (cryptall)
2814             LogEvent(EVENTLOG_INFORMATION_TYPE, MSG_CRYPT_ON);
2815         else
2816             LogEvent(EVENTLOG_INFORMATION_TYPE, MSG_CRYPT_OFF);
2817     }
2818     return 0;
2819 }
2820
2821 /*
2822  * VIOC_RXSTAT_PROC internals.
2823  *
2824  * Assumes that pioctl path has been parsed or skipped.
2825  */
2826 afs_int32
2827 cm_IoctlRxStatProcess(struct cm_ioctl *ioctlp, struct cm_user *userp)
2828 {
2829     afs_int32 flags;
2830     int code = 0;
2831
2832     memcpy((char *)&flags, ioctlp->inDatap, sizeof(afs_int32));
2833     if (!(flags & AFSCALL_RXSTATS_MASK) || (flags & ~AFSCALL_RXSTATS_MASK)) {
2834         return -1;
2835     }
2836     if (flags & AFSCALL_RXSTATS_ENABLE) {
2837         rx_enableProcessRPCStats();
2838     }
2839     if (flags & AFSCALL_RXSTATS_DISABLE) {
2840         rx_disableProcessRPCStats();
2841     }
2842     if (flags & AFSCALL_RXSTATS_CLEAR) {
2843         rx_clearProcessRPCStats(AFS_RX_STATS_CLEAR_ALL);
2844     }
2845     return 0;
2846 }
2847
2848 /*
2849  * VIOC_RXSTAT_PEER internals.
2850  *
2851  * Assumes that pioctl path has been parsed or skipped.
2852  */
2853 afs_int32
2854 cm_IoctlRxStatPeer(struct cm_ioctl *ioctlp, struct cm_user *userp)
2855 {
2856     afs_int32 flags;
2857     int code = 0;
2858
2859     memcpy((char *)&flags, ioctlp->inDatap, sizeof(afs_int32));
2860     if (!(flags & AFSCALL_RXSTATS_MASK) || (flags & ~AFSCALL_RXSTATS_MASK)) {
2861         return -1;
2862     }
2863     if (flags & AFSCALL_RXSTATS_ENABLE) {
2864         rx_enablePeerRPCStats();
2865     }
2866     if (flags & AFSCALL_RXSTATS_DISABLE) {
2867         rx_disablePeerRPCStats();
2868     }
2869     if (flags & AFSCALL_RXSTATS_CLEAR) {
2870         rx_clearPeerRPCStats(AFS_RX_STATS_CLEAR_ALL);
2871     }
2872     return 0;
2873 }
2874
2875 /*
2876  * VIOC_UNICODECTL internals.
2877  *
2878  * Assumes that pioctl path has been parsed or skipped.
2879  */
2880 afs_int32
2881 cm_IoctlUnicodeControl(struct cm_ioctl *ioctlp, struct cm_user * userp)
2882 {
2883     afs_int32 result = 0;
2884 #ifdef SMB_UNICODE
2885     afs_uint32 cmd;
2886
2887     memcpy(&cmd, ioctlp->inDatap, sizeof(afs_uint32));
2888
2889     if (cmd & 2) {
2890         /* Setting the Unicode flag */
2891         LONG newflag;
2892
2893         newflag = ((cmd & 1) == 1);
2894
2895         InterlockedExchange(&smb_UseUnicode, newflag);
2896     }
2897
2898     result = smb_UseUnicode;
2899 #else
2900     result = 2;
2901 #endif
2902
2903     memcpy(ioctlp->outDatap, &result, sizeof(result));
2904     ioctlp->outDatap += sizeof(result);
2905
2906     return 0;
2907 }
2908
2909 /*
2910  * VIOC_UUIDCTL internals.
2911  *
2912  * Assumes that pioctl path has been parsed or skipped.
2913  */
2914 afs_int32
2915 cm_IoctlUUIDControl(struct cm_ioctl * ioctlp, struct cm_user *userp)
2916 {
2917     afs_uint32 cmd;
2918     afsUUID uuid;
2919
2920     memcpy(&cmd, ioctlp->inDatap, sizeof(afs_uint32));
2921
2922     if (cmd) {             /* generate a new UUID */
2923         UuidCreate((UUID *) &uuid);
2924         cm_data.Uuid = uuid;
2925         cm_ForceNewConnectionsAllServers();
2926     }
2927
2928     memcpy(ioctlp->outDatap, &cm_data.Uuid, sizeof(cm_data.Uuid));
2929     ioctlp->outDatap += sizeof(cm_data.Uuid);
2930
2931     return 0;
2932 }
2933
2934
2935
2936 /*
2937  * functions to dump contents of various structures.
2938  * In debug build (linked with crt debug library) will dump allocated but not freed memory
2939  */
2940 extern int cm_DumpSCache(FILE *outputFile, char *cookie, int lock);
2941 extern int cm_DumpBufHashTable(FILE *outputFile, char *cookie, int lock);
2942
2943 /*
2944  * VIOC_TRACEMEMDUMP internals.
2945  *
2946  * Assumes that pioctl path has been parsed or skipped.
2947  * dscp is held but not locked.
2948  */
2949 afs_int32
2950 cm_IoctlMemoryDump(struct cm_ioctl *ioctlp, struct cm_user *userp)
2951 {
2952     afs_int32 inValue = 0;
2953     HANDLE hLogFile;
2954     char logfileName[MAX_PATH+1];
2955     char *cookie;
2956     DWORD dwSize;
2957
2958 #ifdef _DEBUG
2959     static _CrtMemState memstate;
2960 #endif
2961
2962     memcpy(&inValue, ioctlp->inDatap, sizeof(afs_int32));
2963
2964     dwSize = GetEnvironmentVariable("TEMP", logfileName, sizeof(logfileName));
2965     if ( dwSize == 0 || dwSize > sizeof(logfileName) )
2966     {
2967         GetWindowsDirectory(logfileName, sizeof(logfileName));
2968     }
2969     strncat(logfileName, "\\afsd_alloc.log", sizeof(logfileName));
2970
2971     hLogFile = CreateFile(logfileName, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
2972
2973     if (!hLogFile)
2974     {
2975       /* error */
2976       inValue = -1;
2977       memcpy(ioctlp->outDatap, &inValue, sizeof(afs_int32));
2978       ioctlp->outDatap += sizeof(afs_int32);
2979
2980       return 0;
2981     }
2982
2983     SetFilePointer(hLogFile, 0, NULL, FILE_END);
2984
2985     cookie = inValue ? "b" : "e";
2986
2987 #ifdef _DEBUG
2988
2989     if (inValue)
2990     {
2991       _CrtMemCheckpoint(&memstate);
2992     }
2993     else
2994     {
2995         _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
2996         _CrtSetReportFile(_CRT_WARN, hLogFile);
2997         _CrtMemDumpAllObjectsSince(&memstate);
2998     }
2999 #endif
3000
3001     /* dump all interesting data */
3002     cm_MemDumpDirStats(hLogFile, cookie, 1);
3003     cm_MemDumpBPlusStats(hLogFile, cookie, 1);
3004     cm_DumpCells(hLogFile, cookie, 1);
3005     cm_DumpVolumes(hLogFile, cookie, 1);
3006     cm_DumpSCache(hLogFile, cookie, 1);
3007     cm_DumpBufHashTable(hLogFile, cookie, 1);
3008     smb_DumpVCP(hLogFile, cookie, 1);
3009
3010     CloseHandle(hLogFile);
3011
3012     inValue = 0;        /* success */
3013     memcpy(ioctlp->outDatap, &inValue, sizeof(long));
3014     ioctlp->outDatap += sizeof(long);
3015
3016     return 0;
3017 }
3018
3019 /* Utility functon.  Not currently used. */
3020 static afs_int32
3021 cm_CheckServersStatus(cm_serverRef_t *serversp)
3022 {
3023     afs_int32 code = 0;
3024     cm_serverRef_t *tsrp;
3025     cm_server_t *tsp;
3026     int someBusy = 0, someOffline = 0, allOffline = 1, allBusy = 1, allDown = 1;
3027
3028     if (serversp == NULL) {
3029         osi_Log1(afsd_logp, "cm_CheckServersStatus returning 0x%x", CM_ERROR_ALLDOWN);
3030         return CM_ERROR_ALLDOWN;
3031     }
3032
3033     lock_ObtainRead(&cm_serverLock);
3034     for (tsrp = serversp; tsrp; tsrp=tsrp->next) {
3035         if (tsp = tsrp->server) {
3036             cm_GetServerNoLock(tsp);
3037             lock_ReleaseRead(&cm_serverLock);
3038             if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
3039                 allDown = 0;
3040                 if (tsrp->status == srv_busy) {
3041                     allOffline = 0;
3042                     someBusy = 1;
3043                 } else if (tsrp->status == srv_offline) {
3044                     allBusy = 0;
3045                     someOffline = 1;
3046                 } else {
3047                     allOffline = 0;
3048                     allBusy = 0;
3049                     cm_PutServer(tsp);
3050                     goto done;
3051                 }
3052             }
3053             lock_ObtainRead(&cm_serverLock);
3054             cm_PutServerNoLock(tsp);
3055         }
3056     }
3057     lock_ReleaseRead(&cm_serverLock);
3058
3059     if (allDown)
3060         code = CM_ERROR_ALLDOWN;
3061     else if (allBusy)
3062         code = CM_ERROR_ALLBUSY;
3063     else if (allOffline || (someBusy && someOffline))
3064         code = CM_ERROR_ALLOFFLINE;
3065
3066   done:
3067     osi_Log1(afsd_logp, "cm_CheckServersStatus returning 0x%x", code);
3068     return code;
3069 }
3070
3071 /*
3072  * VIOC_PATH_AVAILABILITY internals.
3073  *
3074  * Assumes that pioctl path has been parsed or skipped.
3075  * scp is held but not locked.
3076  */
3077 afs_int32
3078 cm_IoctlPathAvailability(struct cm_ioctl *ioctlp, struct cm_user *userp, cm_scache_t *scp, cm_req_t *reqp)
3079 {
3080     afs_int32 code;
3081     cm_cell_t *cellp;
3082     cm_volume_t *tvp;
3083     cm_vol_state_t *statep;
3084     afs_uint32 volume;
3085
3086 #ifdef AFS_FREELANCE_CLIENT
3087     if ( scp->fid.cell == AFS_FAKE_ROOT_CELL_ID && scp->fid.volume == AFS_FAKE_ROOT_VOL_ID ) {
3088         code = 0;
3089     } else
3090 #endif
3091     {
3092         volume = scp->fid.volume;
3093
3094         cellp = cm_FindCellByID(scp->fid.cell, 0);
3095
3096         if (!cellp)
3097             return CM_ERROR_NOSUCHCELL;
3098
3099         code = cm_FindVolumeByID(cellp, volume, userp, reqp, CM_GETVOL_FLAG_CREATE, &tvp);
3100         if (code)
3101             return code;
3102
3103         statep = cm_VolumeStateByID(tvp, volume);
3104         switch (statep->state) {
3105         case vl_online:
3106         case vl_unknown:
3107             code = 0;
3108             break;
3109         case vl_busy:
3110             code = CM_ERROR_ALLBUSY;
3111             break;
3112         case vl_offline:
3113             code = CM_ERROR_ALLOFFLINE;
3114             break;
3115         case vl_alldown:
3116             code = CM_ERROR_ALLDOWN;
3117             break;
3118         }
3119         cm_PutVolume(tvp);
3120     }
3121     return code;
3122 }
3123
3124 /*
3125  * VIOC_VOLSTAT_TEST internals.
3126  *
3127  * Assumes that pioctl path has been parsed or skipped.
3128  */
3129 afs_int32
3130 cm_IoctlVolStatTest(struct cm_ioctl *ioctlp, struct cm_user *userp, cm_req_t *reqp)
3131 {
3132     afs_int32 code;
3133     cm_cell_t *cellp = NULL;
3134     cm_volume_t *volp;
3135     cm_vol_state_t *statep;
3136     struct VolStatTest * testp;
3137     afs_uint32 n;
3138
3139     testp = (struct VolStatTest *)ioctlp->inDatap;
3140
3141 #ifdef AFS_FREELANCE_CLIENT
3142     if (testp->fid.cell == -1)
3143         return CM_ERROR_NOACCESS;
3144 #endif
3145
3146     if (testp->flags & VOLSTAT_TEST_CHECK_VOLUME) {
3147         cm_CheckOfflineVolumes();
3148         return 0;
3149     }
3150
3151     if (testp->flags & VOLSTAT_TEST_NETWORK_UP) {
3152         cm_VolStatus_Network_Started(cm_NetbiosName
3153 #ifdef _WIN64
3154                                   , cm_NetbiosName
3155 #endif
3156                                   );
3157         return 0;
3158     }
3159
3160     if (testp->flags & VOLSTAT_TEST_NETWORK_DOWN) {
3161         cm_VolStatus_Network_Stopped(cm_NetbiosName
3162 #ifdef _WIN64
3163                                   , cm_NetbiosName
3164 #endif
3165                                   );
3166         return 0;
3167     }
3168
3169     if (testp->cellname[0]) {
3170         n = atoi(testp->cellname);
3171         if (n)
3172             testp->fid.cell = n;
3173         else
3174             cellp = cm_GetCell(testp->cellname, 0);
3175     }
3176
3177     if (testp->fid.cell > 0) {
3178         cellp = cm_FindCellByID(testp->fid.cell, 0);
3179     }
3180
3181     if (!cellp)
3182         return CM_ERROR_NOSUCHCELL;
3183
3184     if (testp->volname[0]) {
3185         n = atoi(testp->volname);
3186         if (n)
3187             testp->fid.volume = n;
3188         else
3189             code = cm_FindVolumeByName(cellp, testp->volname, userp, reqp, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
3190     }
3191
3192     if (testp->fid.volume > 0)
3193         code = cm_FindVolumeByID(cellp, testp->fid.volume, userp, reqp, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
3194
3195     if (code)
3196         return code;
3197
3198     if (testp->fid.volume)
3199         statep = cm_VolumeStateByID(volp, testp->fid.volume);
3200     else
3201         statep = cm_VolumeStateByName(volp, testp->volname);
3202
3203     if (statep) {
3204         statep->state = testp->state;
3205         code = cm_VolStatus_Change_Notification(cellp->cellID, statep->ID, testp->state);
3206     }
3207
3208     cm_PutVolume(volp);
3209
3210     return code;
3211 }