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