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