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