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
  13 #ifndef DJGPP
  14 #include <windows.h>
  15 #else
  16 #include <sys/socket.h>
  17 #endif /* !DJGPP */
  18 #include <errno.h>
  19 #include <stdlib.h>
  20 #include <malloc.h>
  21 #include <string.h>
  22 #include <stdio.h>
  23 #include <time.h>
  24
  25 #include <osi.h>
  26
  27 #include "afsd.h"
  28 #include "afsd_init.h"
  29
  30 #include "smb.h"
  31
  32 #ifndef DJGPP
  33 #include <rx/rxkad.h>
  34 #include "afsrpc.h"
  35 #else
  36 #include <rx/rxkad.h>
  37 #include "afsrpc95.h"
  38 #endif
  39
  40 #include "cm_rpc.h"
  41
  42 /* Copied from afs_tokens.h */
  43 #define PIOCTL_LOGON    0x1
  44 #define MAX_PATH 260
  45
  46 osi_mutex_t cm_Afsdsbmt_Lock;
  47 #ifdef AFS_FREELANCE_CLIENT
  48 extern osi_mutex_t cm_Freelance_Lock;
  49 #endif
  50
  51 extern afs_int32 cryptall;
  52
  53 void cm_InitIoctl(void)
  54 {
  55         lock_InitializeMutex(&cm_Afsdsbmt_Lock, "AFSDSBMT.INI Access Lock");
  56 }
  57
  58 long cm_FlushFile(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp)
  59 {
  60         long code;
  61
  62         lock_ObtainWrite(&scp->bufCreateLock);
  63         code = buf_FlushCleanPages(scp, userp, reqp);
  64
  65         lock_ObtainMutex(&scp->mx);
  66         scp->cbServerp = NULL;
  67         scp->cbExpires = 0;
  68         lock_ReleaseMutex(&scp->mx);
  69
  70         lock_ReleaseWrite(&scp->bufCreateLock);
  71         cm_dnlcPurgedp(scp);
  72
  73         return code;
  74 }
  75
  76 /*
  77  * cm_ResetACLCache -- invalidate ACL info for a user that has just
  78  *                      obtained or lost tokens
  79  */
  80 void cm_ResetACLCache(cm_user_t *userp)
  81 {
  82         cm_scache_t *scp;
  83         int hash;
  84
  85         lock_ObtainWrite(&cm_scacheLock);
  86         for (hash=0; hash < cm_hashTableSize; hash++) {
  87                 for (scp=cm_hashTablep[hash]; scp; scp=scp->nextp) {
  88                         scp->refCount++;
  89                         lock_ReleaseWrite(&cm_scacheLock);
  90                         lock_ObtainMutex(&scp->mx);
  91                         cm_InvalidateACLUser(scp, userp);
  92                         lock_ReleaseMutex(&scp->mx);
  93                         lock_ObtainWrite(&cm_scacheLock);
  94                         scp->refCount--;
  95                 }
  96         }
  97         lock_ReleaseWrite(&cm_scacheLock);
  98 }
  99
 100 /*
 101  *  TranslateExtendedChars - This is a fix for TR 54482.
 102  *
 103  *  If an extended character (80 - FF) is entered into a file
 104  *  or directory name in Windows, the character is translated
 105  *  into the OEM character map before being passed to us.  Why
 106  *  this occurs is unknown.  Our pioctl functions must match
 107  *  this translation for paths given via our own commands (like
 108  *  fs).  If we do not do this, then we will try to perform an
 109  *  operation on a non-translated path, which we will fail to
 110  *  find, since the path was created with the translated chars.
 111  *  This function performs the required translation.
 112  */
 113 void TranslateExtendedChars(char *str)
 114 {
 115 #ifdef DJGPP
 116     char *p;
 117 #endif
 118
 119     if (!str || !*str)
 120         return;
 121
 122 #ifndef DJGPP
 123     CharToOem(str, str);
 124 #else
 125     p = str;
 126     while (*p) *p++ &= 0x7f;  /* turn off high bit; probably not right */
 127 #endif
 128 }
 129
 130 /* parse the passed-in file name and do a namei on it.  If we fail,
 131  * return an error code, otherwise return the vnode located in *scpp.
 132  */
 133 long cm_ParseIoctlPath(smb_ioctl_t *ioctlp, cm_user_t *userp, cm_req_t *reqp,
 134         cm_scache_t **scpp)
 135 {
 136         long code;
 137         cm_scache_t *substRootp;
 138
 139         /* This is usually the file name, but for StatMountPoint it is the path. */
 140         TranslateExtendedChars(ioctlp->inDatap);
 141
 142         code = cm_NameI(cm_rootSCachep, ioctlp->prefix->data,
 143                 CM_FLAG_CASEFOLD | CM_FLAG_FOLLOW,
 144                 userp, ioctlp->tidPathp, reqp, &substRootp);
 145         if (code) return code;
 146
 147         code = cm_NameI(substRootp, ioctlp->inDatap, CM_FLAG_FOLLOW,
 148                 userp, NULL, reqp, scpp);
 149         if (code) return code;
 150
 151         /* # of bytes of path */
 152         code = strlen(ioctlp->inDatap) + 1;
 153         ioctlp->inDatap += code;
 154
 155         /* This is usually nothing, but for StatMountPoint it is the file name. */
 156         TranslateExtendedChars(ioctlp->inDatap);
 157
 158         /* and return success */
 159         return 0;
 160 }
 161
 162 void cm_SkipIoctlPath(smb_ioctl_t *ioctlp)
 163 {
 164         long temp;
 165
 166         temp = strlen(ioctlp->inDatap) + 1;
 167         ioctlp->inDatap += temp;
 168 }
 169
 170
 171 /* format the specified path to look like "/afs/<cellname>/usr", by
 172  * adding "/afs" (if necessary) in front, changing any \'s to /'s, and
 173  * removing any trailing "/"'s. One weirdo caveat: "/afs" will be
 174  * intentionally returned as "/afs/"--this makes submount manipulation
 175  * easier (because we can always jump past the initial "/afs" to find
 176  * the AFS path that should be written into afsdsbmt.ini).
 177  */
 178 void cm_NormalizeAfsPath (char *outpathp, char *inpathp)
 179 {
 180         char *cp;
 181     char bslash_mountRoot[256];
 182
 183     strncpy(bslash_mountRoot, cm_mountRoot, sizeof(bslash_mountRoot) - 1);
 184     bslash_mountRoot[0] = '\\';
 185
 186     if (!strnicmp (inpathp, cm_mountRoot, strlen(cm_mountRoot)))
 187                 lstrcpy (outpathp, inpathp);
 188        else if (!strnicmp (inpathp, bslash_mountRoot, strlen(bslash_mountRoot)))
 189                 lstrcpy (outpathp, inpathp);
 190         else if ((inpathp[0] == '/') || (inpathp[0] == '\\'))
 191                sprintf (outpathp, "%s%s", cm_mountRoot, inpathp);
 192         else // inpathp looks like "<cell>/usr"
 193                sprintf (outpathp, "%s/%s", cm_mountRoot, inpathp);
 194
 195         for (cp = outpathp; *cp != 0; ++cp) {
 196                 if (*cp == '\\')
 197                         *cp = '/';
 198         }
 199
 200         if (strlen(outpathp) && (outpathp[strlen(outpathp)-1] == '/')) {
 201            outpathp[strlen(outpathp)-1] = 0;
 202         }
 203
 204         if (!strcmpi (outpathp, cm_mountRoot)) {
 205         strcpy (outpathp, cm_mountRoot);
 206         }
 207 }
 208
 209 /* parse the passed-in file name and do a namei on its parent.  If we fail,
 210  * return an error code, otherwise return the vnode located in *scpp.
 211  */
 212 long cm_ParseIoctlParent(smb_ioctl_t *ioctlp, cm_user_t *userp, cm_req_t *reqp,
 213                          cm_scache_t **scpp, char *leafp)
 214 {
 215         long code;
 216         char tbuffer[1024];
 217         char *tp, *jp;
 218         cm_scache_t *substRootp;
 219
 220         strcpy(tbuffer, ioctlp->inDatap);
 221         tp = strrchr(tbuffer, '\\');
 222         jp = strrchr(tbuffer, '/');
 223         if (!tp)
 224                 tp = jp;
 225         else if (jp && (tp - tbuffer) < (jp - tbuffer))
 226                 tp = jp;
 227         if (!tp) {
 228                 strcpy(tbuffer, "\\");
 229                 if (leafp) strcpy(leafp, ioctlp->inDatap);
 230         }
 231         else {
 232                 *tp = 0;
 233                 if (leafp) strcpy(leafp, tp+1);
 234         }
 235
 236         code = cm_NameI(cm_rootSCachep, ioctlp->prefix->data,
 237                 CM_FLAG_CASEFOLD | CM_FLAG_FOLLOW,
 238                 userp, ioctlp->tidPathp, reqp, &substRootp);
 239         if (code) return code;
 240
 241         code = cm_NameI(substRootp, tbuffer, CM_FLAG_FOLLOW,
 242                 userp, NULL, reqp, scpp);
 243         if (code) return code;
 244
 245         /* # of bytes of path */
 246         code = strlen(ioctlp->inDatap) + 1;
 247         ioctlp->inDatap += code;
 248
 249         /* and return success */
 250         return 0;
 251 }
 252
 253 long cm_IoctlGetACL(smb_ioctl_t *ioctlp, cm_user_t *userp)
 254 {
 255         cm_conn_t *connp;
 256         cm_scache_t *scp;
 257         AFSOpaque acl;
 258         AFSFetchStatus fileStatus;
 259         AFSVolSync volSync;
 260         long code;
 261         AFSFid fid;
 262         int tlen;
 263         cm_req_t req;
 264
 265         cm_InitReq(&req);
 266
 267         code = cm_ParseIoctlPath(ioctlp, userp, &req, &scp);
 268         if (code) return code;
 269
 270         /* now make the get acl call */
 271         fid.Volume = scp->fid.volume;
 272         fid.Vnode = scp->fid.vnode;
 273         fid.Unique = scp->fid.unique;
 274         do {
 275                 acl.AFSOpaque_val = ioctlp->outDatap;
 276                 acl.AFSOpaque_len = 0;
 277                 code = cm_Conn(&scp->fid, userp, &req, &connp);
 278                 if (code) continue;
 279
 280                 code = RXAFS_FetchACL(connp->callp, &fid, &acl, &fileStatus, &volSync);
 281         } while (cm_Analyze(connp, userp, &req, &scp->fid,
 282                             &volSync, NULL, code));
 283         code = cm_MapRPCError(code, &req);
 284         cm_ReleaseSCache(scp);
 285
 286         if (code) return code;
 287
 288         /* skip over return data */
 289         tlen = strlen(ioctlp->outDatap) + 1;
 290         ioctlp->outDatap += tlen;
 291
 292         /* and return success */
 293         return 0;
 294 }
 295
 296 long cm_IoctlGetFileCellName(struct smb_ioctl *ioctlp, struct cm_user *userp)
 297 {
 298         long code;
 299         cm_scache_t *scp;
 300         cm_cell_t *cellp;
 301         cm_req_t req;
 302
 303         cm_InitReq(&req);
 304
 305         code = cm_ParseIoctlPath(ioctlp, userp, &req, &scp);
 306         if (code) return code;
 307
 308         cellp = cm_FindCellByID(scp->fid.cell);
 309         if (cellp) {
 310                 strcpy(ioctlp->outDatap, cellp->namep);
 311                 ioctlp->outDatap += strlen(ioctlp->outDatap) + 1;
 312                 code = 0;
 313         }
 314         else code = CM_ERROR_NOSUCHCELL;
 315
 316         cm_ReleaseSCache(scp);
 317         return code;
 318 }
 319
 320 long cm_IoctlSetACL(struct smb_ioctl *ioctlp, struct cm_user *userp)
 321 {
 322         cm_conn_t *connp;
 323         cm_scache_t *scp;
 324         AFSOpaque acl;
 325         AFSFetchStatus fileStatus;
 326         AFSVolSync volSync;
 327         long code;
 328         AFSFid fid;
 329         cm_req_t req;
 330
 331         cm_InitReq(&req);
 332
 333         code = cm_ParseIoctlPath(ioctlp, userp, &req, &scp);
 334         if (code) return code;
 335
 336         /* now make the get acl call */
 337         fid.Volume = scp->fid.volume;
 338         fid.Vnode = scp->fid.vnode;
 339         fid.Unique = scp->fid.unique;
 340         do {
 341                 acl.AFSOpaque_val = ioctlp->inDatap;
 342                 acl.AFSOpaque_len = strlen(ioctlp->inDatap)+1;
 343                 code = cm_Conn(&scp->fid, userp, &req, &connp);
 344                 if (code) continue;
 345
 346                 code = RXAFS_StoreACL(connp->callp, &fid, &acl, &fileStatus, &volSync);
 347         } while (cm_Analyze(connp, userp, &req, &scp->fid,
 348                             &volSync, NULL, code));
 349         code = cm_MapRPCError(code, &req);
 350
 351         /* invalidate cache info, since we just trashed the ACL cache */
 352         lock_ObtainMutex(&scp->mx);
 353         cm_DiscardSCache(scp);
 354         lock_ReleaseMutex(&scp->mx);
 355
 356         cm_ReleaseSCache(scp);
 357
 358         return code;
 359 }
 360
 361 long cm_IoctlFlushVolume(struct smb_ioctl *ioctlp, struct cm_user *userp)
 362 {
 363         long code;
 364         cm_scache_t *scp;
 365         unsigned long volume;
 366         int i;
 367         cm_req_t req;
 368
 369         cm_InitReq(&req);
 370
 371         code = cm_ParseIoctlPath(ioctlp, userp, &req, &scp);
 372         if (code) return code;
 373
 374         volume = scp->fid.volume;
 375         cm_ReleaseSCache(scp);
 376
 377         lock_ObtainWrite(&cm_scacheLock);
 378         for(i=0; i<cm_hashTableSize; i++) {
 379                 for(scp = cm_hashTablep[i]; scp; scp = scp->nextp) {
 380                         if (scp->fid.volume == volume) {
 381                                 scp->refCount++;
 382                                 lock_ReleaseWrite(&cm_scacheLock);
 383
 384                                 /* now flush the file */
 385                                 cm_FlushFile(scp, userp, &req);
 386
 387                                 lock_ObtainWrite(&cm_scacheLock);
 388                                 scp->refCount--;
 389                         }
 390                 }
 391         }
 392         lock_ReleaseWrite(&cm_scacheLock);
 393
 394         return code;
 395 }
 396
 397 long cm_IoctlFlushFile(struct smb_ioctl *ioctlp, struct cm_user *userp)
 398 {
 399         long code;
 400         cm_scache_t *scp;
 401         cm_req_t req;
 402
 403         cm_InitReq(&req);
 404
 405         code = cm_ParseIoctlPath(ioctlp, userp, &req, &scp);
 406         if (code) return code;
 407
 408         cm_FlushFile(scp, userp, &req);
 409         cm_ReleaseSCache(scp);
 410
 411         return 0;
 412 }
 413
 414 long cm_IoctlSetVolumeStatus(struct smb_ioctl *ioctlp, struct cm_user *userp)
 415 {
 416         cm_scache_t *scp;
 417         char volName[32];
 418         char offLineMsg[256];
 419         char motd[256];
 420         cm_conn_t *tcp;
 421         long code;
 422         AFSFetchVolumeStatus volStat;
 423         AFSStoreVolumeStatus storeStat;
 424         cm_volume_t *tvp;
 425         char *cp;
 426         cm_cell_t *cellp;
 427         cm_req_t req;
 428
 429         cm_InitReq(&req);
 430
 431         code = cm_ParseIoctlPath(ioctlp, userp, &req, &scp);
 432         if (code) return code;
 433
 434         cellp = cm_FindCellByID(scp->fid.cell);
 435         osi_assert(cellp);
 436
 437         if (scp->flags & CM_SCACHEFLAG_RO) {
 438                 cm_ReleaseSCache(scp);
 439                 return CM_ERROR_READONLY;
 440         }
 441
 442         code = cm_GetVolumeByID(cellp, scp->fid.volume, userp, &req, &tvp);
 443         if (code) {
 444                 cm_ReleaseSCache(scp);
 445                 return code;
 446         }
 447
 448         /* Copy the junk out, using cp as a roving pointer. */
 449         cp = ioctlp->inDatap;
 450         memcpy((char *)&volStat, cp, sizeof(AFSFetchVolumeStatus));
 451         cp += sizeof(AFSFetchVolumeStatus);
 452         strcpy(volName, cp);
 453         cp += strlen(volName)+1;
 454         strcpy(offLineMsg, cp);
 455         cp +=  strlen(offLineMsg)+1;
 456         strcpy(motd, cp);
 457         storeStat.Mask = 0;
 458         if (volStat.MinQuota != -1) {
 459                 storeStat.MinQuota = volStat.MinQuota;
 460                 storeStat.Mask |= AFS_SETMINQUOTA;
 461         }
 462         if (volStat.MaxQuota != -1) {
 463                 storeStat.MaxQuota = volStat.MaxQuota;
 464                 storeStat.Mask |= AFS_SETMAXQUOTA;
 465         }
 466
 467         do {
 468                 code = cm_Conn(&scp->fid, userp, &req, &tcp);
 469                 if (code) continue;
 470
 471                 code = RXAFS_SetVolumeStatus(tcp->callp, scp->fid.volume,
 472                         &storeStat, volName, offLineMsg, motd);
 473         } while (cm_Analyze(tcp, userp, &req, &scp->fid, NULL, NULL, code));
 474         code = cm_MapRPCError(code, &req);
 475
 476         /* return on failure */
 477         cm_ReleaseSCache(scp);
 478         if (code) {
 479                 return code;
 480         }
 481
 482         /* we are sending parms back to make compat. with prev system.  should
 483          * change interface later to not ask for current status, just set
 484          * new status
 485          */
 486         cp = ioctlp->outDatap;
 487         memcpy(cp, (char *)&volStat, sizeof(VolumeStatus));
 488         cp += sizeof(VolumeStatus);
 489         strcpy(cp, volName);
 490         cp += strlen(volName)+1;
 491         strcpy(cp, offLineMsg);
 492         cp += strlen(offLineMsg)+1;
 493         strcpy(cp, motd);
 494         cp += strlen(motd)+1;
 495
 496         /* now return updated return data pointer */
 497         ioctlp->outDatap = cp;
 498
 499         return 0;
 500 }
 501
 502 long cm_IoctlGetVolumeStatus(struct smb_ioctl *ioctlp, struct cm_user *userp)
 503 {
 504         char volName[32];
 505         cm_scache_t *scp;
 506         char offLineMsg[256];
 507         char motd[256];
 508         cm_conn_t *tcp;
 509         register long code;
 510         AFSFetchVolumeStatus volStat;
 511         register char *cp;
 512         char *Name;
 513         char *OfflineMsg;
 514         char *MOTD;
 515         cm_req_t req;
 516
 517         cm_InitReq(&req);
 518
 519         code = cm_ParseIoctlPath(ioctlp, userp, &req, &scp);
 520         if (code) return code;
 521
 522         Name = volName;
 523         OfflineMsg = offLineMsg;
 524         MOTD = motd;
 525         do {
 526                 code = cm_Conn(&scp->fid, userp, &req, &tcp);
 527                 if (code) continue;
 528
 529                 code = RXAFS_GetVolumeStatus(tcp->callp, scp->fid.volume,
 530                         &volStat, &Name, &OfflineMsg, &MOTD);
 531         } while (cm_Analyze(tcp, userp, &req, &scp->fid, NULL, NULL, code));
 532         code = cm_MapRPCError(code, &req);
 533
 534         cm_ReleaseSCache(scp);
 535         if (code) return code;
 536
 537         /* Copy all this junk into msg->im_data, keeping track of the lengths. */
 538         cp = ioctlp->outDatap;
 539         memcpy(cp, (char *)&volStat, sizeof(AFSFetchVolumeStatus));
 540         cp += sizeof(AFSFetchVolumeStatus);
 541         strcpy(cp, volName);
 542         cp += strlen(volName)+1;
 543         strcpy(cp, offLineMsg);
 544         cp += strlen(offLineMsg)+1;
 545         strcpy(cp, motd);
 546         cp += strlen(motd)+1;
 547
 548         /* return new size */
 549         ioctlp->outDatap = cp;
 550
 551         return 0;
 552 }
 553
 554 long cm_IoctlWhereIs(struct smb_ioctl *ioctlp, struct cm_user *userp)
 555 {
 556         long code;
 557         cm_scache_t *scp;
 558         cm_cell_t *cellp;
 559         cm_volume_t *tvp;
 560         cm_serverRef_t *tsrp;
 561         cm_server_t *tsp;
 562         unsigned long volume;
 563         char *cp;
 564         cm_req_t req;
 565
 566         cm_InitReq(&req);
 567
 568         code = cm_ParseIoctlPath(ioctlp, userp, &req, &scp);
 569         if (code) return code;
 570
 571         volume = scp->fid.volume;
 572
 573         cellp = cm_FindCellByID(scp->fid.cell);
 574         osi_assert(cellp);
 575
 576         cm_ReleaseSCache(scp);
 577
 578         code = cm_GetVolumeByID(cellp, volume, userp, &req, &tvp);
 579         if (code) return code;
 580
 581         cp = ioctlp->outDatap;
 582
 583         lock_ObtainMutex(&tvp->mx);
 584         tsrp = cm_GetVolServers(tvp, volume);
 585         lock_ObtainRead(&cm_serverLock);
 586         while(tsrp) {
 587                 tsp = tsrp->server;
 588                 memcpy(cp, (char *)&tsp->addr.sin_addr.s_addr, sizeof(long));
 589                 cp += sizeof(long);
 590                 tsrp = tsrp->next;
 591         }
 592         lock_ReleaseRead(&cm_serverLock);
 593         lock_ReleaseMutex(&tvp->mx);
 594
 595         /* still room for terminating NULL, add it on */
 596         volume = 0;     /* reuse vbl */
 597         memcpy(cp, (char *)&volume, sizeof(long));
 598         cp += sizeof(long);
 599
 600         ioctlp->outDatap = cp;
 601         cm_PutVolume(tvp);
 602         return 0;
 603 }
 604
 605 long cm_IoctlStatMountPoint(struct smb_ioctl *ioctlp, struct cm_user *userp)
 606 {
 607         long code;
 608         cm_scache_t *dscp;
 609         cm_scache_t *scp;
 610         char *cp;
 611         cm_req_t req;
 612
 613         cm_InitReq(&req);
 614
 615         code = cm_ParseIoctlPath(ioctlp, userp, &req, &dscp);
 616         if (code) return code;
 617
 618         cp = ioctlp->inDatap;
 619
 620         code = cm_Lookup(dscp, cp, CM_FLAG_NOMOUNTCHASE, userp, &req, &scp);
 621         cm_ReleaseSCache(dscp);
 622         if (code) return code;
 623
 624         lock_ObtainMutex(&scp->mx);
 625
 626         /* now check that this is a real mount point */
 627         if (scp->fileType != CM_SCACHETYPE_MOUNTPOINT) {
 628                 lock_ReleaseMutex(&scp->mx);
 629                 cm_ReleaseSCache(scp);
 630                 return CM_ERROR_INVAL;
 631         }
 632
 633         code = cm_ReadMountPoint(scp, userp, &req);
 634         if (code == 0) {
 635                 cp = ioctlp->outDatap;
 636                 strcpy(cp, scp->mountPointStringp);
 637                 cp += strlen(cp) + 1;
 638                 ioctlp->outDatap = cp;
 639         }
 640         lock_ReleaseMutex(&scp->mx);
 641         cm_ReleaseSCache(scp);
 642
 643         return code;
 644 }
 645
 646 long cm_IoctlDeleteMountPoint(struct smb_ioctl *ioctlp, struct cm_user *userp)
 647 {
 648         long code;
 649         cm_scache_t *dscp;
 650         cm_scache_t *scp;
 651         char *cp;
 652         cm_req_t req;
 653
 654         cm_InitReq(&req);
 655
 656         code = cm_ParseIoctlPath(ioctlp, userp, &req, &dscp);
 657         if (code) return code;
 658
 659         cp = ioctlp->inDatap;
 660
 661         code = cm_Lookup(dscp, cp, CM_FLAG_NOMOUNTCHASE, userp, &req, &scp);
 662
 663         /* if something went wrong, bail out now */
 664         if (code) {
 665                 goto done;
 666         }
 667
 668         lock_ObtainMutex(&scp->mx);
 669         code = cm_SyncOp(scp, NULL, userp, &req, 0,
 670                 CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
 671         if (code) {
 672                 lock_ReleaseMutex(&scp->mx);
 673                 cm_ReleaseSCache(scp);
 674                 goto done;
 675         }
 676
 677         /* now check that this is a real mount point */
 678         if (scp->fileType != CM_SCACHETYPE_MOUNTPOINT) {
 679                 lock_ReleaseMutex(&scp->mx);
 680                 cm_ReleaseSCache(scp);
 681                 code = CM_ERROR_INVAL;
 682                 goto done;
 683         }
 684
 685         /* time to make the RPC, so drop the lock */
 686         lock_ReleaseMutex(&scp->mx);
 687         cm_ReleaseSCache(scp);
 688
 689         /* easier to do it this way */
 690         code = cm_Unlink(dscp, cp, userp, &req);
 691         if (code == 0 && (dscp->flags & CM_SCACHEFLAG_ANYWATCH))
 692                 smb_NotifyChange(FILE_ACTION_REMOVED,
 693                                  FILE_NOTIFY_CHANGE_DIR_NAME,
 694                                  dscp, cp, NULL, TRUE);
 695
 696 done:
 697         cm_ReleaseSCache(dscp);
 698         return code;
 699 }
 700
 701 long cm_IoctlCheckServers(struct smb_ioctl *ioctlp, struct cm_user *userp)
 702 {
 703         cm_cell_t *cellp;
 704         chservinfo_t csi;
 705         char *tp;
 706         char *cp;
 707         long temp;
 708         cm_server_t *tsp;
 709         int haveCell;
 710
 711         cm_SkipIoctlPath(ioctlp);       /* we don't care about the path */
 712         tp = ioctlp->inDatap;
 713         haveCell = 0;
 714
 715         memcpy(&temp, tp, sizeof(temp));
 716         if (temp == 0x12345678) {       /* For afs3.3 version */
 717                 memcpy(&csi, tp, sizeof(csi));
 718                 if (csi.tinterval >= 0) {
 719                         cp = ioctlp->outDatap;
 720                         memcpy(cp, (char *)&cm_daemonCheckInterval, sizeof(long));
 721                         ioctlp->outDatap += sizeof(long);
 722                         if (csi.tinterval > 0) {
 723                                 if (!smb_SUser(userp))
 724                                         return CM_ERROR_NOACCESS;
 725                                 cm_daemonCheckInterval = csi.tinterval;
 726                         }
 727                         return 0;
 728                 }
 729                 if (csi.tsize)
 730                         haveCell = 1;
 731                 temp = csi.tflags;
 732                 cp = csi.tbuffer;
 733         } else {        /* For pre afs3.3 versions */
 734                 memcpy((char *)&temp, ioctlp->inDatap, sizeof(long));
 735                 ioctlp->inDatap = cp = ioctlp->inDatap + sizeof(long);
 736                 if (cp - ioctlp->inAllocp < ioctlp->inCopied)   /* still more data available */
 737                         haveCell = 1;
 738         }
 739
 740         /*
 741          * 1: fast check, don't contact servers.
 742          * 2: local cell only.
 743          */
 744         if (haveCell) {
 745                 /* have cell name, too */
 746                 cellp = cm_GetCell(cp, 0);
 747                 if (!cellp) return CM_ERROR_NOSUCHCELL;
 748         }
 749         else cellp = (cm_cell_t *) 0;
 750         if (!cellp && (temp & 2)) {
 751                 /* use local cell */
 752                 cellp = cm_FindCellByID(1);
 753         }
 754         if (!(temp & 1)) {      /* if not fast, call server checker routine */
 755                 /* check down servers */
 756                 cm_CheckServers(CM_FLAG_CHECKDOWNSERVERS | CM_FLAG_CHECKUPSERVERS,
 757                         cellp);
 758         }
 759
 760         /* now return the current down server list */
 761         cp = ioctlp->outDatap;
 762         lock_ObtainRead(&cm_serverLock);
 763         for(tsp = cm_allServersp; tsp; tsp=tsp->allNextp) {
 764                 if (cellp && tsp->cellp != cellp) continue;     /* cell spec'd and wrong */
 765                 if ((tsp->flags & CM_SERVERFLAG_DOWN)
 766                         && tsp->type == CM_SERVER_FILE) {
 767                         memcpy(cp, (char *)&tsp->addr.sin_addr.s_addr, sizeof(long));
 768                         cp += sizeof(long);
 769                 }
 770         }
 771         lock_ReleaseRead(&cm_serverLock);
 772
 773         ioctlp->outDatap = cp;
 774         return 0;
 775 }
 776
 777 long cm_IoctlGag(struct smb_ioctl *ioctlp, struct cm_user *userp)
 778 {
 779         /* we don't print anything superfluous, so we don't support the gag call */
 780         return CM_ERROR_INVAL;
 781 }
 782
 783 long cm_IoctlCheckVolumes(struct smb_ioctl *ioctlp, struct cm_user *userp)
 784 {
 785         cm_CheckVolumes();
 786         return 0;
 787 }
 788
 789 long cm_IoctlSetCacheSize(struct smb_ioctl *ioctlp, struct cm_user *userp)
 790 {
 791         long temp;
 792         long code;
 793
 794         cm_SkipIoctlPath(ioctlp);
 795
 796         memcpy(&temp, ioctlp->inDatap, sizeof(temp));
 797         if (temp == 0) temp = buf_nOrigBuffers;
 798         else {
 799                 /* temp is in 1K units, convert to # of buffers */
 800                 temp = temp / (buf_bufferSize / 1024);
 801         }
 802
 803         /* now adjust the cache size */
 804         code = buf_SetNBuffers(temp);
 805
 806         return code;
 807 }
 808
 809 long cm_IoctlTraceControl(struct smb_ioctl *ioctlp, struct cm_user *userp)
 810 {
 811         long inValue;
 812
 813         cm_SkipIoctlPath(ioctlp);
 814
 815         memcpy(&inValue, ioctlp->inDatap, sizeof(long));
 816
 817         /* print trace */
 818         if (inValue & 8) {
 819                 afsd_ForceTrace(FALSE);
 820         }
 821
 822         if (inValue & 2) {
 823                 /* set tracing value to low order bit */
 824                 if ((inValue & 1) == 0) {
 825                         /* disable tracing */
 826                         osi_LogDisable(afsd_logp);
 827                 }
 828                 else {
 829                         /* enable tracing */
 830                         osi_LogEnable(afsd_logp);
 831                 }
 832         }
 833
 834         /* see if we're supposed to do a reset, too */
 835         if (inValue & 4) {
 836                 osi_LogReset(afsd_logp);
 837         }
 838
 839         /* and copy out tracing flag */
 840         inValue = afsd_logp->enabled;   /* use as a temp vbl */
 841         memcpy(ioctlp->outDatap, &inValue, sizeof(long));
 842         ioctlp->outDatap += sizeof(long);
 843         return 0;
 844 }
 845
 846 long cm_IoctlGetCacheParms(struct smb_ioctl *ioctlp, struct cm_user *userp)
 847 {
 848         cm_cacheParms_t parms;
 849
 850         memset(&parms, 0, sizeof(parms));
 851
 852         /* first we get, in 1K units, the cache size */
 853         parms.parms[0] = buf_nbuffers * (buf_bufferSize / 1024);
 854
 855         /* and then the actual # of buffers in use (not in the free list, I guess,
 856          * will be what we do).
 857          */
 858         parms.parms[1] = (buf_nbuffers - buf_CountFreeList()) * (buf_bufferSize / 1024);
 859
 860         memcpy(ioctlp->outDatap, &parms, sizeof(parms));
 861         ioctlp->outDatap += sizeof(parms);
 862
 863         return 0;
 864 }
 865
 866 long cm_IoctlGetCell(struct smb_ioctl *ioctlp, struct cm_user *userp)
 867 {
 868         long whichCell;
 869         long magic = 0;
 870         cm_cell_t *tcellp;
 871         cm_serverRef_t *serverRefp;
 872         cm_server_t *serverp;
 873         long i;
 874         char *cp;
 875         char *tp;
 876         char *basep;
 877
 878         cm_SkipIoctlPath(ioctlp);
 879
 880         tp = ioctlp->inDatap;
 881
 882         memcpy((char *)&whichCell, tp, sizeof(long));
 883         tp += sizeof(long);
 884
 885         /* see if more than one long passed in, ignoring the null pathname (the -1) */
 886         if (ioctlp->inCopied-1 > sizeof(long)) {
 887                 memcpy((char *)&magic, tp, sizeof(long));
 888         }
 889
 890         lock_ObtainRead(&cm_cellLock);
 891         for(tcellp = cm_allCellsp; tcellp; tcellp = tcellp->nextp) {
 892                 if (whichCell == 0) break;
 893                 whichCell--;
 894         }
 895         lock_ReleaseRead(&cm_cellLock);
 896         if (tcellp) {
 897                 int max = 8;
 898
 899                 cp = ioctlp->outDatap;
 900
 901                 if (magic == 0x12345678) {
 902                         memcpy(cp, (char *)&magic, sizeof(long));
 903                         max = 13;
 904                 }
 905                 memset(cp, 0, max * sizeof(long));
 906                 basep = cp;
 907                 lock_ObtainRead(&cm_serverLock);        /* for going down server list */
 908                 serverRefp = tcellp->vlServersp;
 909                 for(i=0; i<max; i++) {
 910                         if (!serverRefp) break;
 911                         serverp = serverRefp->server;
 912                         memcpy(cp, &serverp->addr.sin_addr.s_addr, sizeof(long));
 913                         cp += sizeof(long);
 914                         serverRefp = serverRefp->next;
 915                 }
 916                 lock_ReleaseRead(&cm_serverLock);
 917                 cp = basep + max * sizeof(afs_int32);
 918                 strcpy(cp, tcellp->namep);
 919                 cp += strlen(tcellp->namep)+1;
 920                 ioctlp->outDatap = cp;
 921         }
 922
 923         if (tcellp) return 0;
 924         else return CM_ERROR_NOMORETOKENS;      /* mapped to EDOM */
 925 }
 926
 927 extern long cm_AddCellProc(void *rockp, struct sockaddr_in *addrp, char *namep);
 928
 929 long cm_IoctlNewCell(struct smb_ioctl *ioctlp, struct cm_user *userp)
 930 {
 931     /* NT cache manager will read cell information from afsdcell.ini each time
 932      * cell is accessed. So, this call is necessary only if list of server for a cell
 933      * changes (or IP addresses of cell servers changes).
 934      * All that needs to be done is to refresh server information for all cells that
 935      * are already loaded.
 936
 937      * cell list will be cm_CellLock and cm_ServerLock will be held for write.
 938     */
 939
 940     cm_cell_t *tcellp;
 941
 942     cm_SkipIoctlPath(ioctlp);
 943     lock_ObtainWrite(&cm_cellLock);
 944
 945     for(tcellp = cm_allCellsp; tcellp; tcellp=tcellp->nextp)
 946     {
 947         /* delete all previous server lists - cm_FreeServerList will ask for write on cm_ServerLock*/
 948         cm_FreeServerList(&tcellp->vlServersp);
 949         tcellp->vlServersp = NULL;
 950         cm_SearchCellFile(tcellp->namep, tcellp->namep, cm_AddCellProc, tcellp);
 951         cm_RandomizeServer(&tcellp->vlServersp);
 952     }
 953
 954     lock_ReleaseWrite(&cm_cellLock);
 955     return 0;
 956 }
 957
 958 long cm_IoctlGetWsCell(smb_ioctl_t *ioctlp, cm_user_t *userp)
 959 {
 960         /* if we don't know our default cell, return failure */
 961         if (cm_rootCellp == NULL) {
 962                 return CM_ERROR_NOSUCHCELL;
 963         }
 964
 965         /* return the default cellname to the caller */
 966         strcpy(ioctlp->outDatap, cm_rootCellp->namep);
 967         ioctlp->outDatap += strlen(ioctlp->outDatap) +1;
 968
 969         /* done: success */
 970         return 0;
 971 }
 972
 973 long cm_IoctlSysName(struct smb_ioctl *ioctlp, struct cm_user *userp)
 974 {
 975         long setSysName;
 976         char *cp;
 977
 978         cm_SkipIoctlPath(ioctlp);
 979
 980         memcpy(&setSysName, ioctlp->inDatap, sizeof(long));
 981         ioctlp->inDatap += sizeof(long);
 982
 983         if (setSysName) {
 984                 strcpy(cm_sysName, ioctlp->inDatap);
 985         }
 986         else {
 987                 /* return the sysname to the caller */
 988                 setSysName = 1; /* really means "found sys name */
 989                 cp = ioctlp->outDatap;
 990                 memcpy(cp, &setSysName, sizeof(long));
 991                 cp += sizeof(long);     /* skip found flag */
 992                 strcpy(cp, cm_sysName);
 993                 cp += strlen(cp) + 1;   /* skip name and terminating null char */
 994                 ioctlp->outDatap = cp;
 995         }
 996
 997         /* done: success */
 998         return 0;
 999 }
1000
1001 long cm_IoctlGetCellStatus(struct smb_ioctl *ioctlp, struct cm_user *userp)
1002 {
1003         long temp;
1004         cm_cell_t *cellp;
1005
1006         cm_SkipIoctlPath(ioctlp);
1007
1008         cellp = cm_GetCell(ioctlp->inDatap, 0);
1009         if (!cellp) return CM_ERROR_NOSUCHCELL;
1010
1011         temp = 0;
1012         lock_ObtainMutex(&cellp->mx);
1013         if (cellp->flags & CM_CELLFLAG_SUID)
1014                 temp |= CM_SETCELLFLAG_SUID;
1015         lock_ReleaseMutex(&cellp->mx);
1016
1017         /* now copy out parm */
1018         memcpy(ioctlp->outDatap, &temp, sizeof(long));
1019         ioctlp->outDatap += sizeof(long);
1020
1021         return 0;
1022 }
1023
1024 long cm_IoctlSetCellStatus(struct smb_ioctl *ioctlp, struct cm_user *userp)
1025 {
1026         long temp;
1027         cm_cell_t *cellp;
1028
1029         cm_SkipIoctlPath(ioctlp);
1030
1031         cellp = cm_GetCell(ioctlp->inDatap + 2*sizeof(long), 0);
1032         if (!cellp) return CM_ERROR_NOSUCHCELL;
1033
1034         memcpy((char *)&temp, ioctlp->inDatap, sizeof(long));
1035
1036         lock_ObtainMutex(&cellp->mx);
1037         if (temp & CM_SETCELLFLAG_SUID)
1038                 cellp->flags |= CM_CELLFLAG_SUID;
1039         else
1040                 cellp->flags &= ~CM_CELLFLAG_SUID;
1041         lock_ReleaseMutex(&cellp->mx);
1042
1043         return 0;
1044 }
1045
1046 long cm_IoctlSetSPrefs(struct smb_ioctl *ioctlp, struct cm_user *userp)
1047 {
1048         cm_SSetPref_t     *spin; /* input */
1049         cm_SPref_t        *srvin;   /* one input component */
1050         cm_server_t       *tsp;
1051         int               i, vlonly, noServers, type;
1052         struct sockaddr_in      tmp;
1053         unsigned short    rank;
1054
1055         cm_SkipIoctlPath(ioctlp);       /* we don't care about the path */
1056
1057         spin       = (cm_SSetPref_t *)ioctlp->inDatap;
1058         noServers  = spin->num_servers;
1059         vlonly     = spin->flags;
1060         if ( vlonly )
1061                 type = CM_SERVER_VLDB;
1062         else    type = CM_SERVER_FILE;
1063
1064         for ( i=0; i < noServers; i++)
1065         {
1066                 srvin          = &(spin->servers[i]);
1067                 rank           = srvin->rank + (rand() & 0x000f);
1068                 tmp.sin_addr   = srvin->host;
1069                 tmp.sin_family = AF_INET;
1070
1071                 tsp = cm_FindServer(&tmp, type);
1072                 if ( tsp )              /* an existing server */
1073                 {
1074                         tsp->ipRank = rank; /* no need to protect by mutex*/
1075
1076                         if ( type == CM_SERVER_FILE) /* fileserver */
1077                         {
1078                             /* find volumes which might have RO copy
1079                             /* on server and change the ordering of
1080                             ** their RO list */
1081                             cm_ChangeRankVolume(tsp);
1082                         }
1083                         else
1084                         {
1085                             /* set preferences for an existing vlserver */
1086                             cm_ChangeRankCellVLServer(tsp);
1087                         }
1088                 }
1089                 else                    /* add a new server without a cell*/
1090                 {
1091                         tsp = cm_NewServer(&tmp, type, NULL);
1092                         tsp->ipRank = rank;
1093                 }
1094                 cm_PutServer(tsp);
1095         }
1096         return 0;
1097 }
1098
1099 long cm_IoctlGetSPrefs(struct smb_ioctl *ioctlp, struct cm_user *userp)
1100 {
1101         cm_SPrefRequest_t *spin; /* input */
1102         cm_SPrefInfo_t    *spout;   /* output */
1103         cm_SPref_t        *srvout;   /* one output component */
1104         cm_server_t       *tsp;
1105         int               i, vlonly, noServers;
1106
1107         cm_SkipIoctlPath(ioctlp);       /* we don't care about the path */
1108
1109         spin      = (cm_SPrefRequest_t *)ioctlp->inDatap;
1110         spout     = (cm_SPrefInfo_t *) ioctlp->outDatap;
1111         srvout    = spout->servers;
1112         noServers = spin->num_servers;
1113         vlonly    = spin->flags & CM_SPREF_VLONLY;
1114         spout->num_servers = 0;
1115
1116         lock_ObtainRead(&cm_serverLock); /* get server lock */
1117
1118         for(tsp=cm_allServersp, i=0; tsp && noServers; tsp=tsp->allNextp,i++){
1119                 if (spin->offset > i) {
1120                         continue;    /* catch up to where we left off */
1121                 }
1122
1123                 if ( vlonly && (tsp->type == CM_SERVER_FILE) )
1124                         continue;   /* ignore fileserver for -vlserver option*/
1125                 if ( !vlonly && (tsp->type == CM_SERVER_VLDB) )
1126                         continue;   /* ignore vlservers */
1127
1128                 srvout->host = tsp->addr.sin_addr;
1129                 srvout->rank = tsp->ipRank;
1130                 srvout++;
1131                 spout->num_servers++;
1132                 noServers--;
1133         }
1134         lock_ReleaseRead(&cm_serverLock); /* release server lock */
1135
1136         if ( tsp )      /* we ran out of space in the output buffer */
1137                 spout->next_offset = i;
1138         else
1139                 spout->next_offset = 0;
1140         ioctlp->outDatap += sizeof(cm_SPrefInfo_t) +
1141                         (spout->num_servers -1 ) * sizeof(cm_SPref_t) ;
1142         return 0;
1143 }
1144
1145 long cm_IoctlStoreBehind(struct smb_ioctl *ioctlp, struct cm_user *userp)
1146 {
1147         /* we ignore default asynchrony since we only have one way
1148          * of doing this today.
1149          */
1150         return 0;
1151 }
1152
1153 long cm_IoctlCreateMountPoint(struct smb_ioctl *ioctlp, struct cm_user *userp)
1154 {
1155         char leaf[256];
1156         long code;
1157         cm_scache_t *dscp;
1158         cm_attr_t tattr;
1159         char *cp;
1160         cm_req_t req;
1161         char mpInfo[256];
1162         char fullCell[256];
1163         char volume[256];
1164         char cell[256];
1165         int ttl;
1166
1167         cm_InitReq(&req);
1168
1169         code = cm_ParseIoctlParent(ioctlp, userp, &req, &dscp, leaf);
1170         if (code) return code;
1171
1172         /* Translate chars for the mount point name */
1173         TranslateExtendedChars(leaf);
1174
1175         /*
1176          * The fs command allows the user to specify partial cell names on NT.  These must
1177          * be expanded to the full cell name for mount points so that the mount points will
1178          * work on UNIX clients.
1179          */
1180
1181         /* Extract the possibly partial cell name */
1182         strcpy(cell, ioctlp->inDatap + 1);      /* Skip the mp type character */
1183
1184         if (cp = strchr(cell, ':')) {
1185                 /* Extract the volume name */
1186                 *cp = 0;
1187                 strcpy(volume,  cp + 1);
1188
1189                 /* Get the full name for this cell */
1190                 code = cm_SearchCellFile(cell, fullCell, 0, 0);
1191 #ifdef AFS_AFSDB_ENV
1192                 if (code && cm_dnsEnabled)
1193                   code = cm_SearchCellByDNS(cell, fullCell, &ttl, 0, 0);
1194 #endif
1195                   if (code)
1196                         return CM_ERROR_NOSUCHCELL;
1197
1198                 sprintf(mpInfo, "%c%s:%s", *ioctlp->inDatap, fullCell, volume);
1199         } else {
1200                 /* No cell name specified */
1201                 strcpy(mpInfo, ioctlp->inDatap);
1202         }
1203
1204 #ifdef AFS_FREELANCE_CLIENT
1205         if (cm_freelanceEnabled && dscp == cm_rootSCachep) {
1206           /* we are adding the mount point to the root dir., so call
1207              the freelance code to do the add. */
1208           code = cm_FreelanceAddMount(leaf, fullCell, volume, NULL);
1209           return code;
1210         }
1211 #endif
1212         /* create the symlink with mode 644.  The lack of X bits tells
1213          * us that it is a mount point.
1214          */
1215         tattr.mask = CM_ATTRMASK_UNIXMODEBITS | CM_ATTRMASK_CLIENTMODTIME;
1216         tattr.unixModeBits = 0644;
1217         tattr.clientModTime = time(NULL);
1218
1219         code = cm_SymLink(dscp, leaf, mpInfo, 0, &tattr, userp, &req);
1220         if (code == 0 && (dscp->flags & CM_SCACHEFLAG_ANYWATCH))
1221                 smb_NotifyChange(FILE_ACTION_ADDED,
1222                                  FILE_NOTIFY_CHANGE_DIR_NAME,
1223                                  dscp, leaf, NULL, TRUE);
1224
1225         cm_ReleaseSCache(dscp);
1226
1227         return code;
1228 }
1229
1230 long cm_IoctlSymlink(struct smb_ioctl *ioctlp, struct cm_user *userp)
1231 {
1232         char leaf[256];
1233         long code;
1234         cm_scache_t *dscp;
1235         cm_attr_t tattr;
1236         char *cp;
1237         cm_req_t req;
1238
1239         cm_InitReq(&req);
1240
1241         code = cm_ParseIoctlParent(ioctlp, userp, &req, &dscp, leaf);
1242         if (code) return code;
1243
1244         /* Translate chars for the link name */
1245         TranslateExtendedChars(leaf);
1246
1247         /* Translate chars for the linked to name */
1248         TranslateExtendedChars(ioctlp->inDatap);
1249
1250         cp = ioctlp->inDatap;           /* contents of link */
1251
1252         /* Create symlink with mode 0755. */
1253         tattr.mask = CM_ATTRMASK_UNIXMODEBITS;
1254         tattr.unixModeBits = 0755;
1255
1256         code = cm_SymLink(dscp, leaf, cp, 0, &tattr, userp, &req);
1257         if (code == 0 && (dscp->flags & CM_SCACHEFLAG_ANYWATCH))
1258                 smb_NotifyChange(FILE_ACTION_ADDED,
1259                                  FILE_NOTIFY_CHANGE_FILE_NAME
1260                                    | FILE_NOTIFY_CHANGE_DIR_NAME,
1261                                  dscp, leaf, NULL, TRUE);
1262
1263         cm_ReleaseSCache(dscp);
1264
1265         return code;
1266 }
1267
1268 extern long cm_AssembleLink(cm_scache_t *linkScp, char *pathSuffixp,
1269         cm_scache_t **newRootScpp, cm_space_t **newSpaceBufferp,
1270         cm_user_t *userp, cm_req_t *reqp);
1271
1272 long cm_IoctlListlink(struct smb_ioctl *ioctlp, struct cm_user *userp)
1273 {
1274         long code;
1275         cm_scache_t *dscp;
1276         cm_scache_t *scp;
1277         char *cp;
1278         cm_space_t *spacep;
1279         cm_scache_t *newRootScp;
1280         cm_req_t req;
1281
1282         cm_InitReq(&req);
1283
1284         code = cm_ParseIoctlPath(ioctlp, userp, &req, &dscp);
1285         if (code) return code;
1286
1287         cp = ioctlp->inDatap;
1288
1289         code = cm_Lookup(dscp, cp, CM_FLAG_NOMOUNTCHASE, userp, &req, &scp);
1290         cm_ReleaseSCache(dscp);
1291         if (code) return code;
1292
1293         /* Check that it's a real symlink */
1294         if (scp->fileType != CM_SCACHETYPE_SYMLINK){
1295                 cm_ReleaseSCache(scp);
1296                 return CM_ERROR_INVAL;
1297         }
1298
1299         code = cm_AssembleLink(scp, "", &newRootScp, &spacep, userp, &req);
1300         cm_ReleaseSCache(scp);
1301         if (code == 0) {
1302                 cp = ioctlp->outDatap;
1303                 if (newRootScp != NULL) {
1304             strcpy(cp, cm_mountRoot);
1305             strcat(cp, "/");
1306                         cp += strlen(cp);
1307                 }
1308                 strcpy(cp, spacep->data);
1309                 cp += strlen(cp) + 1;
1310                 ioctlp->outDatap = cp;
1311                 cm_FreeSpace(spacep);
1312                 if (newRootScp != NULL)
1313                         cm_ReleaseSCache(newRootScp);
1314         }
1315
1316         return code;
1317 }
1318
1319 long cm_IoctlIslink(struct smb_ioctl *ioctlp, struct cm_user *userp)
1320 {/*CHECK FOR VALID SYMLINK*/
1321         long code;
1322         cm_scache_t *dscp;
1323         cm_scache_t *scp;
1324         char *cp;
1325         cm_req_t req;
1326
1327         cm_InitReq(&req);
1328
1329         code = cm_ParseIoctlPath(ioctlp, userp, &req, &dscp);
1330         if (code) return code;
1331
1332         cp = ioctlp->inDatap;
1333         osi_LogEvent("cm_IoctlListlink",NULL," name[%s]",cp);
1334
1335         code = cm_Lookup(dscp, cp, CM_FLAG_NOMOUNTCHASE, userp, &req, &scp);
1336         cm_ReleaseSCache(dscp);
1337         if (code) return code;
1338
1339         /* Check that it's a real symlink */
1340         if (scp->fileType != CM_SCACHETYPE_SYMLINK)
1341                 code = CM_ERROR_INVAL;
1342         cm_ReleaseSCache(scp);
1343         return code;
1344 }
1345
1346 long cm_IoctlDeletelink(struct smb_ioctl *ioctlp, struct cm_user *userp)
1347 {
1348         long code;
1349         cm_scache_t *dscp;
1350         cm_scache_t *scp;
1351         char *cp;
1352         cm_req_t req;
1353
1354         cm_InitReq(&req);
1355
1356         code = cm_ParseIoctlPath(ioctlp, userp, &req, &dscp);
1357         if (code) return code;
1358
1359         cp = ioctlp->inDatap;
1360
1361         code = cm_Lookup(dscp, cp, CM_FLAG_NOMOUNTCHASE, userp, &req, &scp);
1362
1363         /* if something went wrong, bail out now */
1364         if (code) {
1365                 goto done;
1366         }
1367
1368         lock_ObtainMutex(&scp->mx);
1369         code = cm_SyncOp(scp, NULL, userp, &req, 0,
1370                 CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
1371         if (code) {
1372                 lock_ReleaseMutex(&scp->mx);
1373                 cm_ReleaseSCache(scp);
1374                 goto done;
1375         }
1376
1377         /* now check that this is a real symlink */
1378         if (scp->fileType != CM_SCACHETYPE_SYMLINK) {
1379                 lock_ReleaseMutex(&scp->mx);
1380                 cm_ReleaseSCache(scp);
1381                 code = CM_ERROR_INVAL;
1382                 goto done;
1383         }
1384
1385         /* time to make the RPC, so drop the lock */
1386         lock_ReleaseMutex(&scp->mx);
1387         cm_ReleaseSCache(scp);
1388
1389         /* easier to do it this way */
1390         code = cm_Unlink(dscp, cp, userp, &req);
1391         if (code == 0 && (dscp->flags & CM_SCACHEFLAG_ANYWATCH))
1392                 smb_NotifyChange(FILE_ACTION_REMOVED,
1393                                  FILE_NOTIFY_CHANGE_FILE_NAME
1394                                    | FILE_NOTIFY_CHANGE_DIR_NAME,
1395                                  dscp, cp, NULL, TRUE);
1396
1397 done:
1398         cm_ReleaseSCache(dscp);
1399         return code;
1400 }
1401
1402 long cm_IoctlSetToken(struct smb_ioctl *ioctlp, struct cm_user *userp)
1403 {
1404         char *saveDataPtr;
1405         char *tp;
1406         int ticketLen;
1407         char *ticket;
1408         int ctSize;
1409         struct ClearToken ct;
1410         cm_cell_t *cellp;
1411         cm_ucell_t *ucellp;
1412         char *uname = NULL;
1413         afs_uuid_t uuid;
1414         int flags;
1415         char sessionKey[8];
1416         char *smbname;
1417
1418         saveDataPtr = ioctlp->inDatap;
1419
1420         cm_SkipIoctlPath(ioctlp);
1421
1422         tp = ioctlp->inDatap;
1423
1424         /* ticket length */
1425         memcpy(&ticketLen, tp, sizeof(ticketLen));
1426         tp += sizeof(ticketLen);
1427         if (ticketLen < MINKTCTICKETLEN || ticketLen > MAXKTCTICKETLEN)
1428                 return CM_ERROR_INVAL;
1429
1430         /* remember ticket and skip over it for now */
1431         ticket = tp;
1432         tp += ticketLen;
1433
1434         /* clear token size */
1435         memcpy(&ctSize, tp, sizeof(ctSize));
1436         tp += sizeof(ctSize);
1437         if (ctSize != sizeof(struct ClearToken))
1438                 return CM_ERROR_INVAL;
1439
1440         /* clear token */
1441         memcpy(&ct, tp, ctSize);
1442         tp += ctSize;
1443         if (ct.AuthHandle == -1)
1444                 ct.AuthHandle = 999;    /* more rxvab compat stuff */
1445
1446         /* more stuff, if any */
1447         if (ioctlp->inCopied > tp - saveDataPtr) {
1448                 /* flags:  logon flag */
1449                 memcpy(&flags, tp, sizeof(int));
1450                 tp += sizeof(int);
1451
1452                 /* cell name */
1453                 cellp = cm_GetCell(tp, CM_FLAG_CREATE);
1454                 if (!cellp) return CM_ERROR_NOSUCHCELL;
1455                 tp += strlen(tp) + 1;
1456
1457                 /* user name */
1458                 uname = tp;
1459                 tp += strlen(tp) + 1;
1460
1461         if (flags & PIOCTL_LOGON) {
1462                   /* SMB user name with which to associate tokens */
1463                   smbname = tp;
1464                   fprintf(stderr, "SMB name = %s\n", smbname);
1465                   tp += strlen(tp) + 1;
1466         }
1467
1468 #ifndef DJGPP   /* for win95, session key is back in pioctl */
1469                 /* uuid */
1470                 memcpy(&uuid, tp, sizeof(uuid));
1471                 if (!cm_FindTokenEvent(uuid, sessionKey))
1472                         return CM_ERROR_INVAL;
1473 #endif /* !DJGPP */
1474         } else
1475                 cellp = cm_rootCellp;
1476
1477         if (flags & PIOCTL_LOGON) {
1478           userp = smb_FindCMUserByName(smbname, ioctlp->fidp->vcp->rname);
1479         }
1480
1481         /* store the token */
1482         lock_ObtainMutex(&userp->mx);
1483         ucellp = cm_GetUCell(userp, cellp);
1484         ucellp->ticketLen = ticketLen;
1485         if (ucellp->ticketp)
1486                 free(ucellp->ticketp);  /* Discard old token if any */
1487         ucellp->ticketp = malloc(ticketLen);
1488         memcpy(ucellp->ticketp, ticket, ticketLen);
1489 #ifndef DJGPP
1490         /*
1491          * Get the session key from the RPC, rather than from the pioctl.
1492          */
1493         /*
1494         memcpy(&ucellp->sessionKey, ct.HandShakeKey, sizeof(ct.HandShakeKey));
1495          */
1496         memcpy(ucellp->sessionKey.data, sessionKey, sizeof(sessionKey));
1497 #else
1498         /* for win95, we are getting the session key from the pioctl */
1499         memcpy(&ucellp->sessionKey, ct.HandShakeKey, sizeof(ct.HandShakeKey));
1500 #endif /* !DJGPP */
1501         ucellp->kvno = ct.AuthHandle;
1502         ucellp->expirationTime = ct.EndTimestamp;
1503         ucellp->gen++;
1504         if (uname) strcpy(ucellp->userName, uname);
1505         ucellp->flags |= CM_UCELLFLAG_RXKAD;
1506         lock_ReleaseMutex(&userp->mx);
1507
1508         if (flags & PIOCTL_LOGON) {
1509                 ioctlp->flags |= SMB_IOCTLFLAG_LOGON;
1510         }
1511
1512         cm_ResetACLCache(userp);
1513
1514         return 0;
1515 }
1516
1517 long cm_IoctlGetTokenIter(struct smb_ioctl *ioctlp, struct cm_user *userp)
1518 {
1519         char *tp, *cp;
1520         int iterator;
1521         int temp;
1522         cm_ucell_t *ucellp;
1523         struct ClearToken ct;
1524
1525         cm_SkipIoctlPath(ioctlp);
1526
1527         tp = ioctlp->inDatap;
1528         cp = ioctlp->outDatap;
1529
1530         /* iterator */
1531         memcpy(&iterator, tp, sizeof(iterator));
1532         tp += sizeof(iterator);
1533
1534         lock_ObtainMutex(&userp->mx);
1535
1536         /* look for token */
1537         for (;;iterator++) {
1538                 ucellp = cm_FindUCell(userp, iterator);
1539                 if (!ucellp) {
1540                         lock_ReleaseMutex(&userp->mx);
1541                         return CM_ERROR_NOMORETOKENS;
1542                 }
1543                 if (ucellp->flags & CM_UCELLFLAG_RXKAD)
1544                         break;
1545         }
1546
1547         /* new iterator */
1548         temp = ucellp->iterator + 1;
1549         memcpy(cp, &temp, sizeof(temp));
1550         cp += sizeof(temp);
1551
1552         /* ticket length */
1553         memcpy(cp, &ucellp->ticketLen, sizeof(ucellp->ticketLen));
1554         cp += sizeof(ucellp->ticketLen);
1555
1556         /* ticket */
1557         memcpy(cp, ucellp->ticketp, ucellp->ticketLen);
1558         cp += ucellp->ticketLen;
1559
1560         /* clear token size */
1561         temp = sizeof(ct);
1562         memcpy(cp, &temp, sizeof(temp));
1563         cp += sizeof(temp);
1564
1565         /* clear token */
1566         ct.AuthHandle = ucellp->kvno;
1567 #ifndef DJGPP
1568         /*
1569          * Don't give out a real session key here
1570          */
1571         /*
1572         memcpy(ct.HandShakeKey, &ucellp->sessionKey, sizeof(ct.HandShakeKey));
1573          */
1574         memset(ct.HandShakeKey, 0, sizeof(ct.HandShakeKey));
1575 #else
1576         memcpy(ct.HandShakeKey, &ucellp->sessionKey, sizeof(ct.HandShakeKey));
1577 #endif /* !DJGPP */
1578         ct.ViceId = 37;                 /* XXX */
1579         ct.BeginTimestamp = 0;          /* XXX */
1580         ct.EndTimestamp = ucellp->expirationTime;
1581         memcpy(cp, &ct, sizeof(ct));
1582         cp += sizeof(ct);
1583
1584         /* Primary flag (unused) */
1585         temp = 0;
1586         memcpy(cp, &temp, sizeof(temp));
1587         cp += sizeof(temp);
1588
1589         /* cell name */
1590         strcpy(cp, ucellp->cellp->namep);
1591         cp += strlen(cp) + 1;
1592
1593         /* user name */
1594         strcpy(cp, ucellp->userName);
1595         cp += strlen(cp) + 1;
1596
1597         ioctlp->outDatap = cp;
1598
1599         lock_ReleaseMutex(&userp->mx);
1600
1601         return 0;
1602 }
1603
1604 long cm_IoctlGetToken(struct smb_ioctl *ioctlp, struct cm_user *userp)
1605 {
1606         char *cp;
1607         int temp;
1608         cm_cell_t *cellp;
1609         cm_ucell_t *ucellp;
1610         struct ClearToken ct;
1611         char *tp;
1612 #ifndef DJGPP
1613         afs_uuid_t uuid;
1614 #endif /* !DJGPP */
1615
1616         cm_SkipIoctlPath(ioctlp);
1617
1618         tp = ioctlp->inDatap;
1619
1620         cp = ioctlp->outDatap;
1621
1622         /* cell name is right here */
1623         cellp = cm_GetCell(tp, 0);
1624         if (!cellp) return CM_ERROR_NOSUCHCELL;
1625         tp += strlen(tp) + 1;
1626
1627 #ifndef DJGPP
1628         /* uuid */
1629         memcpy(&uuid, tp, sizeof(uuid));
1630 #endif /* !DJGPP */
1631
1632         lock_ObtainMutex(&userp->mx);
1633
1634         ucellp = cm_GetUCell(userp, cellp);
1635         if (!ucellp || !(ucellp->flags & CM_UCELLFLAG_RXKAD)) {
1636                 lock_ReleaseMutex(&userp->mx);
1637                 return CM_ERROR_NOMORETOKENS;
1638         }
1639
1640         /* ticket length */
1641         memcpy(cp, &ucellp->ticketLen, sizeof(ucellp->ticketLen));
1642         cp += sizeof(ucellp->ticketLen);
1643
1644         /* ticket */
1645         memcpy(cp, ucellp->ticketp, ucellp->ticketLen);
1646         cp += ucellp->ticketLen;
1647
1648         /* clear token size */
1649         temp = sizeof(ct);
1650         memcpy(cp, &temp, sizeof(temp));
1651         cp += sizeof(temp);
1652
1653         /* clear token */
1654         ct.AuthHandle = ucellp->kvno;
1655 #ifndef DJGPP
1656         /*
1657          * Don't give out a real session key here
1658          */
1659         /*
1660         memcpy(ct.HandShakeKey, &ucellp->sessionKey, sizeof(ct.HandShakeKey));
1661          */
1662         memset(ct.HandShakeKey, 0, sizeof(ct.HandShakeKey));
1663 #else
1664         memcpy(ct.HandShakeKey, &ucellp->sessionKey, sizeof(ct.HandShakeKey));
1665 #endif /* !DJGPP */
1666         ct.ViceId = 37;                 /* XXX */
1667         ct.BeginTimestamp = 0;          /* XXX */
1668         ct.EndTimestamp = ucellp->expirationTime;
1669         memcpy(cp, &ct, sizeof(ct));
1670         cp += sizeof(ct);
1671
1672         /* Primary flag (unused) */
1673         temp = 0;
1674         memcpy(cp, &temp, sizeof(temp));
1675         cp += sizeof(temp);
1676
1677         /* cell name */
1678         strcpy(cp, ucellp->cellp->namep);
1679         cp += strlen(cp) + 1;
1680
1681         /* user name */
1682         strcpy(cp, ucellp->userName);
1683         cp += strlen(cp) + 1;
1684
1685         ioctlp->outDatap = cp;
1686
1687         lock_ReleaseMutex(&userp->mx);
1688
1689 #ifndef DJGPP
1690         cm_RegisterNewTokenEvent(uuid, ucellp->sessionKey.data);
1691 #endif /* !DJGPP */
1692
1693         return 0;
1694 }
1695
1696 long cm_IoctlDelToken(struct smb_ioctl *ioctlp, struct cm_user *userp)
1697 {
1698         char *cp;
1699         cm_cell_t *cellp;
1700         cm_ucell_t *ucellp;
1701
1702         cm_SkipIoctlPath(ioctlp);
1703
1704         cp = ioctlp->outDatap;
1705
1706         /* cell name is right here */
1707         cellp = cm_GetCell(ioctlp->inDatap, 0);
1708         if (!cellp) return CM_ERROR_NOSUCHCELL;
1709
1710         lock_ObtainMutex(&userp->mx);
1711
1712         ucellp = cm_GetUCell(userp, cellp);
1713         if (!ucellp) {
1714                 lock_ReleaseMutex(&userp->mx);
1715                 return CM_ERROR_NOMORETOKENS;
1716         }
1717
1718         if (ucellp->ticketp) {
1719                 free(ucellp->ticketp);
1720                 ucellp->ticketp = NULL;
1721         }
1722         ucellp->flags &= ~CM_UCELLFLAG_RXKAD;
1723         ucellp->gen++;
1724
1725         lock_ReleaseMutex(&userp->mx);
1726
1727         cm_ResetACLCache(userp);
1728
1729         return 0;
1730 }
1731
1732 long cm_IoctlDelAllToken(struct smb_ioctl *ioctlp, struct cm_user *userp)
1733 {
1734         cm_ucell_t *ucellp;
1735
1736         lock_ObtainMutex(&userp->mx);
1737
1738         for (ucellp = userp->cellInfop; ucellp; ucellp = ucellp->nextp) {
1739                 ucellp->flags &= ~CM_UCELLFLAG_RXKAD;
1740                 ucellp->gen++;
1741         }
1742
1743         lock_ReleaseMutex(&userp->mx);
1744
1745         cm_ResetACLCache(userp);
1746
1747         return 0;
1748 }
1749
1750 long cm_IoctlMakeSubmount(smb_ioctl_t *ioctlp, cm_user_t *userp)
1751 {
1752         char afspath[MAX_PATH];
1753         char *submountreqp;
1754         int iteration;
1755         int submountDataSize;
1756         char *submountData;
1757         char *submountName;
1758         int nextAutoSubmount;
1759
1760         cm_SkipIoctlPath(ioctlp);
1761
1762         /* Serialize this one, to prevent simultaneous mods
1763          * to afsdsbmt.ini
1764          */
1765         lock_ObtainMutex(&cm_Afsdsbmt_Lock);
1766
1767         /* Parse the input parameters--first the required afs path,
1768          * then the requested submount name (which may be "").
1769          */
1770         cm_NormalizeAfsPath (afspath, ioctlp->inDatap);
1771         submountreqp = ioctlp->inDatap + (strlen(ioctlp->inDatap)+1);
1772
1773         /* If the caller supplied a suggested submount name, see if
1774          * that submount name is in use... if so, the submount's path
1775          * has to match our path.
1776          */
1777         if (submountreqp && *submountreqp) {
1778                 char submountPathNormalized[MAX_PATH];
1779                 char submountPath[MAX_PATH];
1780                 int submountPathLen;
1781
1782                 submountPathLen = GetPrivateProfileString("AFS Submounts",
1783                                         submountreqp, "", submountPath,
1784                                         sizeof(submountPath), "afsdsbmt.ini");
1785
1786                 if ((submountPathLen == 0) ||
1787                     (submountPathLen == sizeof(submountPath) - 1)) {
1788
1789                         /* The suggested submount name isn't in use now--
1790                          * so we can safely map the requested submount name
1791                          * to the supplied path. Remember not to write the
1792                          * leading "/afs" when writing out the submount.
1793                          */
1794                         WritePrivateProfileString("AFS Submounts",
1795                                         submountreqp,
1796                                         (strlen(&afspath[strlen(cm_mountRoot)])) ?
1797                                                   &afspath[strlen(cm_mountRoot)]:"/",
1798                                         "afsdsbmt.ini");
1799
1800                         strcpy(ioctlp->outDatap, submountreqp);
1801                         ioctlp->outDatap += strlen(ioctlp->outDatap) +1;
1802                         lock_ReleaseMutex(&cm_Afsdsbmt_Lock);
1803                         return 0;
1804                 }
1805
1806                 /* The suggested submount name is already in use--if the
1807                  * supplied path matches the submount's path, we can still
1808                  * use the suggested submount name.
1809                  */
1810                 cm_NormalizeAfsPath (submountPathNormalized, submountPath);
1811                 if (!strcmp (submountPathNormalized, afspath)) {
1812                         strcpy(ioctlp->outDatap, submountreqp);
1813                         ioctlp->outDatap += strlen(ioctlp->outDatap) +1;
1814                         lock_ReleaseMutex(&cm_Afsdsbmt_Lock);
1815                         return 0;
1816                 }
1817         }
1818
1819         /* At this point, the user either didn't request a particular
1820          * submount name, or that submount name couldn't be used.
1821          * Look through afsdsbmt.ini to see if there are any submounts
1822          * already associated with the specified path. The first
1823          * step in doing that search is to load the AFS Submounts
1824          * section of afsdsbmt.ini into memory.
1825          */
1826
1827         submountDataSize = 1024;
1828         submountData = malloc (submountDataSize);
1829
1830         for (iteration = 0; iteration < 5; ++iteration) {
1831
1832                 int sectionSize;
1833                 sectionSize = GetPrivateProfileString("AFS Submounts",
1834                                         NULL, "", submountData,
1835                                         submountDataSize, "afsdsbmt.ini");
1836                 if (sectionSize < submountDataSize-2)
1837                         break;
1838
1839                 free (submountData);
1840                 submountDataSize *= 2;
1841                 submountData = malloc (submountDataSize);
1842         }
1843
1844         /* Having obtained a list of all available submounts, start
1845          * searching that list for a path which matches the requested
1846          * AFS path. We'll also keep track of the highest "auto15"/"auto47"
1847          * submount, in case we need to add a new one later.
1848          */
1849
1850         nextAutoSubmount = 1;
1851
1852         for (submountName = submountData;
1853                 submountName && *submountName;
1854                 submountName += 1+strlen(submountName)) {
1855
1856                 char submountPathNormalized[MAX_PATH];
1857                 char submountPath[MAX_PATH] = "";
1858                 int submountPathLen;
1859
1860                 /* If this is an Auto### submount, remember its ### value */
1861
1862                 if ((!strnicmp (submountName, "auto", 4)) &&
1863                     (isdigit (submountName[strlen("auto")]))) {
1864                         int thisAutoSubmount;
1865                         thisAutoSubmount = atoi (&submountName[strlen("auto")]);
1866                         nextAutoSubmount = max (nextAutoSubmount,
1867                                                 thisAutoSubmount+1);
1868                 }
1869
1870                 /* We have the name of a submount in the AFS Submounts
1871                  * section; read that entry to find out what path it
1872                  * maps to.
1873                  */
1874                 submountPathLen = GetPrivateProfileString("AFS Submounts",
1875                                         submountName, "", submountPath,
1876                                         sizeof(submountPath), "afsdsbmt.ini");
1877
1878                 if ((submountPathLen == 0) ||
1879                     (submountPathLen == sizeof(submountPath) - 1)) {
1880                         continue;
1881                 }
1882
1883                 /* See if the path for this submount matches the path
1884                  * that our caller specified. If so, we can return
1885                  * this submount.
1886                  */
1887                 cm_NormalizeAfsPath (submountPathNormalized, submountPath);
1888                 if (!strcmp (submountPathNormalized, afspath)) {
1889
1890                         strcpy(ioctlp->outDatap, submountName);
1891                         ioctlp->outDatap += strlen(ioctlp->outDatap) +1;
1892                         free (submountData);
1893                         lock_ReleaseMutex(&cm_Afsdsbmt_Lock);
1894                         return 0;
1895
1896                 }
1897         }
1898
1899         free (submountData);
1900
1901         /* We've been through the entire list of existing submounts, and
1902          * didn't find any which matched the specified path. So, we'll
1903          * just have to add one. Remember not to write the leading "/afs"
1904          * when writing out the submount.
1905          */
1906
1907         sprintf(ioctlp->outDatap, "auto%ld", nextAutoSubmount);
1908
1909         WritePrivateProfileString("AFS Submounts", ioctlp->outDatap,
1910                                   (strlen(&afspath[lstrlen(cm_mountRoot)])) ?
1911                                   &afspath[lstrlen(cm_mountRoot)]:"/",
1912                                   "afsdsbmt.ini");
1913
1914         ioctlp->outDatap += strlen(ioctlp->outDatap) +1;
1915         lock_ReleaseMutex(&cm_Afsdsbmt_Lock);
1916         return 0;
1917 }
1918
1919 long cm_IoctlGetRxkcrypt(smb_ioctl_t *ioctlp, cm_user_t *userp)
1920 {
1921         memcpy(ioctlp->outDatap, &cryptall, sizeof(cryptall));
1922         ioctlp->outDatap += sizeof(cryptall);
1923
1924         return 0;
1925 }
1926
1927 long cm_IoctlSetRxkcrypt(smb_ioctl_t *ioctlp, cm_user_t *userp)
1928 {
1929         cm_SkipIoctlPath(ioctlp);
1930
1931         memcpy(&cryptall, ioctlp->inDatap, sizeof(cryptall));
1932
1933         return 0;
1934 }
1935
1936 #ifdef DJGPP
1937 extern int afsd_shutdown(int);
1938 extern int afs_shutdown;
1939
1940 long cm_IoctlShutdown(smb_ioctl_t *ioctlp, cm_user_t *userp) {
1941   afs_shutdown = 1;   /* flag to shut down */
1942   return 0;
1943 }
1944 #endif /* DJGPP */
1945
1946 long cm_IoctlGetSMBName(smb_ioctl_t *ioctlp, cm_user_t *userp)
1947 {
1948   smb_user_t *uidp = ioctlp->uidp;
1949
1950   if (uidp && uidp->unp) {
1951     memcpy(ioctlp->outDatap, uidp->unp->name, strlen(uidp->unp->name));
1952     ioctlp->outDatap += strlen(uidp->unp->name);
1953         }
1954
1955   return 0;
1956 }
1957
1958 /*
1959  * functions to dump contents of various structures.
1960  * In debug build (linked with crt debug library) will dump allocated but not freed memory
1961  */
1962 extern int cm_DumpSCache(FILE *outputFile, char *cookie);
1963 extern int cm_DumpBufHashTable(FILE *outputFile, char *cookie);
1964 extern int smb_DumpVCP(FILE *outputFile, char *cookie);
1965
1966 long cm_IoctlMemoryDump(struct smb_ioctl *ioctlp, struct cm_user *userp)
1967 {
1968     long inValue = 0;
1969     HANDLE hLogFile;
1970     char logfileName[MAX_PATH+1];
1971     char *cookie;
1972
1973 #ifdef _DEBUG
1974     static _CrtMemState memstate;
1975 #endif
1976
1977     cm_SkipIoctlPath(ioctlp);
1978     memcpy(&inValue, ioctlp->inDatap, sizeof(long));
1979
1980     GetWindowsDirectory(logfileName, sizeof(logfileName));
1981     strncat(logfileName, "\\afsd_alloc.log", sizeof(logfileName));
1982
1983     hLogFile = CreateFile(logfileName, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
1984
1985     if (!hLogFile)
1986     {
1987       /* error */
1988       inValue = -1;
1989       memcpy(ioctlp->outDatap, &inValue, sizeof(long));
1990       ioctlp->outDatap += sizeof(long);
1991
1992       return 0;
1993     }
1994
1995     SetFilePointer(hLogFile, 0, NULL, FILE_END);
1996
1997     cookie = inValue ? "b" : "e";
1998
1999 #ifdef _DEBUG
2000
2001     if (inValue)
2002     {
2003       _CrtMemCheckpoint(&memstate);
2004     }
2005     else
2006     {
2007         _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
2008         _CrtSetReportFile(_CRT_WARN, hLogFile);
2009         _CrtMemDumpAllObjectsSince(&memstate);
2010     }
2011 #endif
2012
2013     /* dump all interesting data */
2014     cm_DumpSCache(hLogFile, cookie);
2015     cm_DumpBufHashTable(hLogFile, cookie);
2016     smb_DumpVCP(hLogFile, cookie);
2017
2018     CloseHandle(hLogFile);
2019
2020     memcpy(ioctlp->outDatap, &inValue, sizeof(long));
2021     ioctlp->outDatap += sizeof(long);
2022
2023     return 0;
2024 }