23c5f78c15078b95596237475912fae1a9b99330
[openafs.git] / 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 }