windows-vc-locks-and-more-20060115
[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 #ifndef DJGPP
14 #include <windows.h>
15 #endif /* !DJGPP */
16 #include <stdlib.h>
17 #include <malloc.h>
18 #include <string.h>
19 #include <stdio.h>
20 #include <time.h>
21
22 #include <osi.h>
23
24 #include "afsd.h"
25
26 #include "smb.h"
27
28 smb_ioctlProc_t *smb_ioctlProcsp[SMB_IOCTL_MAXPROCS];
29
30 /*extern unsigned char smb_LANadapter;*/
31
32 void smb_InitIoctl(void)
33 {
34         int i;
35         for (i=0; i<SMB_IOCTL_MAXPROCS; i++)
36             smb_ioctlProcsp[i] = NULL;
37
38         smb_ioctlProcsp[VIOCGETAL] = cm_IoctlGetACL;
39         smb_ioctlProcsp[VIOC_FILE_CELL_NAME] = cm_IoctlGetFileCellName;
40         smb_ioctlProcsp[VIOCSETAL] = cm_IoctlSetACL;
41         smb_ioctlProcsp[VIOC_FLUSHVOLUME] = cm_IoctlFlushVolume;
42         smb_ioctlProcsp[VIOCFLUSH] = cm_IoctlFlushFile;
43         smb_ioctlProcsp[VIOCSETVOLSTAT] = cm_IoctlSetVolumeStatus;
44         smb_ioctlProcsp[VIOCGETVOLSTAT] = cm_IoctlGetVolumeStatus;
45         smb_ioctlProcsp[VIOCWHEREIS] = cm_IoctlWhereIs;
46         smb_ioctlProcsp[VIOC_AFS_STAT_MT_PT] = cm_IoctlStatMountPoint;
47         smb_ioctlProcsp[VIOC_AFS_DELETE_MT_PT] = cm_IoctlDeleteMountPoint;
48         smb_ioctlProcsp[VIOCCKSERV] = cm_IoctlCheckServers;
49         smb_ioctlProcsp[VIOC_GAG] = cm_IoctlGag;
50         smb_ioctlProcsp[VIOCCKBACK] = cm_IoctlCheckVolumes;
51         smb_ioctlProcsp[VIOCSETCACHESIZE] = cm_IoctlSetCacheSize;
52         smb_ioctlProcsp[VIOCGETCACHEPARMS] = cm_IoctlGetCacheParms;
53         smb_ioctlProcsp[VIOCGETCELL] = cm_IoctlGetCell;
54         smb_ioctlProcsp[VIOCNEWCELL] = cm_IoctlNewCell;
55         smb_ioctlProcsp[VIOC_GET_WS_CELL] = cm_IoctlGetWsCell;
56         smb_ioctlProcsp[VIOC_AFS_SYSNAME] = cm_IoctlSysName;
57         smb_ioctlProcsp[VIOC_GETCELLSTATUS] = cm_IoctlGetCellStatus;
58         smb_ioctlProcsp[VIOC_SETCELLSTATUS] = cm_IoctlSetCellStatus;
59         smb_ioctlProcsp[VIOC_SETSPREFS] = cm_IoctlSetSPrefs;
60         smb_ioctlProcsp[VIOC_GETSPREFS] = cm_IoctlGetSPrefs;
61         smb_ioctlProcsp[VIOC_STOREBEHIND] = cm_IoctlStoreBehind;
62         smb_ioctlProcsp[VIOC_AFS_CREATE_MT_PT] = cm_IoctlCreateMountPoint;
63         smb_ioctlProcsp[VIOC_TRACECTL] = cm_IoctlTraceControl;
64         smb_ioctlProcsp[VIOCSETTOK] = cm_IoctlSetToken;
65         smb_ioctlProcsp[VIOCGETTOK] = cm_IoctlGetTokenIter;
66         smb_ioctlProcsp[VIOCNEWGETTOK] = cm_IoctlGetToken;
67         smb_ioctlProcsp[VIOCDELTOK] = cm_IoctlDelToken;
68         smb_ioctlProcsp[VIOCDELALLTOK] = cm_IoctlDelAllToken;
69         smb_ioctlProcsp[VIOC_SYMLINK] = cm_IoctlSymlink;
70         smb_ioctlProcsp[VIOC_LISTSYMLINK] = cm_IoctlListlink;
71         smb_ioctlProcsp[VIOC_DELSYMLINK] = cm_IoctlDeletelink;
72         smb_ioctlProcsp[VIOC_MAKESUBMOUNT] = cm_IoctlMakeSubmount;
73         smb_ioctlProcsp[VIOC_GETRXKCRYPT] = cm_IoctlGetRxkcrypt;
74         smb_ioctlProcsp[VIOC_SETRXKCRYPT] = cm_IoctlSetRxkcrypt;
75         smb_ioctlProcsp[VIOC_ISSYMLINK] = cm_IoctlIslink;
76 #ifdef DJGPP
77         smb_ioctlProcsp[VIOC_SHUTDOWN] = cm_IoctlShutdown;
78 #endif
79         smb_ioctlProcsp[VIOC_TRACEMEMDUMP] = cm_IoctlMemoryDump;
80         smb_ioctlProcsp[VIOC_ISSYMLINK] = cm_IoctlIslink;
81         smb_ioctlProcsp[VIOC_FLUSHALL] = cm_IoctlFlushAllVolumes;
82         smb_ioctlProcsp[VIOCGETFID] = cm_IoctlGetFid;
83         smb_ioctlProcsp[VIOCGETOWNER] = cm_IoctlGetOwner;
84         smb_ioctlProcsp[VIOC_RXSTAT_PROC] = cm_IoctlRxStatProcess;
85         smb_ioctlProcsp[VIOC_RXSTAT_PEER] = cm_IoctlRxStatPeer;
86 }
87
88 /* called to make a fid structure into an IOCTL fid structure */
89 void smb_SetupIoctlFid(smb_fid_t *fidp, cm_space_t *prefix)
90 {
91     smb_ioctl_t *iop;
92     cm_space_t *copyPrefix;
93
94     lock_ObtainMutex(&fidp->mx);
95     fidp->flags |= SMB_FID_IOCTL;
96     fidp->scp = &cm_data.fakeSCache;
97     cm_HoldSCache(fidp->scp);
98     if (fidp->ioctlp == NULL) {
99         iop = malloc(sizeof(*iop));
100         memset(iop, 0, sizeof(*iop));
101         fidp->ioctlp = iop;
102         iop->fidp = fidp;
103     }
104     if (prefix) {
105         copyPrefix = cm_GetSpace();
106         strcpy(copyPrefix->data, prefix->data);
107         fidp->ioctlp->prefix = copyPrefix;
108     }
109     lock_ReleaseMutex(&fidp->mx);
110 }
111
112 /* called when we receive a read call, does the send of the received data if
113  * this is the first read call.  This is the function that actually makes the
114  * call to the ioctl code.
115  */
116 smb_IoctlPrepareRead(smb_fid_t *fidp, smb_ioctl_t *ioctlp, cm_user_t *userp)
117 {
118     long opcode;
119     smb_ioctlProc_t *procp;
120     long code;
121
122     if (ioctlp->flags & SMB_IOCTLFLAG_DATAIN) {
123         ioctlp->flags &= ~SMB_IOCTLFLAG_DATAIN;
124
125         /* do the call now, or fail if we didn't get an opcode, or
126          * enough of an opcode.
127          */
128         if (ioctlp->inCopied < sizeof(long)) 
129             return CM_ERROR_INVAL;
130         memcpy(&opcode, ioctlp->inDatap, sizeof(long));
131         ioctlp->inDatap += sizeof(long);
132
133         osi_Log1(afsd_logp, "Ioctl opcode 0x%x", opcode);
134
135         /* check for opcode out of bounds */
136         if (opcode < 0 || opcode >= SMB_IOCTL_MAXPROCS)
137             return CM_ERROR_TOOBIG;
138
139         /* check for no such proc */
140         procp = smb_ioctlProcsp[opcode];
141         if (procp == NULL) 
142             return CM_ERROR_BADOP;
143
144         /* otherwise, make the call */
145         ioctlp->outDatap += sizeof(long);       /* reserve room for return code */
146         code = (*procp)(ioctlp, userp);
147
148         osi_Log1(afsd_logp, "Ioctl return code 0x%x", code);
149
150         /* copy in return code */
151         memcpy(ioctlp->outAllocp, &code, sizeof(long));
152     }
153     return 0;
154 }
155
156 /* called when we receive a write call.  If this is the first write call after
157  * a series of reads (or the very first call), then we start a new call.
158  * We also ensure that things are properly initialized for the start of a call.
159  */
160 void smb_IoctlPrepareWrite(smb_fid_t *fidp, smb_ioctl_t *ioctlp)
161 {
162         /* make sure the buffer(s) are allocated */
163         if (!ioctlp->inAllocp) ioctlp->inAllocp = malloc(SMB_IOCTL_MAXDATA);
164         if (!ioctlp->outAllocp) ioctlp->outAllocp = malloc(SMB_IOCTL_MAXDATA);
165
166         /* Fixes fs la problem.  We do a StrToOEM later and if this data isn't initialized we get memory issues. */
167        (void) memset(ioctlp->inAllocp, 0, SMB_IOCTL_MAXDATA);
168        (void) memset(ioctlp->outAllocp, 0, SMB_IOCTL_MAXDATA);
169
170         /* and make sure that we've reset our state for the new incoming request */
171         if (!(ioctlp->flags & SMB_IOCTLFLAG_DATAIN)) {
172                 ioctlp->inCopied = 0;
173                 ioctlp->outCopied = 0;
174                 ioctlp->inDatap = ioctlp->inAllocp;
175                 ioctlp->outDatap = ioctlp->outAllocp;
176                 ioctlp->flags |= SMB_IOCTLFLAG_DATAIN;
177         }
178 }
179
180 /* called from smb_ReceiveCoreRead when we receive a read on the ioctl fid */
181 long smb_IoctlRead(smb_fid_t *fidp, smb_vc_t *vcp, smb_packet_t *inp,
182         smb_packet_t *outp)
183 {
184         smb_ioctl_t *iop;
185         long count;
186         long leftToCopy;
187         char *op;
188         long code;
189         cm_user_t *userp;
190
191         iop = fidp->ioctlp;
192         count = smb_GetSMBParm(inp, 1);
193         userp = smb_GetUser(vcp, inp);
194
195         /* Identify tree */
196     code = smb_LookupTIDPath(vcp, ((smb_t *)inp)->tid, &iop->tidPathp);
197     if(code) {
198         cm_ReleaseUser(userp);
199         return CM_ERROR_NOSUCHPATH;
200     }
201
202         /* turn the connection around, if required */
203         code = smb_IoctlPrepareRead(fidp, iop, userp);
204
205         if (code) {
206                 cm_ReleaseUser(userp);
207                 return code;
208         }
209
210         leftToCopy = (long)((iop->outDatap - iop->outAllocp) - iop->outCopied);
211         if (count > leftToCopy) count = leftToCopy;
212         
213         /* now set the parms for a read of count bytes */
214         smb_SetSMBParm(outp, 0, count);
215         smb_SetSMBParm(outp, 1, 0);
216         smb_SetSMBParm(outp, 2, 0);
217         smb_SetSMBParm(outp, 3, 0);
218         smb_SetSMBParm(outp, 4, 0);
219
220         smb_SetSMBDataLength(outp, count+3);
221
222         op = smb_GetSMBData(outp, NULL);
223         *op++ = 1;
224         *op++ = (char)(count & 0xff);
225         *op++ = (char)((count >> 8) & 0xff);
226         
227         /* now copy the data into the response packet */
228         memcpy(op, iop->outCopied + iop->outAllocp, count);
229
230         /* and adjust the counters */
231         iop->outCopied += count;
232         
233         cm_ReleaseUser(userp);
234         smb_ReleaseFID(fidp);
235
236         return 0;
237 }
238
239 /* called from smb_ReceiveCoreWrite when we receive a write call on the IOCTL
240  * file descriptor.
241  */
242 long smb_IoctlWrite(smb_fid_t *fidp, smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
243 {
244         smb_ioctl_t *iop;
245         long count;
246         long code;
247         char *op;
248         int inDataBlockCount;
249
250         code = 0;
251         count = smb_GetSMBParm(inp, 1);
252         iop = fidp->ioctlp;
253         
254         smb_IoctlPrepareWrite(fidp, iop);
255
256         op = smb_GetSMBData(inp, NULL);
257         op = smb_ParseDataBlock(op, NULL, &inDataBlockCount);
258         
259         if (count + iop->inCopied > SMB_IOCTL_MAXDATA) {
260                 code = CM_ERROR_TOOBIG;
261                 goto done;
262         }
263         
264         /* copy data */
265         memcpy(iop->inDatap + iop->inCopied, op, count);
266         
267         /* adjust counts */
268         iop->inCopied += count;
269
270 done:
271         /* return # of bytes written */
272         if (code == 0) {
273                 smb_SetSMBParm(outp, 0, count);
274                 smb_SetSMBDataLength(outp, 0);
275         }
276
277         smb_ReleaseFID(fidp);
278         return code;
279 }
280
281 /* called from V3 read to handle IOCTL descriptor reads */
282 long smb_IoctlV3Read(smb_fid_t *fidp, smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
283 {
284     smb_ioctl_t *iop;
285     long count;
286     long code;
287     long leftToCopy;
288     char *op;
289     cm_user_t *userp;
290     smb_user_t *uidp;
291
292     iop = fidp->ioctlp;
293     count = smb_GetSMBParm(inp, 5);
294         
295     userp = smb_GetUser(vcp, inp);
296     osi_assert(userp != 0);
297
298     uidp = smb_FindUID(vcp, ((smb_t *)inp)->uid, 0);
299     iop->uidp = uidp;
300     if (uidp && uidp->unp) {
301         osi_Log3(afsd_logp, "Ioctl uid %d user %x name %s",
302                   uidp->userID, userp,
303                   osi_LogSaveString(afsd_logp, uidp->unp->name));
304     } else {
305         if (uidp)
306             osi_Log2(afsd_logp, "Ioctl uid %d user %x no name",
307                      uidp->userID, userp);
308         else
309             osi_Log1(afsd_logp, "Ioctl no uid user %x no name",
310                      userp);
311     }
312
313     code = smb_LookupTIDPath(vcp, ((smb_t *)inp)->tid, &iop->tidPathp);
314     if (code) {
315         if (uidp)
316             smb_ReleaseUID(uidp);
317         cm_ReleaseUser(userp);
318         smb_ReleaseFID(fidp);
319         return CM_ERROR_NOSUCHPATH;
320     }
321
322     code = smb_IoctlPrepareRead(fidp, iop, userp);
323     if (uidp) {
324         iop->uidp = 0;
325         smb_ReleaseUID(uidp);
326     }
327     if (code) {
328         cm_ReleaseUser(userp);
329         smb_ReleaseFID(fidp);
330         return code;
331     }
332
333     leftToCopy = (long)((iop->outDatap - iop->outAllocp) - iop->outCopied);
334     if (count > leftToCopy) count = leftToCopy;
335         
336     /* 0 and 1 are reserved for request chaining, were setup by our caller,
337      * and will be further filled in after we return.
338      */
339     smb_SetSMBParm(outp, 2, 0); /* remaining bytes, for pipes */
340     smb_SetSMBParm(outp, 3, 0); /* resvd */
341     smb_SetSMBParm(outp, 4, 0); /* resvd */
342     smb_SetSMBParm(outp, 5, count);     /* # of bytes we're going to read */
343     /* fill in #6 when we have all the parameters' space reserved */
344     smb_SetSMBParm(outp, 7, 0); /* resv'd */
345     smb_SetSMBParm(outp, 8, 0); /* resv'd */
346     smb_SetSMBParm(outp, 9, 0); /* resv'd */
347     smb_SetSMBParm(outp, 10, 0);        /* resv'd */
348     smb_SetSMBParm(outp, 11, 0);        /* reserved */
349
350     /* get op ptr after putting in the last parm, since otherwise we don't
351      * know where the data really is.
352      */
353     op = smb_GetSMBData(outp, NULL);
354         
355     /* now fill in offset from start of SMB header to first data byte (to op) */
356     smb_SetSMBParm(outp, 6, ((int) (op - outp->data)));
357
358     /* set the packet data length the count of the # of bytes */
359     smb_SetSMBDataLength(outp, count);
360         
361     /* now copy the data into the response packet */
362     memcpy(op, iop->outCopied + iop->outAllocp, count);
363
364     /* and adjust the counters */
365     iop->outCopied += count;
366
367     /* and cleanup things */
368     cm_ReleaseUser(userp);
369     smb_ReleaseFID(fidp);
370
371     return 0;
372 }       
373
374 /* called from Read Raw to handle IOCTL descriptor reads */
375 long smb_IoctlReadRaw(smb_fid_t *fidp, smb_vc_t *vcp, smb_packet_t *inp,
376                       smb_packet_t *outp
377 #ifdef DJGPP
378                       , dos_ptr rawBuf
379 #endif /* DJGPP */
380                       )
381 {
382     smb_ioctl_t *iop;
383     long leftToCopy;
384     NCB *ncbp;
385     long code;
386     cm_user_t *userp;
387 #ifdef DJGPP
388     dos_ptr dos_ncb;
389
390     if (rawBuf == 0)
391     {
392         osi_Log0(afsd_logp, "Failed to get raw buf for smb_IoctlReadRaw");
393         return -1;
394     }
395 #endif /* DJGPP */
396
397     iop = fidp->ioctlp;
398
399     userp = smb_GetUser(vcp, inp);
400
401     /* Log the user */
402     {
403         smb_user_t *uidp;
404
405         uidp = smb_FindUID(vcp, ((smb_t *)inp)->uid, 0);
406         if (uidp && uidp->unp) {
407             osi_Log3(afsd_logp, "Ioctl uid %d user %x name %s",
408                      uidp->userID, userp,
409                      osi_LogSaveString(afsd_logp, uidp->unp->name));
410         } else if (uidp) {
411             osi_Log2(afsd_logp, "Ioctl uid %d user %x no name",
412                      uidp->userID, userp);
413         } else {
414             osi_Log1(afsd_logp, "Ioctl no uid user %x no name",
415                      userp);
416         }
417         if (uidp) 
418             smb_ReleaseUID(uidp);
419     }   
420
421     code = smb_LookupTIDPath(vcp, ((smb_t *)inp)->tid, &iop->tidPathp);
422     if (code) {
423         cm_ReleaseUser(userp);
424         smb_ReleaseFID(fidp);
425         return CM_ERROR_NOSUCHPATH;
426     }
427
428     code = smb_IoctlPrepareRead(fidp, iop, userp);
429     if (code) {
430         cm_ReleaseUser(userp);
431         smb_ReleaseFID(fidp);
432         return code;
433     }
434
435     leftToCopy = (long)((iop->outDatap - iop->outAllocp) - iop->outCopied);
436
437     ncbp = outp->ncbp;
438     memset((char *)ncbp, 0, sizeof(NCB));
439
440     ncbp->ncb_length = (unsigned short) leftToCopy;
441     ncbp->ncb_lsn = (unsigned char) vcp->lsn;
442     ncbp->ncb_command = NCBSEND;
443     /*ncbp->ncb_lana_num = smb_LANadapter;*/
444     ncbp->ncb_lana_num = vcp->lana;
445
446 #ifndef DJGPP
447     ncbp->ncb_buffer = iop->outCopied + iop->outAllocp;
448     code = Netbios(ncbp);
449 #else /* DJGPP */
450     dosmemput(iop->outCopied + iop->outAllocp, ncbp->ncb_length, rawBuf);
451     ncbp->ncb_buffer = rawBuf;
452     dos_ncb = ((smb_ncb_t *)ncbp)->dos_ncb;
453     code = Netbios(ncbp, dos_ncb);
454 #endif /* !DJGPP */
455
456     if (code != 0)
457         osi_Log1(afsd_logp, "ReadRaw send failure code %d", code);
458
459     cm_ReleaseUser(userp);
460     smb_ReleaseFID(fidp);
461
462     return 0;
463 }