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