smb-string-conversion-20080902
[openafs.git] / src / WINNT / afsd / smb_ioctl.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afs/param.h>
11 #include <afs/stds.h>
12
13 #include <windows.h>
14 #include <stdlib.h>
15 #include <malloc.h>
16 #include <string.h>
17 #include <stdio.h>
18 #include <time.h>
19 #include <strsafe.h>
20
21 #include <osi.h>
22
23 #include "afsd.h"
24
25 #include "smb.h"
26
27 #include "cm_rpc.h"
28 #include "afs/afsrpc.h"
29 #include "afs/auth.h"
30
31 smb_ioctlProc_t *smb_ioctlProcsp[SMB_IOCTL_MAXPROCS];
32
33 void 
34 smb_InitIoctl(void)
35 {
36     int i;
37     for (i=0; i<SMB_IOCTL_MAXPROCS; i++)
38         smb_ioctlProcsp[i] = NULL;
39
40     smb_ioctlProcsp[VIOCGETAL] = smb_IoctlGetACL;
41     smb_ioctlProcsp[VIOC_FILE_CELL_NAME] = smb_IoctlGetFileCellName;
42     smb_ioctlProcsp[VIOCSETAL] = smb_IoctlSetACL;
43     smb_ioctlProcsp[VIOC_FLUSHVOLUME] = smb_IoctlFlushVolume;
44     smb_ioctlProcsp[VIOCFLUSH] = smb_IoctlFlushFile;
45     smb_ioctlProcsp[VIOCSETVOLSTAT] = smb_IoctlSetVolumeStatus;
46     smb_ioctlProcsp[VIOCGETVOLSTAT] = smb_IoctlGetVolumeStatus;
47     smb_ioctlProcsp[VIOCWHEREIS] = smb_IoctlWhereIs;
48     smb_ioctlProcsp[VIOC_AFS_STAT_MT_PT] = smb_IoctlStatMountPoint;
49     smb_ioctlProcsp[VIOC_AFS_DELETE_MT_PT] = smb_IoctlDeleteMountPoint;
50     smb_ioctlProcsp[VIOCCKSERV] = smb_IoctlCheckServers;
51     smb_ioctlProcsp[VIOC_GAG] = smb_IoctlGag;
52     smb_ioctlProcsp[VIOCCKBACK] = smb_IoctlCheckVolumes;
53     smb_ioctlProcsp[VIOCSETCACHESIZE] = smb_IoctlSetCacheSize;
54     smb_ioctlProcsp[VIOCGETCACHEPARMS] = smb_IoctlGetCacheParms;
55     smb_ioctlProcsp[VIOCGETCELL] = smb_IoctlGetCell;
56     smb_ioctlProcsp[VIOCNEWCELL] = smb_IoctlNewCell;
57     smb_ioctlProcsp[VIOC_GET_WS_CELL] = smb_IoctlGetWsCell;
58     smb_ioctlProcsp[VIOC_AFS_SYSNAME] = smb_IoctlSysName;
59     smb_ioctlProcsp[VIOC_GETCELLSTATUS] = smb_IoctlGetCellStatus;
60     smb_ioctlProcsp[VIOC_SETCELLSTATUS] = smb_IoctlSetCellStatus;
61     smb_ioctlProcsp[VIOC_SETSPREFS] = smb_IoctlSetSPrefs;
62     smb_ioctlProcsp[VIOC_GETSPREFS] = smb_IoctlGetSPrefs;
63     smb_ioctlProcsp[VIOC_STOREBEHIND] = smb_IoctlStoreBehind;
64     smb_ioctlProcsp[VIOC_AFS_CREATE_MT_PT] = smb_IoctlCreateMountPoint;
65     smb_ioctlProcsp[VIOC_TRACECTL] = smb_IoctlTraceControl;
66     smb_ioctlProcsp[VIOCSETTOK] = smb_IoctlSetToken;
67     smb_ioctlProcsp[VIOCGETTOK] = smb_IoctlGetTokenIter;
68     smb_ioctlProcsp[VIOCNEWGETTOK] = smb_IoctlGetToken;
69     smb_ioctlProcsp[VIOCDELTOK] = smb_IoctlDelToken;
70     smb_ioctlProcsp[VIOCDELALLTOK] = smb_IoctlDelAllToken;
71     smb_ioctlProcsp[VIOC_SYMLINK] = smb_IoctlSymlink;
72     smb_ioctlProcsp[VIOC_LISTSYMLINK] = smb_IoctlListlink;
73     smb_ioctlProcsp[VIOC_DELSYMLINK] = smb_IoctlDeletelink;
74     smb_ioctlProcsp[VIOC_MAKESUBMOUNT] = smb_IoctlMakeSubmount;
75     smb_ioctlProcsp[VIOC_GETRXKCRYPT] = smb_IoctlGetRxkcrypt;
76     smb_ioctlProcsp[VIOC_SETRXKCRYPT] = smb_IoctlSetRxkcrypt;
77     smb_ioctlProcsp[VIOC_ISSYMLINK] = smb_IoctlIslink;
78     smb_ioctlProcsp[VIOC_TRACEMEMDUMP] = smb_IoctlMemoryDump;
79     smb_ioctlProcsp[VIOC_ISSYMLINK] = smb_IoctlIslink;
80     smb_ioctlProcsp[VIOC_FLUSHALL] = smb_IoctlFlushAllVolumes;
81     smb_ioctlProcsp[VIOCGETFID] = smb_IoctlGetFid;
82     smb_ioctlProcsp[VIOCGETOWNER] = smb_IoctlGetOwner;
83     smb_ioctlProcsp[VIOC_RXSTAT_PROC] = smb_IoctlRxStatProcess;
84     smb_ioctlProcsp[VIOC_RXSTAT_PEER] = smb_IoctlRxStatPeer;
85     smb_ioctlProcsp[VIOC_UUIDCTL] = smb_IoctlUUIDControl;
86     smb_ioctlProcsp[VIOC_PATH_AVAILABILITY] = smb_IoctlPathAvailability;
87     smb_ioctlProcsp[VIOC_GETFILETYPE] = smb_IoctlGetFileType;
88     smb_ioctlProcsp[VIOC_VOLSTAT_TEST] = smb_IoctlVolStatTest;
89     smb_ioctlProcsp[VIOC_UNICODECTL] = smb_IoctlUnicodeControl;
90 }       
91
92 /* called to make a fid structure into an IOCTL fid structure */
93 void 
94 smb_SetupIoctlFid(smb_fid_t *fidp, cm_space_t *prefix)
95 {
96     smb_ioctl_t *iop;
97     cm_space_t *copyPrefix;
98
99     lock_ObtainMutex(&fidp->mx);
100     fidp->flags |= SMB_FID_IOCTL;
101     fidp->scp = &cm_data.fakeSCache;
102     cm_HoldSCache(fidp->scp);
103     if (fidp->ioctlp == NULL) {
104         iop = malloc(sizeof(*iop));
105         memset(iop, 0, sizeof(*iop));
106         fidp->ioctlp = iop;
107         iop->fidp = fidp;
108     }
109     if (prefix) {
110         copyPrefix = cm_GetSpace();
111         memcpy(copyPrefix->data, prefix->data, CM_UTILS_SPACESIZE);
112         fidp->ioctlp->prefix = copyPrefix;
113     }
114     lock_ReleaseMutex(&fidp->mx);
115 }
116
117 /* called when we receive a read call, does the send of the received data if
118  * this is the first read call.  This is the function that actually makes the
119  * call to the ioctl code.
120  */
121 afs_int32
122 smb_IoctlPrepareRead(struct smb_fid *fidp, smb_ioctl_t *ioctlp, cm_user_t *userp)
123 {
124     afs_int32 opcode;
125     smb_ioctlProc_t *procp = NULL;
126     afs_int32 code;
127
128     if (ioctlp->ioctl.flags & CM_IOCTLFLAG_DATAIN) {
129         ioctlp->ioctl.flags &= ~CM_IOCTLFLAG_DATAIN;
130
131         /* do the call now, or fail if we didn't get an opcode, or
132          * enough of an opcode.
133          */
134         if (ioctlp->ioctl.inCopied < sizeof(afs_int32)) 
135             return CM_ERROR_INVAL;
136         memcpy(&opcode, ioctlp->ioctl.inDatap, sizeof(afs_int32));
137         ioctlp->ioctl.inDatap += sizeof(afs_int32);
138
139         osi_Log1(afsd_logp, "Ioctl opcode 0x%x", opcode);
140
141         /* check for opcode out of bounds */
142         if (opcode < 0 || opcode >= SMB_IOCTL_MAXPROCS)
143             return CM_ERROR_TOOBIG;
144
145         /* check for no such proc */
146         procp = smb_ioctlProcsp[opcode];
147         if (procp == NULL) 
148             return CM_ERROR_BADOP;
149
150         /* otherwise, make the call */
151         ioctlp->ioctl.outDatap += sizeof(afs_int32); /* reserve room for return code */
152         code = (*procp)(ioctlp, userp);
153
154         osi_Log1(afsd_logp, "Ioctl return code 0x%x", code);
155
156         /* copy in return code */
157         memcpy(ioctlp->ioctl.outAllocp, &code, sizeof(afs_int32));
158     }
159     return 0;
160 }
161
162 /* called when we receive a write call.  If this is the first write call after
163  * a series of reads (or the very first call), then we start a new call.
164  * We also ensure that things are properly initialized for the start of a call.
165  */
166 void 
167 smb_IoctlPrepareWrite(smb_fid_t *fidp, smb_ioctl_t *ioctlp)
168 {
169     /* make sure the buffer(s) are allocated */
170     if (!ioctlp->ioctl.inAllocp) 
171         ioctlp->ioctl.inAllocp = malloc(SMB_IOCTL_MAXDATA);
172     if (!ioctlp->ioctl.outAllocp)
173         ioctlp->ioctl.outAllocp = malloc(SMB_IOCTL_MAXDATA);
174
175     /* Fixes fs la problem.  We do a StrToOEM later and if this data isn't initialized we get memory issues. */
176     (void) memset(ioctlp->ioctl.inAllocp, 0, SMB_IOCTL_MAXDATA);
177     (void) memset(ioctlp->ioctl.outAllocp, 0, SMB_IOCTL_MAXDATA);
178
179     /* and make sure that we've reset our state for the new incoming request */
180     if (!(ioctlp->ioctl.flags & CM_IOCTLFLAG_DATAIN)) {
181         ioctlp->ioctl.inCopied = 0;
182         ioctlp->ioctl.outCopied = 0;
183         ioctlp->ioctl.inDatap = ioctlp->ioctl.inAllocp;
184         ioctlp->ioctl.outDatap = ioctlp->ioctl.outAllocp;
185         ioctlp->ioctl.flags |= CM_IOCTLFLAG_DATAIN;
186     }
187 }       
188
189 /* called from smb_ReceiveCoreRead when we receive a read on the ioctl fid */
190 afs_int32
191 smb_IoctlRead(smb_fid_t *fidp, smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
192 {
193     smb_ioctl_t *iop;
194     long count;
195     afs_int32 leftToCopy;
196     char *op;
197     afs_int32 code;
198     cm_user_t *userp;
199
200     iop = fidp->ioctlp;
201     count = smb_GetSMBParm(inp, 1);
202     userp = smb_GetUserFromVCP(vcp, inp);
203
204     /* Identify tree */
205     code = smb_LookupTIDPath(vcp, ((smb_t *)inp)->tid, &iop->tidPathp);
206     if(code) {
207         cm_ReleaseUser(userp);
208         return CM_ERROR_NOSUCHPATH;
209     }
210
211     /* turn the connection around, if required */
212     code = smb_IoctlPrepareRead(fidp, iop, userp);
213
214     if (code) {
215         cm_ReleaseUser(userp);
216         return code;
217     }
218
219     leftToCopy = (afs_int32)((iop->ioctl.outDatap - iop->ioctl.outAllocp) - iop->ioctl.outCopied);
220     if (count > leftToCopy)
221         count = leftToCopy;
222
223     /* now set the parms for a read of count bytes */
224     smb_SetSMBParm(outp, 0, count);
225     smb_SetSMBParm(outp, 1, 0);
226     smb_SetSMBParm(outp, 2, 0);
227     smb_SetSMBParm(outp, 3, 0);
228     smb_SetSMBParm(outp, 4, 0);
229
230     smb_SetSMBDataLength(outp, count+3);
231
232     op = smb_GetSMBData(outp, NULL);
233     *op++ = 1;
234     *op++ = (char)(count & 0xff);
235     *op++ = (char)((count >> 8) & 0xff);
236
237     /* now copy the data into the response packet */
238     memcpy(op, iop->ioctl.outCopied + iop->ioctl.outAllocp, count);
239
240     /* and adjust the counters */
241     iop->ioctl.outCopied += count;
242
243     cm_ReleaseUser(userp);
244
245     return 0;
246 }
247
248 /* called from smb_ReceiveCoreWrite when we receive a write call on the IOCTL
249  * file descriptor.
250  */
251 afs_int32
252 smb_IoctlWrite(smb_fid_t *fidp, smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
253 {
254     smb_ioctl_t *iop;
255     long count;
256     afs_int32 code;
257     char *op;
258     int inDataBlockCount;
259
260     code = 0;
261     count = smb_GetSMBParm(inp, 1);
262     iop = fidp->ioctlp;
263         
264     smb_IoctlPrepareWrite(fidp, iop);
265
266     op = smb_GetSMBData(inp, NULL);
267     op = smb_ParseDataBlock(op, NULL, &inDataBlockCount);
268         
269     if (count + iop->ioctl.inCopied > SMB_IOCTL_MAXDATA) {
270         code = CM_ERROR_TOOBIG;
271         goto done;
272     }
273         
274     /* copy data */
275     memcpy(iop->ioctl.inDatap + iop->ioctl.inCopied, op, count);
276         
277     /* adjust counts */
278     iop->ioctl.inCopied += count;
279
280   done:
281     /* return # of bytes written */
282     if (code == 0) {
283         smb_SetSMBParm(outp, 0, count);
284         smb_SetSMBDataLength(outp, 0);
285     }
286
287     return code;
288 }       
289
290 /* called from smb_ReceiveV3WriteX when we receive a write call on the IOCTL
291  * file descriptor.
292  */
293 afs_int32
294 smb_IoctlV3Write(smb_fid_t *fidp, smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
295 {
296     smb_ioctl_t *iop;
297     long count;
298     afs_int32 code;
299     char *op;
300     int inDataBlockCount;
301
302     code = 0;
303     count = smb_GetSMBParm(inp, 10);
304     iop = fidp->ioctlp;
305
306     smb_IoctlPrepareWrite(fidp, iop);
307
308     op = inp->data + smb_GetSMBParm(inp, 11);
309     inDataBlockCount = count;
310
311     if (count + iop->ioctl.inCopied > SMB_IOCTL_MAXDATA) {
312         code = CM_ERROR_TOOBIG;
313         goto done;
314     }
315         
316     /* copy data */
317     memcpy(iop->ioctl.inDatap + iop->ioctl.inCopied, op, count);
318
319     /* adjust counts */
320     iop->ioctl.inCopied += count;
321
322   done:
323     /* return # of bytes written */
324     if (code == 0) {
325         smb_SetSMBParm(outp, 2, count);
326         smb_SetSMBParm(outp, 3, 0); /* reserved */
327         smb_SetSMBParm(outp, 4, 0); /* reserved */
328         smb_SetSMBParm(outp, 5, 0); /* reserved */
329         smb_SetSMBDataLength(outp, 0);
330     }
331
332     return code;
333 }       
334
335
336 /* called from V3 read to handle IOCTL descriptor reads */
337 afs_int32
338 smb_IoctlV3Read(smb_fid_t *fidp, smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
339 {
340     smb_ioctl_t *iop;
341     long count;
342     afs_int32 code;
343     long leftToCopy;
344     char *op;
345     cm_user_t *userp;
346     smb_user_t *uidp;
347
348     iop = fidp->ioctlp;
349     count = smb_GetSMBParm(inp, 5);
350         
351     uidp = smb_FindUID(vcp, ((smb_t *)inp)->uid, 0);
352     userp = smb_GetUserFromUID(uidp);
353     osi_assertx(userp != NULL, "null cm_user_t");
354     iop->uidp = uidp;
355     if (uidp && uidp->unp) {
356         osi_Log3(afsd_logp, "Ioctl uid %d user %x name %S",
357                   uidp->userID, userp,
358                   osi_LogSaveClientString(afsd_logp, uidp->unp->name));
359     } else {
360         if (uidp)
361             osi_Log2(afsd_logp, "Ioctl uid %d user %x no name",
362                      uidp->userID, userp);
363         else
364             osi_Log1(afsd_logp, "Ioctl no uid user %x no name",
365                      userp);
366     }
367
368     code = smb_LookupTIDPath(vcp, ((smb_t *)inp)->tid, &iop->tidPathp);
369     if (code) {
370         if (uidp)
371             smb_ReleaseUID(uidp);
372         cm_ReleaseUser(userp);
373         return CM_ERROR_NOSUCHPATH;
374     }
375
376     code = smb_IoctlPrepareRead(fidp, iop, userp);
377     if (uidp) {
378         iop->uidp = 0;
379         smb_ReleaseUID(uidp);
380     }
381     if (code) {
382         cm_ReleaseUser(userp);
383         return code;
384     }
385
386     leftToCopy = (long)((iop->ioctl.outDatap - iop->ioctl.outAllocp) - iop->ioctl.outCopied);
387     if (count > leftToCopy) 
388         count = leftToCopy;
389         
390     /* 0 and 1 are reserved for request chaining, were setup by our caller,
391      * and will be further filled in after we return.
392      */
393     smb_SetSMBParm(outp, 2, 0); /* remaining bytes, for pipes */
394     smb_SetSMBParm(outp, 3, 0); /* resvd */
395     smb_SetSMBParm(outp, 4, 0); /* resvd */
396     smb_SetSMBParm(outp, 5, count);     /* # of bytes we're going to read */
397     /* fill in #6 when we have all the parameters' space reserved */
398     smb_SetSMBParm(outp, 7, 0); /* resv'd */
399     smb_SetSMBParm(outp, 8, 0); /* resv'd */
400     smb_SetSMBParm(outp, 9, 0); /* resv'd */
401     smb_SetSMBParm(outp, 10, 0);        /* resv'd */
402     smb_SetSMBParm(outp, 11, 0);        /* reserved */
403
404     /* get op ptr after putting in the last parm, since otherwise we don't
405      * know where the data really is.
406      */
407     op = smb_GetSMBData(outp, NULL);
408         
409     /* now fill in offset from start of SMB header to first data byte (to op) */
410     smb_SetSMBParm(outp, 6, ((int) (op - outp->data)));
411
412     /* set the packet data length the count of the # of bytes */
413     smb_SetSMBDataLength(outp, count);
414         
415     /* now copy the data into the response packet */
416     memcpy(op, iop->ioctl.outCopied + iop->ioctl.outAllocp, count);
417
418     /* and adjust the counters */
419     iop->ioctl.outCopied += count;
420
421     /* and cleanup things */
422     cm_ReleaseUser(userp);
423
424     return 0;
425 }       
426
427 /* called from Read Raw to handle IOCTL descriptor reads */
428 afs_int32
429 smb_IoctlReadRaw(smb_fid_t *fidp, smb_vc_t *vcp, smb_packet_t *inp,
430                  smb_packet_t *outp)
431 {
432     smb_ioctl_t *iop;
433     long leftToCopy;
434     NCB *ncbp;
435     afs_int32 code;
436     cm_user_t *userp;
437     smb_user_t *uidp;
438
439     iop = fidp->ioctlp;
440
441     userp = smb_GetUserFromVCP(vcp, inp);
442
443     /* Log the user */
444     uidp = smb_FindUID(vcp, ((smb_t *)inp)->uid, 0);
445     if (uidp && uidp->unp) {
446         osi_Log3(afsd_logp, "Ioctl uid %d user %x name %s",
447                  uidp->userID, userp,
448                  osi_LogSaveClientString(afsd_logp, uidp->unp->name));
449     } else if (uidp) {
450         osi_Log2(afsd_logp, "Ioctl uid %d user %x no name",
451                  uidp->userID, userp);
452     } else {
453         osi_Log1(afsd_logp, "Ioctl no uid user %x no name",
454                   userp);
455     }
456     if (uidp) 
457         smb_ReleaseUID(uidp);
458
459     code = smb_LookupTIDPath(vcp, ((smb_t *)inp)->tid, &iop->tidPathp);
460     if (code) {
461         code = CM_ERROR_NOSUCHPATH;
462         goto done;
463     }
464
465     code = smb_IoctlPrepareRead(fidp, iop, userp);
466     if (code) {
467         goto done;
468     }
469
470     leftToCopy = (long)((iop->ioctl.outDatap - iop->ioctl.outAllocp) - iop->ioctl.outCopied);
471
472     ncbp = outp->ncbp;
473     memset((char *)ncbp, 0, sizeof(NCB));
474
475     ncbp->ncb_length = (unsigned short) leftToCopy;
476     ncbp->ncb_lsn = (unsigned char) vcp->lsn;
477     ncbp->ncb_command = NCBSEND;
478     /*ncbp->ncb_lana_num = smb_LANadapter;*/
479     ncbp->ncb_lana_num = vcp->lana;
480
481     ncbp->ncb_buffer = iop->ioctl.outCopied + iop->ioctl.outAllocp;
482     code = Netbios(ncbp);
483
484     if (code != 0)
485         osi_Log1(afsd_logp, "ReadRaw send failure code %d", code);
486
487   done:
488     cm_ReleaseUser(userp);
489
490     return code;
491 }
492
493 /* parse the passed-in file name and do a namei on it.  If we fail,
494  * return an error code, otherwise return the vnode located in *scpp.
495  */
496 #define CM_PARSE_FLAG_LITERAL 1
497
498 afs_int32
499 smb_ParseIoctlPath(smb_ioctl_t *ioctlp, cm_user_t *userp, cm_req_t *reqp,
500                    cm_scache_t **scpp, afs_uint32 flags)
501 {
502     long code;
503     cm_scache_t  *substRootp = NULL;
504     cm_scache_t  *iscp = NULL;
505     char      *inPath;
506     clientchar_t *relativePath = NULL;
507     clientchar_t *lastComponent = NULL;
508     afs_uint32 follow = (flags & CM_PARSE_FLAG_LITERAL ? CM_FLAG_NOMOUNTCHASE : CM_FLAG_FOLLOW);
509
510     inPath = ioctlp->ioctl.inDatap;
511     /* setup the next data value for the caller to use */
512     ioctlp->ioctl.inDatap += (long)strlen(ioctlp->ioctl.inDatap) + 1;
513
514     osi_Log1(afsd_logp, "cm_ParseIoctlPath %s", osi_LogSaveString(afsd_logp,inPath));
515
516     /* This is usually the file name, but for StatMountPoint it is the path. */
517     /* ioctlp->ioctl.inDatap can be either of the form:
518      *    \path\.
519      *    \path\file
520      *    \\netbios-name\submount\path\.
521      *    \\netbios-name\submount\path\file
522      */
523
524     /* We do not perform path name translation on the ioctl path data
525      * because these paths were not translated by Windows through the
526      * file system API.  Therefore, they are not OEM characters but
527      * whatever the display character set is.
528      */
529
530     // TranslateExtendedChars(relativePath);
531
532     /* This is usually nothing, but for StatMountPoint it is the file name. */
533     // TranslateExtendedChars(ioctlp->ioctl.inDatap);
534
535     /* If the string starts with our UTF-8 prefix (which is the
536        sequence [ESC,'%','G'] as used by ISO-2022 to designate UTF-8
537        strings), we assume that the provided path is UTF-8.  Otherwise
538        we have to convert the string to UTF-8, since that is what we
539        want to use everywhere else.*/
540
541     if (memcmp(inPath, utf8_prefix, utf8_prefix_size) == 0) {
542         /* String is UTF-8 */
543         inPath += utf8_prefix_size;
544         ioctlp->ioctl.flags |= CM_IOCTLFLAG_USEUTF8;
545
546         relativePath = cm_Utf8ToClientStringAlloc(inPath, -1, NULL);
547     } else {
548         int cch;
549
550         /* Not a UTF-8 string */
551         /* TODO: If this is an OEM string, we should convert it to
552            UTF-8. */
553         if (smb_StoreAnsiFilenames) {
554             cch = cm_AnsiToClientString(inPath, -1, NULL, 0);
555 #ifdef DEBUG
556             osi_assert(cch > 0);
557 #endif
558             relativePath = malloc(cch * sizeof(clientchar_t));
559             cm_AnsiToClientString(inPath, -1, relativePath, cch);
560         } else {
561             TranslateExtendedChars(inPath);
562
563             cch = cm_OemToClientString(inPath, -1, NULL, 0);
564 #ifdef DEBUG
565             osi_assert(cch > 0);
566 #endif
567             relativePath = malloc(cch * sizeof(clientchar_t));
568             cm_OemToClientString(inPath, -1, relativePath, cch);
569         }
570     }
571
572     if (relativePath[0] == relativePath[1] &&
573         relativePath[1] == '\\' && 
574         !cm_ClientStrCmpNI(cm_NetbiosNameC, relativePath+2,
575                            cm_ClientStrLen(cm_NetbiosNameC))) 
576     {
577         clientchar_t shareName[256];
578         clientchar_t *sharePath;
579         int shareFound, i;
580
581         /* We may have found a UNC path. 
582          * If the first component is the NetbiosName,
583          * then throw out the second component (the submount)
584          * since it had better expand into the value of ioctl->tidPathp
585          */
586         clientchar_t * p;
587         p = relativePath + 2 + cm_ClientStrLen(cm_NetbiosNameC) + 1;                    /* buffer overflow vuln.? */
588         if ( !cm_ClientStrCmpNI(_C("all"),  p,  3) )
589             p += 4;
590
591         for (i = 0; *p && *p != '\\'; i++,p++ ) {
592             shareName[i] = *p;
593         }
594         p++;                    /* skip past trailing slash */
595         shareName[i] = 0;       /* terminate string */
596
597         shareFound = smb_FindShare(ioctlp->fidp->vcp, ioctlp->uidp, shareName, &sharePath);
598         if ( shareFound ) {
599             /* we found a sharename, therefore use the resulting path */
600             code = cm_NameI(cm_data.rootSCachep, ioctlp->prefix->wdata,
601                             CM_FLAG_CASEFOLD | CM_FLAG_FOLLOW,
602                             userp, sharePath, reqp, &substRootp);
603             free(sharePath);
604             if (code) {
605                 osi_Log1(afsd_logp,"cm_ParseIoctlPath [1] code 0x%x", code);
606                 if (relativePath)
607                     free(relativePath);
608                 return code;
609             }
610
611             lastComponent = cm_ClientStrRChr(p,  '\\');
612             if (lastComponent && (lastComponent - p) > 1 &&
613                 cm_ClientStrLen(lastComponent) > 1) {
614                 *lastComponent = '\0';
615                 lastComponent++;
616
617                 code = cm_NameI(substRootp, p, CM_FLAG_CASEFOLD | CM_FLAG_FOLLOW,
618                                 userp, NULL, reqp, &iscp);
619                 if (code == 0)
620                     code = cm_NameI(iscp, lastComponent, CM_FLAG_CASEFOLD | follow,
621                                     userp, NULL, reqp, scpp);
622                 if (iscp)
623                     cm_ReleaseSCache(iscp);
624             } else {
625                 code = cm_NameI(substRootp, p, CM_FLAG_CASEFOLD,
626                                 userp, NULL, reqp, scpp);
627             }
628             cm_ReleaseSCache(substRootp);
629             if (code) {
630                 osi_Log1(afsd_logp,"cm_ParseIoctlPath [2] code 0x%x", code);
631                 if (relativePath)
632                     free(relativePath);
633                 return code;
634             }
635         } else {
636             /* otherwise, treat the name as a cellname mounted off the afs root.
637              * This requires that we reconstruct the shareName string with 
638              * leading and trailing slashes.
639              */
640             p = relativePath + 2 + cm_ClientStrLen(cm_NetbiosNameC) + 1;
641             if ( !cm_ClientStrCmpNI(_C("all"),  p,  3) )
642                 p += 4;
643
644             shareName[0] = '/';
645             for (i = 1; *p && *p != '\\'; i++,p++ ) {
646                 shareName[i] = *p;
647             }
648             p++;                    /* skip past trailing slash */
649             shareName[i++] = '/';       /* add trailing slash */
650             shareName[i] = 0;       /* terminate string */
651
652
653             code = cm_NameI(cm_data.rootSCachep, ioctlp->prefix->wdata,
654                             CM_FLAG_CASEFOLD | CM_FLAG_FOLLOW,
655                             userp, shareName, reqp, &substRootp);
656             if (code) {
657                 osi_Log1(afsd_logp,"cm_ParseIoctlPath [3] code 0x%x", code);
658                 if (relativePath)
659                     free(relativePath);
660                 return code;
661             }
662
663             lastComponent = cm_ClientStrRChr(p,  '\\');
664             if (lastComponent && (lastComponent - p) > 1 &&
665                 cm_ClientStrLen(lastComponent) > 1) {
666                 *lastComponent = '\0';
667                 lastComponent++;
668
669                 code = cm_NameI(substRootp, p, CM_FLAG_CASEFOLD | CM_FLAG_FOLLOW,
670                                 userp, NULL, reqp, &iscp);
671                 if (code == 0)
672                     code = cm_NameI(iscp, lastComponent, CM_FLAG_CASEFOLD | follow,
673                                     userp, NULL, reqp, scpp);
674                 if (iscp)
675                     cm_ReleaseSCache(iscp);
676             } else {
677                 code = cm_NameI(substRootp, p, CM_FLAG_CASEFOLD,
678                                 userp, NULL, reqp, scpp);
679             }
680
681             if (code) {
682                 cm_ReleaseSCache(substRootp);
683                 osi_Log1(afsd_logp,"cm_ParseIoctlPath code [4] 0x%x", code);
684                 if (relativePath)
685                     free(relativePath);
686                 return code;
687             }
688         }
689     } else {
690         code = cm_NameI(cm_data.rootSCachep, ioctlp->prefix->wdata,
691                          CM_FLAG_CASEFOLD | CM_FLAG_FOLLOW,
692                          userp, ioctlp->tidPathp, reqp, &substRootp);
693         if (code) {
694             osi_Log1(afsd_logp,"cm_ParseIoctlPath [6] code 0x%x", code);
695             if (relativePath)
696                 free(relativePath);
697             return code;
698         }
699         
700         lastComponent = cm_ClientStrRChr(relativePath,  '\\');
701         if (lastComponent && (lastComponent - relativePath) > 1 &&
702             cm_ClientStrLen(lastComponent) > 1) {
703             *lastComponent = '\0';
704             lastComponent++;
705
706             code = cm_NameI(substRootp, relativePath, CM_FLAG_CASEFOLD | CM_FLAG_FOLLOW,
707                             userp, NULL, reqp, &iscp);
708             if (code == 0)
709                 code = cm_NameI(iscp, lastComponent, CM_FLAG_CASEFOLD | follow,
710                                 userp, NULL, reqp, scpp);
711             if (iscp)
712                 cm_ReleaseSCache(iscp);
713         } else {
714             code = cm_NameI(substRootp, relativePath, CM_FLAG_CASEFOLD | follow,
715                             userp, NULL, reqp, scpp);
716         }
717         if (code) {
718             cm_ReleaseSCache(substRootp);
719             osi_Log1(afsd_logp,"cm_ParseIoctlPath [7] code 0x%x", code);
720             if (relativePath)
721                 free(relativePath);
722             return code;
723         }
724     }
725
726     if (substRootp)
727         cm_ReleaseSCache(substRootp);
728
729     /* and return success */
730     osi_Log1(afsd_logp,"cm_ParseIoctlPath [8] code 0x%x", code);
731
732     if (relativePath)
733         free(relativePath);
734     return 0;
735 }
736
737
738
739 #define LEAF_SIZE 256
740 /* parse the passed-in file name and do a namei on its parent.  If we fail,
741  * return an error code, otherwise return the vnode located in *scpp.
742  */
743 afs_int32
744 smb_ParseIoctlParent(smb_ioctl_t *ioctlp, cm_user_t *userp, cm_req_t *reqp,
745                      cm_scache_t **scpp, clientchar_t *leafp)
746 {
747     long code;
748     clientchar_t tbuffer[1024];
749     clientchar_t *tp, *jp;
750     cm_scache_t *substRootp = NULL;
751     clientchar_t *inpathp = NULL;
752     char *inpathdatap;
753
754     inpathdatap = ioctlp->ioctl.inDatap;
755
756     /* If the string starts with our UTF-8 prefix (which is the
757        sequence [ESC,'%','G'] as used by ISO-2022 to designate UTF-8
758        strings), we assume that the provided path is UTF-8.  Otherwise
759        we have to convert the string to UTF-8, since that is what we
760        want to use everywhere else.*/
761
762     if (memcmp(inpathdatap, utf8_prefix, utf8_prefix_size) == 0) {
763
764         /* String is UTF-8 */
765         inpathdatap += utf8_prefix_size;
766         ioctlp->ioctl.flags |= CM_IOCTLFLAG_USEUTF8;
767
768         inpathp = cm_Utf8ToClientStringAlloc(inpathdatap, -1, NULL);
769     } else {
770         int cch;
771
772         /* Not a UTF-8 string */
773         /* TODO: If this is an OEM string, we should convert it to
774            UTF-8. */
775         if (smb_StoreAnsiFilenames) {
776             cch = cm_AnsiToClientString(inpathdatap, -1, NULL, 0);
777 #ifdef DEBUG
778             osi_assert(cch > 0);
779 #endif
780             inpathp = malloc(cch * sizeof(clientchar_t));
781             cm_AnsiToClientString(inpathdatap, -1, inpathp, cch);
782         } else {
783             TranslateExtendedChars(inpathdatap);
784
785             cch = cm_OemToClientString(inpathdatap, -1, NULL, 0);
786 #ifdef DEBUG
787             osi_assert(cch > 0);
788 #endif
789             inpathp = malloc(cch * sizeof(clientchar_t));
790             cm_OemToClientString(inpathdatap, -1, inpathp, cch);
791         }
792     }
793
794     cm_ClientStrCpy(tbuffer, lengthof(tbuffer), inpathp);
795     tp = cm_ClientStrRChr(tbuffer, '\\');
796     jp = cm_ClientStrRChr(tbuffer, '/');
797     if (!tp)
798         tp = jp;
799     else if (jp && (tp - tbuffer) < (jp - tbuffer))
800         tp = jp;
801     if (!tp) {
802         cm_ClientStrCpy(tbuffer, lengthof(tbuffer), _C("\\"));
803         if (leafp)
804             cm_ClientStrCpy(leafp, LEAF_SIZE, inpathp);
805     }
806     else {
807         *tp = 0;
808         if (leafp) 
809             cm_ClientStrCpy(leafp, LEAF_SIZE, tp+1);
810     }
811
812     free(inpathp);
813     inpathp = NULL;             /* We don't need this from this point on */
814
815     if (tbuffer[0] == tbuffer[1] &&
816         tbuffer[1] == '\\' && 
817         !cm_ClientStrCmpNI(cm_NetbiosNameC, tbuffer+2,
818                            cm_ClientStrLen(cm_NetbiosNameC))) 
819     {
820         clientchar_t shareName[256];
821         clientchar_t *sharePath;
822         int shareFound, i;
823
824         /* We may have found a UNC path. 
825          * If the first component is the NetbiosName,
826          * then throw out the second component (the submount)
827          * since it had better expand into the value of ioctl->tidPathp
828          */
829         clientchar_t * p;
830         p = tbuffer + 2 + cm_ClientStrLen(cm_NetbiosNameC) + 1;
831         if ( !cm_ClientStrCmpNI(_C("all"),  p,  3) )
832             p += 4;
833
834         for (i = 0; *p && *p != '\\'; i++,p++ ) {
835             shareName[i] = *p;
836         }
837         p++;                    /* skip past trailing slash */
838         shareName[i] = 0;       /* terminate string */
839
840         shareFound = smb_FindShare(ioctlp->fidp->vcp, ioctlp->uidp, shareName, &sharePath);
841         if ( shareFound ) {
842             /* we found a sharename, therefore use the resulting path */
843             code = cm_NameI(cm_data.rootSCachep, ioctlp->prefix->wdata,
844                             CM_FLAG_CASEFOLD | CM_FLAG_FOLLOW,
845                             userp, sharePath, reqp, &substRootp);
846             free(sharePath);
847             if (code) return code;
848
849             code = cm_NameI(substRootp, p, CM_FLAG_CASEFOLD | CM_FLAG_FOLLOW,
850                             userp, NULL, reqp, scpp);
851             cm_ReleaseSCache(substRootp);
852             if (code) return code;
853         } else {
854             /* otherwise, treat the name as a cellname mounted off the afs root.
855              * This requires that we reconstruct the shareName string with 
856              * leading and trailing slashes.
857              */
858             p = tbuffer + 2 + cm_ClientStrLen(cm_NetbiosNameC) + 1;
859             if ( !cm_ClientStrCmpNI(_C("all"),  p,  3) )
860                 p += 4;
861
862             shareName[0] = '/';
863             for (i = 1; *p && *p != '\\'; i++,p++ ) {
864                 shareName[i] = *p;
865             }
866             p++;                    /* skip past trailing slash */
867             shareName[i++] = '/';       /* add trailing slash */
868             shareName[i] = 0;       /* terminate string */
869
870             code = cm_NameI(cm_data.rootSCachep, ioctlp->prefix->wdata,
871                             CM_FLAG_CASEFOLD | CM_FLAG_FOLLOW,
872                             userp, shareName, reqp, &substRootp);
873             if (code) return code;
874
875             code = cm_NameI(substRootp, p, CM_FLAG_CASEFOLD | CM_FLAG_FOLLOW,
876                             userp, NULL, reqp, scpp);
877             cm_ReleaseSCache(substRootp);
878             if (code) return code;
879         }
880     } else {
881         code = cm_NameI(cm_data.rootSCachep, ioctlp->prefix->wdata,
882                         CM_FLAG_CASEFOLD | CM_FLAG_FOLLOW,
883                         userp, ioctlp->tidPathp, reqp, &substRootp);
884         if (code) return code;
885
886         code = cm_NameI(substRootp, tbuffer, CM_FLAG_CASEFOLD | CM_FLAG_FOLLOW,
887                         userp, NULL, reqp, scpp);
888         cm_ReleaseSCache(substRootp);
889         if (code) return code;
890     }
891
892     /* # of bytes of path */
893     code = (long)strlen(ioctlp->ioctl.inDatap) + 1;
894     ioctlp->ioctl.inDatap += code;
895
896     /* and return success */
897     return 0;
898 }
899
900 afs_int32 
901 smb_IoctlSetToken(struct smb_ioctl *ioctlp, struct cm_user *userp)
902 {
903     char *saveDataPtr;
904     char *tp;
905     int ticketLen;
906     char *ticket;
907     int ctSize;
908     struct ClearToken ct;
909     cm_cell_t *cellp;
910     cm_ucell_t *ucellp;
911     afs_uuid_t uuid;
912     int flags;
913     char sessionKey[8];
914     int release_userp = 0;
915     clientchar_t *uname = NULL;
916     clientchar_t *smbname = NULL;
917     clientchar_t *wdir = NULL;
918     afs_int32 code = 0;
919
920     saveDataPtr = ioctlp->ioctl.inDatap;
921
922     cm_SkipIoctlPath(&ioctlp->ioctl);
923
924     tp = ioctlp->ioctl.inDatap;
925
926     /* ticket length */
927     memcpy(&ticketLen, tp, sizeof(ticketLen));
928     tp += sizeof(ticketLen);
929     if (ticketLen < MINKTCTICKETLEN || ticketLen > MAXKTCTICKETLEN)
930         return CM_ERROR_INVAL;
931
932     /* remember ticket and skip over it for now */
933     ticket = tp;
934     tp += ticketLen;
935
936     /* clear token size */
937     memcpy(&ctSize, tp, sizeof(ctSize));
938     tp += sizeof(ctSize);
939     if (ctSize != sizeof(struct ClearToken))
940         return CM_ERROR_INVAL;
941
942     /* clear token */
943     memcpy(&ct, tp, ctSize);
944     tp += ctSize;
945     if (ct.AuthHandle == -1)
946         ct.AuthHandle = 999;    /* more rxvab compat stuff */
947
948     /* more stuff, if any */
949     if (ioctlp->ioctl.inCopied > tp - saveDataPtr) {
950         /* flags:  logon flag */
951         memcpy(&flags, tp, sizeof(int));
952         tp += sizeof(int);
953
954         /* cell name */
955         {
956             fschar_t * cellnamep;
957             clientchar_t * temp;
958
959             temp = cm_ParseIoctlStringAlloc(&ioctlp->ioctl, tp);
960             cellnamep = cm_ClientStringToFsStringAlloc(temp, -1, NULL);
961             cellp = cm_GetCell(cellnamep, CM_FLAG_CREATE | CM_FLAG_NOPROBE);
962             free(cellnamep);
963             free(temp);
964         }
965
966         if (!cellp) {
967             code = CM_ERROR_NOSUCHCELL;
968             goto done;
969         }
970         tp += strlen(tp) + 1;
971
972         /* user name */
973         uname = cm_ParseIoctlStringAlloc(&ioctlp->ioctl, tp);
974         tp += strlen(tp) + 1;
975
976         if (flags & PIOCTL_LOGON) {
977             /* SMB user name with which to associate tokens */
978             smbname = cm_ParseIoctlStringAlloc(&ioctlp->ioctl, tp);
979             osi_Log2(smb_logp,"cm_IoctlSetToken for user [%S] smbname [%S]",
980                      osi_LogSaveClientString(smb_logp,uname),
981                      osi_LogSaveClientString(smb_logp,smbname));
982             fprintf(stderr, "SMB name = %S\n", smbname);
983             tp += strlen(tp) + 1;
984         } else {
985             osi_Log1(smb_logp,"cm_IoctlSetToken for user [%S]",
986                      osi_LogSaveClientString(smb_logp, uname));
987         }
988
989         /* uuid */
990         memcpy(&uuid, tp, sizeof(uuid));
991         if (!cm_FindTokenEvent(uuid, sessionKey)) {
992             code = CM_ERROR_INVAL;
993             goto done;
994         }
995     } else {
996         cellp = cm_data.rootCellp;
997         osi_Log0(smb_logp,"cm_IoctlSetToken - no name specified");
998     }
999
1000     if (flags & PIOCTL_LOGON) {
1001         userp = smb_FindCMUserByName(smbname, ioctlp->fidp->vcp->rname,
1002                                      SMB_FLAG_CREATE|SMB_FLAG_AFSLOGON);
1003         release_userp = 1;
1004     }
1005
1006     /* store the token */
1007     lock_ObtainMutex(&userp->mx);
1008     ucellp = cm_GetUCell(userp, cellp);
1009     osi_Log1(smb_logp,"cm_IoctlSetToken ucellp %lx", ucellp);
1010     ucellp->ticketLen = ticketLen;
1011     if (ucellp->ticketp)
1012         free(ucellp->ticketp);  /* Discard old token if any */
1013     ucellp->ticketp = malloc(ticketLen);
1014     memcpy(ucellp->ticketp, ticket, ticketLen);
1015     /*
1016      * Get the session key from the RPC, rather than from the pioctl.
1017      */
1018     /*
1019     memcpy(&ucellp->sessionKey, ct.HandShakeKey, sizeof(ct.HandShakeKey));
1020     */
1021     memcpy(ucellp->sessionKey.data, sessionKey, sizeof(sessionKey));
1022     ucellp->kvno = ct.AuthHandle;
1023     ucellp->expirationTime = ct.EndTimestamp;
1024     ucellp->gen++;
1025 #ifdef QUERY_AFSID
1026     ucellp->uid = ANONYMOUSID;
1027 #endif
1028     if (uname) {
1029         cm_ClientStringToFsString(uname, -1, ucellp->userName, MAXKTCNAMELEN);
1030 #ifdef QUERY_AFSID
1031         cm_UsernameToId(uname, ucellp, &ucellp->uid);
1032 #endif
1033     }
1034     ucellp->flags |= CM_UCELLFLAG_RXKAD;
1035     lock_ReleaseMutex(&userp->mx);
1036
1037     if (flags & PIOCTL_LOGON) {
1038         ioctlp->ioctl.flags |= CM_IOCTLFLAG_LOGON;
1039     }
1040
1041     cm_ResetACLCache(userp);
1042
1043   done:
1044     if (release_userp)
1045         cm_ReleaseUser(userp);
1046
1047     if (uname)
1048         free(uname);
1049
1050     if (smbname)
1051         free(smbname);
1052
1053     return code;
1054 }
1055
1056
1057
1058 afs_int32
1059 smb_IoctlGetSMBName(smb_ioctl_t *ioctlp, cm_user_t *userp)
1060 {
1061     smb_user_t *uidp = ioctlp->uidp;
1062
1063     if (uidp && uidp->unp) {
1064         int cch;
1065
1066         cch = cm_ClientStringToUtf8(uidp->unp->name,
1067                                     -1,
1068                                     ioctlp->ioctl.outDatap,
1069                                     (SMB_IOCTL_MAXDATA -
1070                                      (ioctlp->ioctl.outDatap - ioctlp->ioctl.outAllocp))
1071                                     / sizeof(cm_utf8char_t));
1072
1073         ioctlp->ioctl.outDatap += cch * sizeof(cm_utf8char_t);
1074     }
1075
1076     return 0;
1077 }
1078
1079 afs_int32 
1080 smb_IoctlGetACL(smb_ioctl_t *ioctlp, cm_user_t *userp)
1081 {
1082     cm_scache_t *scp;
1083     afs_int32 code;
1084     cm_req_t req;
1085     cm_ioctlQueryOptions_t *optionsp;
1086     afs_uint32 flags = 0;
1087
1088     smb_InitReq(&req);
1089
1090     optionsp = cm_IoctlGetQueryOptions(&ioctlp->ioctl, userp);
1091     if (optionsp && CM_IOCTL_QOPTS_HAVE_LITERAL(optionsp))
1092         flags |= (optionsp->literal ? CM_PARSE_FLAG_LITERAL : 0);
1093
1094     if (optionsp && CM_IOCTL_QOPTS_HAVE_FID(optionsp)) {
1095         cm_fid_t fid;
1096         cm_SkipIoctlPath(&ioctlp->ioctl);
1097         cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume, 
1098                   optionsp->fid.vnode, optionsp->fid.unique);
1099         code = cm_GetSCache(&fid, &scp, userp, &req);
1100     } else {
1101         code = smb_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
1102     }
1103     if (code) 
1104         return code;
1105
1106     code = cm_IoctlGetACL(&ioctlp->ioctl, userp, scp, &req);
1107
1108     cm_ReleaseSCache(scp);
1109     return code;
1110 }
1111
1112 afs_int32 
1113 smb_IoctlSetACL(smb_ioctl_t *ioctlp, cm_user_t *userp)
1114 {
1115     cm_scache_t *scp;
1116     afs_int32 code;
1117     cm_req_t req;
1118     afs_uint32 flags = 0;
1119
1120     smb_InitReq(&req);
1121
1122     code = smb_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
1123     if (code) 
1124         return code;
1125
1126     code = cm_IoctlSetACL(&ioctlp->ioctl, userp, scp, &req);
1127
1128     cm_ReleaseSCache(scp);
1129     return code;
1130 }
1131
1132 afs_int32
1133 smb_IoctlGetFileCellName(struct smb_ioctl *ioctlp, struct cm_user *userp)
1134 {
1135     afs_int32 code;
1136     cm_scache_t *scp;
1137     cm_req_t req;
1138     cm_ioctlQueryOptions_t *optionsp;
1139     afs_uint32 flags = 0;
1140
1141     smb_InitReq(&req);
1142
1143     optionsp = cm_IoctlGetQueryOptions(&ioctlp->ioctl, userp);
1144     if (optionsp && CM_IOCTL_QOPTS_HAVE_LITERAL(optionsp))
1145         flags |= (optionsp->literal ? CM_PARSE_FLAG_LITERAL : 0);
1146
1147     if (optionsp && CM_IOCTL_QOPTS_HAVE_FID(optionsp)) {
1148         cm_fid_t fid;
1149         cm_SkipIoctlPath(&ioctlp->ioctl);
1150         cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume, 
1151                   optionsp->fid.vnode, optionsp->fid.unique);
1152         code = cm_GetSCache(&fid, &scp, userp, &req);
1153     } else {
1154         code = smb_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
1155     }
1156     if (code) 
1157         return code;
1158
1159     code = cm_IoctlGetFileCellName(&ioctlp->ioctl, userp, scp, &req);
1160
1161     cm_ReleaseSCache(scp);
1162
1163     return code;
1164 }
1165
1166 afs_int32 
1167 smb_IoctlFlushAllVolumes(struct smb_ioctl *ioctlp, struct cm_user *userp)
1168 {
1169     cm_req_t req;
1170
1171     smb_InitReq(&req);
1172
1173     cm_SkipIoctlPath(&ioctlp->ioctl);   /* we don't care about the path */
1174
1175     return cm_IoctlFlushAllVolumes(&ioctlp->ioctl, userp, &req);
1176 }
1177
1178 afs_int32 
1179 smb_IoctlFlushVolume(struct smb_ioctl *ioctlp, struct cm_user *userp)
1180 {
1181     afs_int32 code;
1182     cm_scache_t *scp;
1183     cm_req_t req;
1184     cm_ioctlQueryOptions_t *optionsp;
1185     afs_uint32 flags = 0;
1186
1187     smb_InitReq(&req);
1188
1189     optionsp = cm_IoctlGetQueryOptions(&ioctlp->ioctl, userp);
1190     if (optionsp && CM_IOCTL_QOPTS_HAVE_LITERAL(optionsp))
1191         flags |= (optionsp->literal ? CM_PARSE_FLAG_LITERAL : 0);
1192
1193     if (optionsp && CM_IOCTL_QOPTS_HAVE_FID(optionsp)) {
1194         cm_fid_t fid;
1195         cm_SkipIoctlPath(&ioctlp->ioctl);
1196         cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume, 
1197                   optionsp->fid.vnode, optionsp->fid.unique);
1198         code = cm_GetSCache(&fid, &scp, userp, &req);
1199     } else {
1200         code = smb_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
1201     }
1202     if (code) 
1203         return code;
1204
1205     code = cm_IoctlFlushVolume(&ioctlp->ioctl, userp, scp, &req);
1206
1207     cm_ReleaseSCache(scp);
1208
1209     return code;
1210 }
1211
1212 afs_int32 
1213 smb_IoctlFlushFile(struct smb_ioctl *ioctlp, struct cm_user *userp)
1214 {
1215     afs_int32 code;
1216     cm_scache_t *scp;
1217     cm_req_t req;
1218     cm_ioctlQueryOptions_t *optionsp;
1219     afs_uint32 flags = 0;
1220
1221     smb_InitReq(&req);
1222
1223     optionsp = cm_IoctlGetQueryOptions(&ioctlp->ioctl, userp);
1224     if (optionsp && CM_IOCTL_QOPTS_HAVE_LITERAL(optionsp))
1225         flags |= (optionsp->literal ? CM_PARSE_FLAG_LITERAL : 0);
1226
1227     if (optionsp && CM_IOCTL_QOPTS_HAVE_FID(optionsp)) {
1228         cm_fid_t fid;
1229         cm_SkipIoctlPath(&ioctlp->ioctl);
1230         cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume,
1231                   optionsp->fid.vnode, optionsp->fid.unique);
1232         code = cm_GetSCache(&fid, &scp, userp, &req);
1233     } else {
1234         code = smb_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
1235     }
1236     if (code) 
1237         return code;
1238
1239     code = cm_IoctlFlushFile(&ioctlp->ioctl, userp, scp, &req);
1240
1241     cm_ReleaseSCache(scp);
1242     return code;
1243 }
1244
1245 afs_int32 
1246 smb_IoctlSetVolumeStatus(struct smb_ioctl *ioctlp, struct cm_user *userp)
1247 {
1248     afs_int32 code;
1249     cm_scache_t *scp;
1250     cm_req_t req;
1251
1252     smb_InitReq(&req);
1253
1254     code = smb_ParseIoctlPath(ioctlp, userp, &req, &scp, 0);
1255     if (code) return code;
1256
1257     code = cm_IoctlSetVolumeStatus(&ioctlp->ioctl, userp, scp, &req);
1258     cm_ReleaseSCache(scp);
1259
1260     return code;
1261 }
1262
1263 afs_int32 
1264 smb_IoctlGetVolumeStatus(struct smb_ioctl *ioctlp, struct cm_user *userp)
1265 {
1266     afs_int32 code;
1267     cm_scache_t *scp;
1268     cm_ioctlQueryOptions_t *optionsp;
1269     afs_uint32 flags = 0;
1270     cm_req_t req;
1271
1272     smb_InitReq(&req);
1273
1274     optionsp = cm_IoctlGetQueryOptions(&ioctlp->ioctl, userp);
1275     if (optionsp && CM_IOCTL_QOPTS_HAVE_LITERAL(optionsp))
1276         flags |= (optionsp->literal ? CM_PARSE_FLAG_LITERAL : 0);
1277
1278     if (optionsp && CM_IOCTL_QOPTS_HAVE_FID(optionsp)) {
1279         cm_fid_t fid;
1280         cm_SkipIoctlPath(&ioctlp->ioctl);
1281         cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume, 
1282                   optionsp->fid.vnode, optionsp->fid.unique);
1283         code = cm_GetSCache(&fid, &scp, userp, &req);
1284     } else {
1285         code = smb_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
1286     }
1287     if (code) 
1288         return code;
1289
1290     code = cm_IoctlGetVolumeStatus(&ioctlp->ioctl, userp, scp, &req);
1291
1292     cm_ReleaseSCache(scp);
1293
1294     return code;
1295 }
1296
1297 afs_int32 
1298 smb_IoctlGetFid(struct smb_ioctl *ioctlp, struct cm_user *userp)
1299 {
1300     afs_int32 code;
1301     cm_scache_t *scp;
1302     cm_req_t req;
1303     cm_ioctlQueryOptions_t * optionsp;
1304     afs_uint32 flags = 0;
1305
1306     smb_InitReq(&req);
1307
1308     optionsp = cm_IoctlGetQueryOptions(&ioctlp->ioctl, userp);
1309     if (optionsp && CM_IOCTL_QOPTS_HAVE_LITERAL(optionsp))
1310         flags |= (optionsp->literal ? CM_PARSE_FLAG_LITERAL : 0);
1311
1312     code = smb_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
1313     if (code) 
1314         return code;
1315
1316     code = cm_IoctlGetFid(&ioctlp->ioctl, userp, scp, &req);
1317
1318     cm_ReleaseSCache(scp);
1319
1320     return code;
1321 }
1322
1323 afs_int32 
1324 smb_IoctlGetFileType(struct smb_ioctl *ioctlp, struct cm_user *userp)
1325 {
1326     afs_int32 code;
1327     cm_scache_t *scp;
1328     cm_req_t req;
1329     cm_ioctlQueryOptions_t * optionsp;
1330     afs_uint32 flags = 0;
1331
1332     smb_InitReq(&req);
1333
1334     optionsp = cm_IoctlGetQueryOptions(&ioctlp->ioctl, userp);
1335     if (optionsp && CM_IOCTL_QOPTS_HAVE_LITERAL(optionsp))
1336         flags |= (optionsp->literal ? CM_PARSE_FLAG_LITERAL : 0);
1337
1338     if (optionsp && CM_IOCTL_QOPTS_HAVE_FID(optionsp)) {
1339         cm_fid_t fid;
1340         cm_SkipIoctlPath(&ioctlp->ioctl);
1341         cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume, 
1342                   optionsp->fid.vnode, optionsp->fid.unique);
1343         code = cm_GetSCache(&fid, &scp, userp, &req);
1344     } else {
1345         code = smb_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
1346     }
1347     if (code) 
1348         return code;
1349
1350     code = cm_IoctlGetFileType(&ioctlp->ioctl, userp, scp, &req);
1351
1352     cm_ReleaseSCache(scp);
1353
1354     return code;
1355 }
1356
1357 afs_int32 
1358 smb_IoctlGetOwner(struct smb_ioctl *ioctlp, struct cm_user *userp)
1359 {
1360     afs_int32 code;
1361     cm_scache_t *scp;
1362     cm_req_t req;
1363     cm_ioctlQueryOptions_t *optionsp;
1364     afs_uint32 flags = 0;
1365
1366     smb_InitReq(&req);
1367
1368     optionsp = cm_IoctlGetQueryOptions(&ioctlp->ioctl, userp);
1369     if (optionsp && CM_IOCTL_QOPTS_HAVE_LITERAL(optionsp))
1370         flags |= (optionsp->literal ? CM_PARSE_FLAG_LITERAL : 0);
1371
1372     if (optionsp && CM_IOCTL_QOPTS_HAVE_FID(optionsp)) {
1373         cm_fid_t fid;
1374         cm_SkipIoctlPath(&ioctlp->ioctl);
1375         cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume,
1376                   optionsp->fid.vnode, optionsp->fid.unique);
1377         code = cm_GetSCache(&fid, &scp, userp, &req);
1378     } else {
1379         code = smb_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
1380     }
1381     if (code) 
1382         return code;
1383
1384     code = cm_IoctlGetOwner(&ioctlp->ioctl, userp, scp, &req);
1385
1386     cm_ReleaseSCache(scp);
1387
1388     return code;
1389 }
1390
1391 afs_int32 
1392 smb_IoctlWhereIs(struct smb_ioctl *ioctlp, struct cm_user *userp)
1393 {
1394     afs_int32 code;
1395     cm_scache_t *scp;
1396     cm_req_t req;
1397     cm_ioctlQueryOptions_t *optionsp;
1398     afs_uint32 flags = 0;
1399
1400     smb_InitReq(&req);
1401
1402     optionsp = cm_IoctlGetQueryOptions(&ioctlp->ioctl, userp);
1403     if (optionsp && CM_IOCTL_QOPTS_HAVE_LITERAL(optionsp))
1404         flags |= (optionsp->literal ? CM_PARSE_FLAG_LITERAL : 0);
1405
1406     if (optionsp && CM_IOCTL_QOPTS_HAVE_FID(optionsp)) {
1407         cm_fid_t fid;
1408         cm_SkipIoctlPath(&ioctlp->ioctl);
1409         cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume,
1410                   optionsp->fid.vnode, optionsp->fid.unique);
1411         code = cm_GetSCache(&fid, &scp, userp, &req);
1412     } else {
1413         code = smb_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
1414     }
1415     if (code) 
1416         return code;
1417
1418     code = cm_IoctlWhereIs(&ioctlp->ioctl, userp, scp, &req);
1419
1420     cm_ReleaseSCache(scp);
1421
1422     return code;
1423 }
1424
1425
1426 afs_int32 
1427 smb_IoctlStatMountPoint(struct smb_ioctl *ioctlp, struct cm_user *userp)
1428 {
1429     afs_int32 code;
1430     cm_scache_t *dscp;
1431     cm_req_t req;
1432
1433     smb_InitReq(&req);
1434
1435     code = smb_ParseIoctlPath(ioctlp, userp, &req, &dscp, 0);
1436     if (code)
1437         return code;
1438
1439     code = cm_IoctlStatMountPoint(&ioctlp->ioctl, userp, dscp, &req);
1440
1441     cm_ReleaseSCache(dscp);
1442
1443     return code;
1444 }
1445
1446 afs_int32 
1447 smb_IoctlDeleteMountPoint(struct smb_ioctl *ioctlp, struct cm_user *userp)
1448 {
1449     afs_int32 code;
1450     cm_scache_t *dscp;
1451     cm_req_t req;
1452
1453     smb_InitReq(&req);
1454
1455     code = smb_ParseIoctlPath(ioctlp, userp, &req, &dscp, 0);
1456     if (code) 
1457         return code;
1458
1459     code = cm_IoctlDeleteMountPoint(&ioctlp->ioctl, userp, dscp, &req);
1460
1461     cm_ReleaseSCache(dscp);
1462
1463     return code;
1464 }
1465
1466 afs_int32 
1467 smb_IoctlCheckServers(struct smb_ioctl *ioctlp, struct cm_user *userp)
1468 {
1469     cm_SkipIoctlPath(&ioctlp->ioctl);   /* we don't care about the path */
1470
1471     return cm_IoctlCheckServers(&ioctlp->ioctl, userp);
1472 }
1473
1474 afs_int32 
1475 smb_IoctlGag(struct smb_ioctl *ioctlp, struct cm_user *userp)
1476 {
1477     /* we don't print anything superfluous, so we don't support the gag call */
1478     return CM_ERROR_INVAL;
1479 }
1480
1481 afs_int32 
1482 smb_IoctlCheckVolumes(struct smb_ioctl *ioctlp, struct cm_user *userp)
1483 {
1484     cm_SkipIoctlPath(&ioctlp->ioctl);
1485
1486     return cm_IoctlCheckVolumes(&ioctlp->ioctl, userp);
1487 }
1488
1489 afs_int32 smb_IoctlSetCacheSize(struct smb_ioctl *ioctlp, struct cm_user *userp)
1490 {
1491     cm_SkipIoctlPath(&ioctlp->ioctl);
1492
1493     return cm_IoctlSetCacheSize(&ioctlp->ioctl, userp);
1494 }
1495
1496
1497 afs_int32 
1498 smb_IoctlTraceControl(struct smb_ioctl *ioctlp, struct cm_user *userp)
1499 {
1500     cm_SkipIoctlPath(&ioctlp->ioctl);
1501        
1502     return cm_IoctlTraceControl(&ioctlp->ioctl, userp);
1503 }
1504
1505 afs_int32 
1506 smb_IoctlGetCacheParms(struct smb_ioctl *ioctlp, struct cm_user *userp)
1507 {
1508     cm_SkipIoctlPath(&ioctlp->ioctl);
1509        
1510     return cm_IoctlGetCacheParms(&ioctlp->ioctl, userp);
1511 }
1512
1513 afs_int32 
1514 smb_IoctlGetCell(struct smb_ioctl *ioctlp, struct cm_user *userp)
1515 {
1516     cm_SkipIoctlPath(&ioctlp->ioctl);
1517
1518     return cm_IoctlGetCell(&ioctlp->ioctl, userp);
1519 }
1520
1521 afs_int32 
1522 smb_IoctlNewCell(struct smb_ioctl *ioctlp, struct cm_user *userp)
1523 {
1524     cm_SkipIoctlPath(&ioctlp->ioctl);
1525
1526     return cm_IoctlNewCell(&ioctlp->ioctl, userp);
1527 }
1528
1529 afs_int32 
1530 smb_IoctlGetWsCell(smb_ioctl_t *ioctlp, cm_user_t *userp)
1531 {
1532     cm_SkipIoctlPath(&ioctlp->ioctl);
1533
1534     return cm_IoctlGetWsCell(&ioctlp->ioctl, userp);
1535 }
1536
1537 afs_int32 
1538 smb_IoctlSysName(struct smb_ioctl *ioctlp, struct cm_user *userp)
1539 {
1540     cm_SkipIoctlPath(&ioctlp->ioctl);
1541
1542     return cm_IoctlSysName(&ioctlp->ioctl, userp);
1543 }
1544
1545 afs_int32 
1546 smb_IoctlGetCellStatus(struct smb_ioctl *ioctlp, struct cm_user *userp)
1547 {
1548     cm_SkipIoctlPath(&ioctlp->ioctl);
1549
1550     return cm_IoctlGetCellStatus(&ioctlp->ioctl, userp);
1551 }
1552
1553 afs_int32 
1554 smb_IoctlSetCellStatus(struct smb_ioctl *ioctlp, struct cm_user *userp)
1555 {
1556     cm_SkipIoctlPath(&ioctlp->ioctl);
1557
1558     return cm_IoctlSetCellStatus(&ioctlp->ioctl, userp);
1559 }
1560
1561 afs_int32
1562 smb_IoctlSetSPrefs(struct smb_ioctl *ioctlp, struct cm_user *userp)
1563 {
1564     cm_SkipIoctlPath(&ioctlp->ioctl);
1565
1566     return cm_IoctlSetSPrefs(&ioctlp->ioctl, userp);
1567 }
1568
1569 afs_int32
1570 smb_IoctlGetSPrefs(struct smb_ioctl *ioctlp, struct cm_user *userp)
1571 {
1572     cm_SkipIoctlPath(&ioctlp->ioctl);
1573
1574     return cm_IoctlGetSPrefs(&ioctlp->ioctl, userp);
1575 }
1576
1577 afs_int32
1578 smb_IoctlStoreBehind(struct smb_ioctl *ioctlp, struct cm_user *userp)
1579 {
1580     /* we ignore default asynchrony since we only have one way
1581      * of doing this today.
1582      */
1583     return 0;
1584 }       
1585
1586 afs_int32
1587 smb_IoctlCreateMountPoint(struct smb_ioctl *ioctlp, struct cm_user *userp)
1588 {
1589     afs_int32 code;
1590     cm_scache_t *dscp;
1591     clientchar_t leaf[LEAF_SIZE];
1592     cm_req_t req;
1593
1594     smb_InitReq(&req);
1595         
1596     code = smb_ParseIoctlParent(ioctlp, userp, &req, &dscp, leaf);
1597     if (code)
1598         return code;
1599
1600     code = cm_IoctlCreateMountPoint(&ioctlp->ioctl, userp, dscp, &req, leaf);
1601
1602     cm_ReleaseSCache(dscp);
1603     return code;
1604 }
1605
1606 afs_int32
1607 smb_IoctlSymlink(struct smb_ioctl *ioctlp, struct cm_user *userp)
1608 {
1609     afs_int32 code;
1610     cm_scache_t *dscp;
1611     clientchar_t leaf[LEAF_SIZE];
1612     cm_req_t req;
1613
1614     smb_InitReq(&req);
1615
1616     code = smb_ParseIoctlParent(ioctlp, userp, &req, &dscp, leaf);
1617     if (code) return code;
1618
1619     code = cm_IoctlSymlink(&ioctlp->ioctl, userp, dscp, &req, leaf);
1620
1621     cm_ReleaseSCache(dscp);
1622
1623     return code;
1624 }
1625
1626 afs_int32 
1627 smb_IoctlListlink(struct smb_ioctl *ioctlp, struct cm_user *userp)
1628 {
1629     afs_int32 code;
1630     cm_scache_t *dscp;
1631     cm_req_t req;
1632
1633     smb_InitReq(&req);
1634
1635     code = smb_ParseIoctlPath(ioctlp, userp, &req, &dscp, 0);
1636     if (code) return code;
1637
1638     code = cm_IoctlListlink(&ioctlp->ioctl, userp, dscp, &req);
1639
1640     cm_ReleaseSCache(dscp);
1641     return code;
1642 }
1643
1644 afs_int32 
1645 smb_IoctlIslink(struct smb_ioctl *ioctlp, struct cm_user *userp)
1646 {/*CHECK FOR VALID SYMLINK*/
1647     afs_int32 code;
1648     cm_scache_t *dscp;
1649     cm_req_t req;
1650
1651     smb_InitReq(&req);
1652
1653     code = smb_ParseIoctlPath(ioctlp, userp, &req, &dscp, 0);
1654     if (code) return code;
1655
1656     code = cm_IoctlIslink(&ioctlp->ioctl, userp, dscp, &req);
1657
1658     cm_ReleaseSCache(dscp);
1659
1660     return code;
1661 }
1662
1663 afs_int32 
1664 smb_IoctlDeletelink(struct smb_ioctl *ioctlp, struct cm_user *userp)
1665 {
1666     afs_int32 code;
1667     cm_scache_t *dscp;
1668     cm_req_t req;
1669
1670     smb_InitReq(&req);
1671
1672     code = smb_ParseIoctlPath(ioctlp, userp, &req, &dscp, 0);
1673     if (code) return code;
1674
1675     code = cm_IoctlDeletelink(&ioctlp->ioctl, userp, dscp, &req);
1676
1677     cm_ReleaseSCache(dscp);
1678
1679     return code;
1680 }
1681
1682 afs_int32 
1683 smb_IoctlGetTokenIter(struct smb_ioctl *ioctlp, struct cm_user *userp)
1684 {
1685     cm_SkipIoctlPath(&ioctlp->ioctl);
1686
1687     return cm_IoctlGetTokenIter(&ioctlp->ioctl, userp);
1688 }
1689
1690 afs_int32
1691 smb_IoctlGetToken(struct smb_ioctl *ioctlp, struct cm_user *userp)
1692 {
1693     cm_SkipIoctlPath(&ioctlp->ioctl);
1694
1695     return cm_IoctlGetToken(&ioctlp->ioctl, userp);
1696 }
1697
1698
1699 afs_int32
1700 smb_IoctlDelToken(struct smb_ioctl *ioctlp, struct cm_user *userp)
1701 {
1702     cm_SkipIoctlPath(&ioctlp->ioctl);
1703
1704     return cm_IoctlDelToken(&ioctlp->ioctl, userp);
1705 }
1706
1707
1708 afs_int32
1709 smb_IoctlDelAllToken(struct smb_ioctl *ioctlp, struct cm_user *userp)
1710 {
1711     cm_SkipIoctlPath(&ioctlp->ioctl);
1712
1713     return cm_IoctlDelAllToken(&ioctlp->ioctl, userp);
1714 }
1715
1716
1717 afs_int32
1718 smb_IoctlMakeSubmount(struct smb_ioctl *ioctlp, struct cm_user *userp)
1719 {
1720     cm_SkipIoctlPath(&ioctlp->ioctl);
1721
1722     return cm_IoctlMakeSubmount(&ioctlp->ioctl, userp);
1723 }
1724
1725 afs_int32
1726 smb_IoctlGetRxkcrypt(struct smb_ioctl *ioctlp, struct cm_user *userp)
1727 {
1728     cm_SkipIoctlPath(&ioctlp->ioctl);
1729
1730     return cm_IoctlGetRxkcrypt(&ioctlp->ioctl, userp);
1731 }
1732
1733 afs_int32
1734 smb_IoctlSetRxkcrypt(struct smb_ioctl *ioctlp, struct cm_user *userp)
1735 {
1736     cm_SkipIoctlPath(&ioctlp->ioctl);
1737
1738     return cm_IoctlSetRxkcrypt(&ioctlp->ioctl, userp);
1739 }
1740
1741 afs_int32
1742 smb_IoctlRxStatProcess(struct smb_ioctl *ioctlp, struct cm_user *userp)
1743 {
1744     cm_SkipIoctlPath(&ioctlp->ioctl);
1745
1746     return cm_IoctlRxStatProcess(&ioctlp->ioctl, userp);
1747 }
1748
1749
1750 afs_int32
1751 smb_IoctlRxStatPeer(struct smb_ioctl *ioctlp, struct cm_user *userp)
1752 {
1753     cm_SkipIoctlPath(&ioctlp->ioctl);
1754
1755     return cm_IoctlRxStatPeer(&ioctlp->ioctl, userp);
1756 }
1757
1758 afs_int32
1759 smb_IoctlUnicodeControl(struct smb_ioctl *ioctlp, struct cm_user *userp)
1760 {
1761     cm_SkipIoctlPath(&ioctlp->ioctl);
1762
1763     return cm_IoctlUnicodeControl(&ioctlp->ioctl, userp);
1764 }
1765
1766 afs_int32
1767 smb_IoctlUUIDControl(struct smb_ioctl *ioctlp, struct cm_user *userp)
1768 {
1769     cm_SkipIoctlPath(&ioctlp->ioctl);
1770
1771     return cm_IoctlUUIDControl(&ioctlp->ioctl, userp);
1772 }
1773
1774
1775 afs_int32
1776 smb_IoctlMemoryDump(struct smb_ioctl *ioctlp, struct cm_user *userp)
1777 {
1778     cm_SkipIoctlPath(&ioctlp->ioctl);
1779
1780     return cm_IoctlMemoryDump(&ioctlp->ioctl, userp);
1781 }
1782
1783 afs_int32
1784 smb_IoctlPathAvailability(struct smb_ioctl *ioctlp, struct cm_user *userp)
1785 {
1786     afs_int32 code;
1787     cm_scache_t *scp;
1788     cm_req_t req;
1789     cm_ioctlQueryOptions_t *optionsp;
1790     afs_uint32 flags = 0;
1791
1792     smb_InitReq(&req);
1793
1794     optionsp = cm_IoctlGetQueryOptions(&ioctlp->ioctl, userp);
1795     if (optionsp && CM_IOCTL_QOPTS_HAVE_LITERAL(optionsp))
1796         flags |= (optionsp->literal ? CM_PARSE_FLAG_LITERAL : 0);
1797
1798     if (optionsp && CM_IOCTL_QOPTS_HAVE_FID(optionsp)) {
1799         cm_fid_t fid;
1800         cm_SkipIoctlPath(&ioctlp->ioctl);
1801         cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume, 
1802                   optionsp->fid.vnode, optionsp->fid.unique);
1803         code = cm_GetSCache(&fid, &scp, userp, &req);
1804     } else {
1805         code = smb_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
1806     }
1807     if (code) 
1808         return code;
1809
1810     code = cm_IoctlPathAvailability(&ioctlp->ioctl, userp, scp, &req);
1811     cm_ReleaseSCache(scp);
1812     return code;
1813 }
1814
1815 afs_int32
1816 smb_IoctlVolStatTest(struct smb_ioctl *ioctlp, struct cm_user *userp)
1817 {
1818     cm_req_t req;
1819
1820     smb_InitReq(&req);
1821
1822     cm_SkipIoctlPath(&ioctlp->ioctl);
1823
1824     return cm_IoctlVolStatTest(&ioctlp->ioctl, userp, &req);
1825 }