hidedots-fix-20040228
[openafs.git] / src / WINNT / afsd / smb3.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 extern osi_hyper_t hzero;
29
30 smb_packet_t *smb_Directory_Watches = NULL;
31 osi_mutex_t smb_Dir_Watch_Lock;
32
33 smb_tran2Dispatch_t smb_tran2DispatchTable[SMB_TRAN2_NOPCODES];
34
35 /* protected by the smb_globalLock */
36 smb_tran2Packet_t *smb_tran2AssemblyQueuep;
37
38 /* retrieve a held reference to a user structure corresponding to an incoming
39  * request */
40 cm_user_t *smb_GetTran2User(smb_vc_t *vcp, smb_tran2Packet_t *inp)
41 {
42         smb_user_t *uidp;
43         cm_user_t *up = NULL;
44         
45         uidp = smb_FindUID(vcp, inp->uid, 0);
46         if (!uidp) return NULL;
47         
48         lock_ObtainMutex(&uidp->mx);
49         if (uidp->unp) {
50           up = uidp->unp->userp;
51           cm_HoldUser(up);
52         }
53         lock_ReleaseMutex(&uidp->mx);
54
55         smb_ReleaseUID(uidp);
56         
57         return up;
58 }
59
60 /*
61  * Return extended attributes.
62  * Right now, we aren't using any of the "new" bits, so this looks exactly
63  * like smb_Attributes() (see smb.c).
64  */
65 unsigned long smb_ExtAttributes(cm_scache_t *scp)
66 {
67         unsigned long attrs;
68
69         if (scp->fileType == CM_SCACHETYPE_DIRECTORY
70             || scp->fileType == CM_SCACHETYPE_MOUNTPOINT)
71                 attrs = SMB_ATTR_DIRECTORY;
72         else
73                 attrs = 0;
74         /*
75          * We used to mark a file RO if it was in an RO volume, but that
76          * turns out to be impolitic in NT.  See defect 10007.
77          */
78 #ifdef notdef
79         if ((scp->unixModeBits & 0222) == 0 || (scp->flags & CM_SCACHEFLAG_RO))
80 #endif
81         if ((scp->unixModeBits & 0222) == 0)
82                 attrs |= SMB_ATTR_READONLY;             /* Read-only */
83
84         if (attrs == 0)
85                 attrs = SMB_ATTR_NORMAL;                /* FILE_ATTRIBUTE_NORMAL */
86
87         return attrs;
88 }
89
90 int smb_V3IsStarMask(char *maskp)
91 {
92         char tc;
93
94         while (tc = *maskp++)
95           if (tc == '?' || tc == '*') return 1;
96         return 0;
97 }
98
99 unsigned char *smb_ParseString(unsigned char *inp, char **chainpp)
100 {
101         if (chainpp) {
102                 /* skip over null-terminated string */
103                 *chainpp = inp + strlen(inp) + 1;
104         }
105         return inp;
106 }
107
108 long smb_ReceiveV3SessionSetupX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
109 {
110     char *tp;
111     char *usern, *pwd, *pwdx;
112     smb_user_t *uidp;
113     unsigned short newUid;
114     unsigned long caps;
115     cm_user_t *userp;
116     smb_username_t *unp;
117     char *s1 = " ";
118
119     /* Check for bad conns */
120     if (vcp->flags & SMB_VCFLAG_REMOTECONN)
121         return CM_ERROR_REMOTECONN;
122
123     /* For NT LM 0.12 and up, get capabilities */
124     if (vcp->flags & SMB_VCFLAG_USENT) {
125         caps = smb_GetSMBParm(inp, 11);
126         if (caps & 0x40)
127             vcp->flags |= SMB_VCFLAG_STATUS32;
128         /* for now, ignore other capability bits */
129     }
130
131     /* Parse the data */
132     tp = smb_GetSMBData(inp, NULL);
133     if (vcp->flags & SMB_VCFLAG_USENT)
134         pwdx = smb_ParseString(tp, &tp);
135     pwd = smb_ParseString(tp, &tp);
136     usern = smb_ParseString(tp, &tp);
137
138     /* On Windows 2000, this function appears to be called more often than
139        it is expected to be called. This resulted in multiple smb_user_t
140        records existing all for the same user session which results in all
141        of the users tokens disappearing.
142
143        To avoid this problem, we look for an existing smb_user_t record
144        based on the users name, and use that one if we find it.
145     */
146
147     uidp = smb_FindUserByNameThisSession(vcp, usern);
148     if (uidp) {   /* already there, so don't create a new one */
149         unp = uidp->unp;
150         userp = unp->userp;
151         newUid = (unsigned short)uidp->userID;  /* For some reason these are different types!*/
152                 osi_LogEvent("AFS smb_ReceiveV3SessionSetupX",NULL,"FindUserByName:Lana[%d],lsn[%d],userid[%d],name[%s]",vcp->lana,vcp->lsn,newUid,usern);
153                 osi_Log3(afsd_logp,"smb_ReceiveV3SessionSetupX FindUserByName:Lana[%d],lsn[%d],userid[%d]",vcp->lana,vcp->lsn,newUid);
154         smb_ReleaseUID(uidp);
155     }
156     else {
157       /* do a global search for the username/machine name pair */
158         unp = smb_FindUserByName(usern, vcp->rname, SMB_FLAG_CREATE);
159
160         /* Create a new UID and cm_user_t structure */
161         userp = unp->userp;
162         if (!userp)
163           userp = cm_NewUser();
164         lock_ObtainMutex(&vcp->mx);
165         if (!vcp->uidCounter)
166             vcp->uidCounter++; /* handle unlikely wraparounds */
167         newUid = (strlen(usern)==0)?0:vcp->uidCounter++;
168         lock_ReleaseMutex(&vcp->mx);
169
170         /* Create a new smb_user_t structure and connect them up */
171         lock_ObtainMutex(&unp->mx);
172         unp->userp = userp;
173         lock_ReleaseMutex(&unp->mx);
174
175         uidp = smb_FindUID(vcp, newUid, SMB_FLAG_CREATE);
176         lock_ObtainMutex(&uidp->mx);
177         uidp->unp = unp;
178                 osi_LogEvent("AFS smb_ReceiveV3SessionSetupX",NULL,"MakeNewUser:VCP[%x],Lana[%d],lsn[%d],userid[%d],TicketKTCName[%s]",(int)vcp,vcp->lana,vcp->lsn,newUid,usern);
179                 osi_Log4(afsd_logp,"smb_ReceiveV3SessionSetupX MakeNewUser:VCP[%x],Lana[%d],lsn[%d],userid[%d]",vcp,vcp->lana,vcp->lsn,newUid);
180         lock_ReleaseMutex(&uidp->mx);
181         smb_ReleaseUID(uidp);
182     }
183
184     /* Return UID to the client */
185     ((smb_t *)outp)->uid = newUid;
186     /* Also to the next chained message */
187     ((smb_t *)inp)->uid = newUid;
188
189     osi_Log3(afsd_logp, "SMB3 session setup name %s creating ID %d%s",
190              osi_LogSaveString(afsd_logp, usern), newUid, osi_LogSaveString(afsd_logp, s1));
191     smb_SetSMBParm(outp, 2, 0);
192     smb_SetSMBDataLength(outp, 0);
193     return 0;
194 }
195
196 long smb_ReceiveV3UserLogoffX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
197 {
198         smb_user_t *uidp;
199
200         /* don't get tokens from this VC */
201         vcp->flags |= SMB_VCFLAG_ALREADYDEAD;
202
203         inp->flags |= SMB_PACKETFLAG_PROFILE_UPDATE_OK;
204
205         /* find the tree and free it */
206     uidp = smb_FindUID(vcp, ((smb_t *)inp)->uid, 0);
207     /* TODO: smb_ReleaseUID() ? */
208     if (uidp) {
209                 char *s1 = NULL, *s2 = NULL;
210
211                 if (s2 == NULL) s2 = " ";
212                 if (s1 == NULL) {s1 = s2; s2 = " ";}
213
214                 osi_Log4(afsd_logp, "SMB3 user logoffX uid %d name %s%s%s",
215                          uidp->userID,
216                          osi_LogSaveString(afsd_logp,
217                  (uidp->unp) ? uidp->unp->name: " "), s1, s2);
218
219                 lock_ObtainMutex(&uidp->mx);
220                 uidp->flags |= SMB_USERFLAG_DELETE;
221                 /*
222                  * it doesn't get deleted right away
223                  * because the vcp points to it
224                  */
225                 lock_ReleaseMutex(&uidp->mx);
226         }
227         else
228                 osi_Log0(afsd_logp, "SMB3 user logoffX");
229
230         smb_SetSMBDataLength(outp, 0);
231         return 0;
232 }
233
234 long smb_ReceiveV3TreeConnectX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
235 {
236         smb_tid_t *tidp;
237         unsigned short newTid;
238         char shareName[256];
239         char *sharePath;
240         int shareFound;
241         char *tp;
242         char *pathp;
243         char *passwordp;
244         char *servicep;
245         cm_user_t *userp;
246         
247         osi_Log0(afsd_logp, "SMB3 receive tree connect");
248
249         /* parse input parameters */
250         tp = smb_GetSMBData(inp, NULL);
251         passwordp = smb_ParseString(tp, &tp);
252         pathp = smb_ParseString(tp, &tp);
253         servicep = smb_ParseString(tp, &tp);
254
255         tp = strrchr(pathp, '\\');
256         if (!tp) {
257                 return CM_ERROR_BADSMB;
258         }
259         strcpy(shareName, tp+1);
260
261         if (strcmp(servicep, "IPC") == 0 || strcmp(shareName, "IPC$") == 0)
262                 return CM_ERROR_NOIPC;
263
264         userp = smb_GetUser(vcp, inp);
265
266         lock_ObtainMutex(&vcp->mx);
267         newTid = vcp->tidCounter++;
268         lock_ReleaseMutex(&vcp->mx);
269         
270         tidp = smb_FindTID(vcp, newTid, SMB_FLAG_CREATE);
271         shareFound = smb_FindShare(vcp, inp, shareName, &sharePath);
272         if (!shareFound) {
273                 smb_ReleaseTID(tidp);
274                 return CM_ERROR_BADSHARENAME;
275         }
276         lock_ObtainMutex(&tidp->mx);
277         tidp->userp = userp;
278         tidp->pathname = sharePath;
279         lock_ReleaseMutex(&tidp->mx);
280         smb_ReleaseTID(tidp);
281
282         if (vcp->flags & SMB_VCFLAG_USENT)
283                 smb_SetSMBParm(outp, 2, 0);     /* OptionalSupport bits */
284
285         ((smb_t *)outp)->tid = newTid;
286         ((smb_t *)inp)->tid = newTid;
287         tp = smb_GetSMBData(outp, NULL);
288         *tp++ = 'A';
289         *tp++ = ':';
290         *tp++ = 0;
291         smb_SetSMBDataLength(outp, 3);
292         
293         osi_Log1(afsd_logp, "SMB3 tree connect created ID %d", newTid);
294         return 0;
295 }
296
297 /* must be called with global tran lock held */
298 smb_tran2Packet_t *smb_FindTran2Packet(smb_vc_t *vcp, smb_packet_t *inp)
299 {
300         smb_tran2Packet_t *tp;
301         smb_t *smbp;
302         
303         smbp = (smb_t *) inp->data;
304         for(tp = smb_tran2AssemblyQueuep; tp; tp = (smb_tran2Packet_t *) osi_QNext(&tp->q)) {
305                 if (tp->vcp == vcp && tp->mid == smbp->mid && tp->tid == smbp->tid)
306                         return tp;
307         }
308         return NULL;
309 }
310
311 smb_tran2Packet_t *smb_NewTran2Packet(smb_vc_t *vcp, smb_packet_t *inp,
312         int totalParms, int totalData)
313 {
314         smb_tran2Packet_t *tp;
315     smb_t *smbp;
316         
317     smbp = (smb_t *) inp->data;
318         tp = malloc(sizeof(*tp));
319     memset(tp, 0, sizeof(*tp));
320     tp->vcp = vcp;
321     smb_HoldVC(vcp);
322     tp->curData = tp->curParms = 0;
323     tp->totalData = totalData;
324     tp->totalParms = totalParms;
325     tp->tid = smbp->tid;
326     tp->mid = smbp->mid;
327     tp->uid = smbp->uid;
328     tp->pid = smbp->pid;
329         tp->res[0] = smbp->res[0];
330         osi_QAdd((osi_queue_t **)&smb_tran2AssemblyQueuep, &tp->q);
331     tp->opcode = smb_GetSMBParm(inp, 14);
332         if (totalParms != 0)
333         tp->parmsp = malloc(totalParms);
334         if (totalData != 0)
335         tp->datap = malloc(totalData);
336         tp->flags |= SMB_TRAN2PFLAG_ALLOC;
337     return tp;
338 }
339
340 smb_tran2Packet_t *smb_GetTran2ResponsePacket(smb_vc_t *vcp,
341         smb_tran2Packet_t *inp, smb_packet_t *outp,
342         int totalParms, int totalData)
343 {
344         smb_tran2Packet_t *tp;
345         unsigned short parmOffset;
346         unsigned short dataOffset;
347         unsigned short dataAlign;
348         
349         tp = malloc(sizeof(*tp));
350         memset(tp, 0, sizeof(*tp));
351         tp->vcp = NULL;
352         tp->curData = tp->curParms = 0;
353         tp->totalData = totalData;
354         tp->totalParms = totalParms;
355         tp->oldTotalParms = totalParms;
356         tp->tid = inp->tid;
357         tp->mid = inp->mid;
358         tp->uid = inp->uid;
359         tp->pid = inp->pid;
360         tp->res[0] = inp->res[0];
361         tp->opcode = inp->opcode;
362
363         /*
364          * We calculate where the parameters and data will start.
365          * This calculation must parallel the calculation in
366          * smb_SendTran2Packet.
367          */
368
369         parmOffset = 10*2 + 35;
370         parmOffset++;                   /* round to even */
371         tp->parmsp = (unsigned short *) (outp->data + parmOffset);
372
373         dataOffset = parmOffset + totalParms;
374         dataAlign = dataOffset & 2;     /* quad-align */
375         dataOffset += dataAlign;
376         tp->datap = outp->data + dataOffset;
377
378         return tp;
379 }
380
381 /* free a tran2 packet; must be called with smb_globalLock held */
382 void smb_FreeTran2Packet(smb_tran2Packet_t *t2p)
383 {
384     if (t2p->vcp) smb_ReleaseVC(t2p->vcp);
385         if (t2p->flags & SMB_TRAN2PFLAG_ALLOC) {
386                 if (t2p->parmsp)
387                         free(t2p->parmsp);
388                 if (t2p->datap)
389                         free(t2p->datap);
390         }
391     free(t2p);
392 }
393
394 /* called with a VC, an input packet to respond to, and an error code.
395  * sends an error response.
396  */
397 void smb_SendTran2Error(smb_vc_t *vcp, smb_tran2Packet_t *t2p,
398         smb_packet_t *tp, long code)
399 {
400         smb_t *smbp;
401         unsigned short errCode;
402         unsigned char errClass;
403         unsigned long NTStatus;
404
405         if (vcp->flags & SMB_VCFLAG_STATUS32)
406                 smb_MapNTError(code, &NTStatus);
407         else
408                 smb_MapCoreError(code, vcp, &errCode, &errClass);
409
410         smb_FormatResponsePacket(vcp, NULL, tp);
411         smbp = (smb_t *) tp;
412         
413         /* We can handle long names */
414         if (vcp->flags & SMB_VCFLAG_USENT)
415                 smbp->flg2 |= 0x40;     /* IS_LONG_NAME */
416         
417         /* now copy important fields from the tran 2 packet */
418         smbp->com = 0x32;               /* tran 2 response */
419         smbp->tid = t2p->tid;
420         smbp->mid = t2p->mid;
421         smbp->pid = t2p->pid;
422         smbp->uid = t2p->uid;
423         smbp->res[0] = t2p->res[0];
424         if (vcp->flags & SMB_VCFLAG_STATUS32) {
425                 smbp->rcls = (unsigned char) (NTStatus & 0xff);
426                 smbp->reh = (unsigned char) ((NTStatus >> 8) & 0xff);
427                 smbp->errLow = (unsigned char) ((NTStatus >> 16) & 0xff);
428                 smbp->errHigh = (unsigned char) ((NTStatus >> 24) & 0xff);
429                 smbp->flg2 |= 0x4000;
430         }
431         else {
432                 smbp->rcls = errClass;
433                 smbp->errLow = (unsigned char) (errCode & 0xff);
434                 smbp->errHigh = (unsigned char) ((errCode >> 8) & 0xff);
435         }
436         
437         /* send packet */
438         smb_SendPacket(vcp, tp);
439 }        
440
441 void smb_SendTran2Packet(smb_vc_t *vcp, smb_tran2Packet_t *t2p, smb_packet_t *tp)
442 {
443         smb_t *smbp;
444         unsigned short parmOffset;
445         unsigned short dataOffset;
446         unsigned short totalLength;
447         unsigned short dataAlign;
448         char *datap;
449         
450         smb_FormatResponsePacket(vcp, NULL, tp);
451         smbp = (smb_t *) tp;
452
453         /* We can handle long names */
454         if (vcp->flags & SMB_VCFLAG_USENT)
455                 smbp->flg2 |= 0x40;     /* IS_LONG_NAME */
456         
457         /* now copy important fields from the tran 2 packet */
458         smbp->com = 0x32;               /* tran 2 response */
459         smbp->tid = t2p->tid;
460         smbp->mid = t2p->mid;
461         smbp->pid = t2p->pid;
462         smbp->uid = t2p->uid;
463         smbp->res[0] = t2p->res[0];
464
465         totalLength = 1 + t2p->totalData + t2p->totalParms;
466
467         /* now add the core parameters (tran2 info) to the packet */
468         smb_SetSMBParm(tp, 0, t2p->totalParms); /* parm bytes */
469         smb_SetSMBParm(tp, 1, t2p->totalData);  /* data bytes */
470         smb_SetSMBParm(tp, 2, 0);               /* reserved */
471         smb_SetSMBParm(tp, 3, t2p->totalParms); /* parm bytes in this packet */
472         parmOffset = 10*2 + 35;                 /* parm offset in packet */
473         parmOffset++;                           /* round to even */
474         smb_SetSMBParm(tp, 4, parmOffset);      /* 11 parm words plus *
475                                                  * hdr, bcc and wct */
476         smb_SetSMBParm(tp, 5, 0);               /* parm displacement */
477         smb_SetSMBParm(tp, 6, t2p->totalData);  /* data in this packet */
478         dataOffset = parmOffset + t2p->oldTotalParms;
479         dataAlign = dataOffset & 2;             /* quad-align */
480         dataOffset += dataAlign;
481         smb_SetSMBParm(tp, 7, dataOffset);      /* offset of data */
482         smb_SetSMBParm(tp, 8, 0);               /* data displacement */
483         smb_SetSMBParm(tp, 9, 0);               /* low: setup word count *
484                                                  * high: resvd */
485         
486         datap = smb_GetSMBData(tp, NULL);
487         *datap++ = 0;                           /* we rounded to even */
488
489         totalLength += dataAlign;
490         smb_SetSMBDataLength(tp, totalLength);
491         
492         /* next, send the datagram */
493         smb_SendPacket(vcp, tp);
494 }
495
496 long smb_ReceiveV3Tran2A(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
497 {
498         smb_tran2Packet_t *asp;
499         int totalParms;
500         int totalData;
501         int parmDisp;
502         int dataDisp;
503         int parmOffset;
504         int dataOffset;
505         int parmCount;
506         int dataCount;
507         int firstPacket;
508         long code;
509
510         /* We sometimes see 0 word count.  What to do? */
511         if (*inp->wctp == 0) {
512 #ifndef DJGPP
513                 HANDLE h;
514                 char *ptbuf[1];
515
516                 osi_Log0(afsd_logp, "TRANSACTION2 word count = 0"); 
517
518                 h = RegisterEventSource(NULL, AFS_DAEMON_EVENT_NAME);
519                 ptbuf[0] = "Transaction2 word count = 0";
520                 ReportEvent(h, EVENTLOG_WARNING_TYPE, 0, 1003, NULL,
521                             1, inp->ncb_length, ptbuf, inp);
522                 DeregisterEventSource(h);
523 #else /* DJGPP */
524                 osi_Log0(afsd_logp, "TRANSACTION2 word count = 0"); 
525 #endif /* !DJGPP */
526
527                 smb_SetSMBDataLength(outp, 0);
528                 smb_SendPacket(vcp, outp);
529                 return 0;
530         }
531
532         totalParms = smb_GetSMBParm(inp, 0);
533         totalData = smb_GetSMBParm(inp, 1);
534         
535         firstPacket = (inp->inCom == 0x32);
536         
537         /* find the packet we're reassembling */
538         lock_ObtainWrite(&smb_globalLock);
539         asp = smb_FindTran2Packet(vcp, inp);
540         if (!asp) {
541                 asp = smb_NewTran2Packet(vcp, inp, totalParms, totalData);
542         }
543         lock_ReleaseWrite(&smb_globalLock);
544         
545         /* now merge in this latest packet; start by looking up offsets */
546         if (firstPacket) {
547                 parmDisp = dataDisp = 0;
548                 parmOffset = smb_GetSMBParm(inp, 10);
549                 dataOffset = smb_GetSMBParm(inp, 12);
550                 parmCount = smb_GetSMBParm(inp, 9);
551                 dataCount = smb_GetSMBParm(inp, 11);
552                 asp->maxReturnParms = smb_GetSMBParm(inp, 2);
553                 asp->maxReturnData = smb_GetSMBParm(inp, 3);
554
555                 osi_Log3(afsd_logp, "SMB3 received T2 init packet total data %d, cur data %d, max return data %d",
556                         totalData, dataCount, asp->maxReturnData);
557         }
558         else {
559                 parmDisp = smb_GetSMBParm(inp, 4);
560                 parmOffset = smb_GetSMBParm(inp, 3);
561                 dataDisp = smb_GetSMBParm(inp, 7);
562                 dataOffset = smb_GetSMBParm(inp, 6);
563                 parmCount = smb_GetSMBParm(inp, 2);
564                 dataCount = smb_GetSMBParm(inp, 5);
565                 
566                 osi_Log2(afsd_logp, "SMB3 received T2 aux packet parms %d, data %d",
567                         parmCount, dataCount);
568         }
569
570     /* now copy the parms and data */
571     if ( parmCount != 0 )
572     {
573         memcpy(((char *)asp->parmsp) + parmDisp, inp->data + parmOffset, parmCount);
574     }
575     if ( dataCount != 0 ) {
576         memcpy(asp->datap + dataDisp, inp->data + dataOffset, dataCount);
577     }
578
579         /* account for new bytes */
580         asp->curData += dataCount;
581         asp->curParms += parmCount;
582         
583         /* finally, if we're done, remove the packet from the queue and dispatch it */
584         if (asp->totalData <= asp->curData && asp->totalParms <= asp->curParms) {
585                 /* we've received it all */
586                 lock_ObtainWrite(&smb_globalLock);
587                 osi_QRemove((osi_queue_t **) &smb_tran2AssemblyQueuep, &asp->q);
588                 lock_ReleaseWrite(&smb_globalLock);
589                 
590             /* now dispatch it */
591             if ( asp->opcode >= 0 && asp->opcode < 20 && smb_tran2DispatchTable[asp->opcode].procp) {
592                 osi_LogEvent("AFS-Dispatch-2[%s]",myCrt_2Dispatch(asp->opcode),"vcp[%x] lana[%d] lsn[%d]",(int)vcp,vcp->lana,vcp->lsn);
593                 osi_Log4(afsd_logp,"AFS Server - Dispatch-2 %s vcp[%x] lana[%d] lsn[%d]",myCrt_2Dispatch(asp->opcode),vcp,vcp->lana,vcp->lsn);
594                 code = (*smb_tran2DispatchTable[asp->opcode].procp)(vcp, asp, outp);
595             }
596             else {
597                 osi_LogEvent("AFS-Dispatch-2 [invalid]", NULL, "op[%x] vcp[%x] lana[%d] lsn[%d]", asp->opcode, vcp, vcp->lana, vcp->lsn);
598                 osi_Log4(afsd_logp,"AFS Server - Dispatch-2 [INVALID] op[%x] vcp[%x] lana[%d] lsn[%d]", asp->opcode, vcp, vcp->lana, vcp->lsn);
599                 code = CM_ERROR_BADOP;
600             }
601
602                 /* if an error is returned, we're supposed to send an error packet,
603                  * otherwise the dispatched function already did the data sending.
604                  * We give dispatched proc the responsibility since it knows how much
605                  * space to allocate.
606                  */
607                 if (code != 0) {
608                         smb_SendTran2Error(vcp, asp, outp, code);
609                 }
610
611                 /* free the input tran 2 packet */
612                 lock_ObtainWrite(&smb_globalLock);
613                 smb_FreeTran2Packet(asp);
614                 lock_ReleaseWrite(&smb_globalLock);
615         }
616         else if (firstPacket) {
617                 /* the first packet in a multi-packet request, we need to send an
618                  * ack to get more data.
619                  */
620                 smb_SetSMBDataLength(outp, 0);
621                 smb_SendPacket(vcp, outp);
622         }
623
624         return 0;
625 }
626
627 long smb_ReceiveTran2Open(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *op)
628 {
629         char *pathp;
630         smb_tran2Packet_t *outp;
631         long code;
632         cm_space_t *spacep;
633         int excl;
634         cm_user_t *userp;
635         cm_scache_t *dscp;              /* dir we're dealing with */
636         cm_scache_t *scp;               /* file we're creating */
637         cm_attr_t setAttr;
638         int initialModeBits;
639         smb_fid_t *fidp;
640         int attributes;
641         char *lastNamep;
642         long dosTime;
643         int openFun;
644         int trunc;
645         int openMode;
646         int extraInfo;
647         int openAction;
648         int parmSlot;                   /* which parm we're dealing with */
649         long returnEALength;
650         char *tidPathp;
651         cm_req_t req;
652
653         cm_InitReq(&req);
654
655         scp = NULL;
656         
657         extraInfo = (p->parmsp[0] & 1); /* return extra info */
658         returnEALength = (p->parmsp[0] & 8);    /* return extended attr length */
659
660         openFun = p->parmsp[6];         /* open function */
661         excl = ((openFun & 3) == 0);
662         trunc = ((openFun & 3) == 2);   /* truncate it */
663         openMode = (p->parmsp[1] & 0x7);
664         openAction = 0;                 /* tracks what we did */
665
666         attributes = p->parmsp[3];
667         dosTime = p->parmsp[4] | (p->parmsp[5] << 16);
668         
669         /* compute initial mode bits based on read-only flag in attributes */
670         initialModeBits = 0666;
671         if (attributes & 1) initialModeBits &= ~0222;
672         
673         pathp = (char *) (&p->parmsp[14]);
674         
675         outp = smb_GetTran2ResponsePacket(vcp, p, op, 40, 0);
676
677         spacep = cm_GetSpace();
678         smb_StripLastComponent(spacep->data, &lastNamep, pathp);
679
680         if (lastNamep && strcmp(lastNamep, SMB_IOCTL_FILENAME) == 0) {
681                 /* special case magic file name for receiving IOCTL requests
682                  * (since IOCTL calls themselves aren't getting through).
683                  */
684                 fidp = smb_FindFID(vcp, 0, SMB_FLAG_CREATE);
685                 smb_SetupIoctlFid(fidp, spacep);
686
687                 /* copy out remainder of the parms */
688                 parmSlot = 0;
689                 outp->parmsp[parmSlot] = fidp->fid; parmSlot++;
690                 if (extraInfo) {
691                         outp->parmsp[parmSlot] = /* attrs */ 0; parmSlot++;
692                         outp->parmsp[parmSlot] = 0; parmSlot++; /* mod time */
693                         outp->parmsp[parmSlot] = 0; parmSlot++;
694                         outp->parmsp[parmSlot] = 0; parmSlot++; /* len */
695                         outp->parmsp[parmSlot] = 0x7fff; parmSlot++;
696                         outp->parmsp[parmSlot] = openMode; parmSlot++;
697                         outp->parmsp[parmSlot] = 0; parmSlot++; /* file type 0 ==> normal file or dir */
698                         outp->parmsp[parmSlot] = 0; parmSlot++; /* IPC junk */
699                 }
700                 /* and the final "always present" stuff */
701                 outp->parmsp[parmSlot] = /* openAction found existing file */ 1; parmSlot++;
702                 /* next write out the "unique" ID */
703                 outp->parmsp[parmSlot] = 0x1234; parmSlot++;
704                 outp->parmsp[parmSlot] = 0x5678; parmSlot++;
705                 outp->parmsp[parmSlot] = 0; parmSlot++;
706                 if (returnEALength) {
707                         outp->parmsp[parmSlot] = 0; parmSlot++;
708                         outp->parmsp[parmSlot] = 0; parmSlot++;
709                 }
710                 
711                 outp->totalData = 0;
712                 outp->totalParms = parmSlot * 2;
713                 
714                 smb_SendTran2Packet(vcp, outp, op);
715                 
716                 smb_FreeTran2Packet(outp);
717
718                 /* and clean up fid reference */
719                 smb_ReleaseFID(fidp);
720                 return 0;
721         }
722
723 #ifdef DEBUG_VERBOSE
724         {
725                 char *hexp, *asciip;
726                 asciip = (lastNamep ? lastNamep : pathp);
727                 hexp = osi_HexifyString( asciip );
728                 DEBUG_EVENT2("AFS","T2Open H[%s] A[%s]", hexp, asciip);
729                 free(hexp);
730         }
731 #endif
732
733         userp = smb_GetTran2User(vcp, p);
734     /* In the off chance that userp is NULL, we log and abandon */
735     if(!userp) {
736         osi_Log1(afsd_logp, "ReceiveTran2Open user [%d] not resolvable", p->uid);
737         smb_FreeTran2Packet(outp);
738         return CM_ERROR_BADSMB;
739     }
740
741         tidPathp = smb_GetTIDPath(vcp, p->tid);
742
743         dscp = NULL;
744         code = cm_NameI(cm_rootSCachep, pathp,
745                         CM_FLAG_FOLLOW | CM_FLAG_CASEFOLD,
746                         userp, tidPathp, &req, &scp);
747         if (code != 0) {
748                 code = cm_NameI(cm_rootSCachep, spacep->data,
749                                 CM_FLAG_FOLLOW | CM_FLAG_CASEFOLD,
750                         userp, tidPathp, &req, &dscp);
751                 cm_FreeSpace(spacep);
752
753                 if (code) {
754                         cm_ReleaseUser(userp);
755                         smb_FreeTran2Packet(outp);
756                         return code;
757                 }
758         
759                 /* otherwise, scp points to the parent directory.  Do a lookup,
760                  * and truncate the file if we find it, otherwise we create the
761                  * file.
762                  */
763                 if (!lastNamep) lastNamep = pathp;
764                 else lastNamep++;
765                 code = cm_Lookup(dscp, lastNamep, CM_FLAG_CASEFOLD, userp,
766                                  &req, &scp);
767                 if (code && code != CM_ERROR_NOSUCHFILE) {
768                         cm_ReleaseSCache(dscp);
769                         cm_ReleaseUser(userp);
770                         smb_FreeTran2Packet(outp);
771                         return code;
772                 }
773         }
774         else {
775                 cm_FreeSpace(spacep);
776         }
777         
778         /* if we get here, if code is 0, the file exists and is represented by
779          * scp.  Otherwise, we have to create it.
780          */
781         if (code == 0) {
782                 code = cm_CheckOpen(scp, openMode, trunc, userp, &req);
783                 if (code) {
784                         if (dscp) cm_ReleaseSCache(dscp);
785                         cm_ReleaseSCache(scp);
786                         cm_ReleaseUser(userp);
787                         smb_FreeTran2Packet(outp);
788                         return code;
789                 }
790
791                 if (excl) {
792                         /* oops, file shouldn't be there */
793                         if (dscp) cm_ReleaseSCache(dscp);
794                         cm_ReleaseSCache(scp);
795                         cm_ReleaseUser(userp);
796                         smb_FreeTran2Packet(outp);
797                         return CM_ERROR_EXISTS;
798                 }
799
800                 if (trunc) {
801                         setAttr.mask = CM_ATTRMASK_LENGTH;
802                         setAttr.length.LowPart = 0;
803                         setAttr.length.HighPart = 0;
804                         code = cm_SetAttr(scp, &setAttr, userp, &req);
805                         openAction = 3; /* truncated existing file */
806                 }
807                 else openAction = 1;    /* found existing file */
808         }
809         else if (!(openFun & SMB_ATTR_DIRECTORY)) {
810                 /* don't create if not found */
811                 if (dscp) cm_ReleaseSCache(dscp);
812                 osi_assert(scp == NULL);
813                 cm_ReleaseUser(userp);
814                 smb_FreeTran2Packet(outp);
815                 return CM_ERROR_NOSUCHFILE;
816         }
817         else {
818                 osi_assert(dscp != NULL && scp == NULL);
819                 openAction = 2; /* created file */
820                 setAttr.mask = CM_ATTRMASK_CLIENTMODTIME;
821                 smb_UnixTimeFromSearchTime(&setAttr.clientModTime, dosTime);
822                 code = cm_Create(dscp, lastNamep, 0, &setAttr, &scp, userp,
823                                  &req);
824                 if (code == 0 && (dscp->flags & CM_SCACHEFLAG_ANYWATCH))
825                         smb_NotifyChange(FILE_ACTION_ADDED,
826                                          FILE_NOTIFY_CHANGE_FILE_NAME,
827                                          dscp, lastNamep, NULL, TRUE);
828                 if (!excl && code == CM_ERROR_EXISTS) {
829                         /* not an exclusive create, and someone else tried
830                          * creating it already, then we open it anyway.  We
831                          * don't bother retrying after this, since if this next
832                          * fails, that means that the file was deleted after we
833                          * started this call.
834                          */
835                         code = cm_Lookup(dscp, lastNamep, CM_FLAG_CASEFOLD,
836                                          userp, &req, &scp);
837                         if (code == 0) {
838                                 if (trunc) {
839                                         setAttr.mask = CM_ATTRMASK_LENGTH;
840                                         setAttr.length.LowPart = 0;
841                                         setAttr.length.HighPart = 0;
842                                         code = cm_SetAttr(scp, &setAttr, userp,
843                                                           &req);
844                                 }
845                         }       /* lookup succeeded */
846                 }
847         }
848         
849         /* we don't need this any longer */
850         if (dscp) cm_ReleaseSCache(dscp);
851
852         if (code) {
853                 /* something went wrong creating or truncating the file */
854                 if (scp) cm_ReleaseSCache(scp);
855                 cm_ReleaseUser(userp);
856                 smb_FreeTran2Packet(outp);
857                 return code;
858         }
859         
860         /* make sure we're about to open a file */
861         if (scp->fileType != CM_SCACHETYPE_FILE) {
862                 cm_ReleaseSCache(scp);
863                 cm_ReleaseUser(userp);
864                 smb_FreeTran2Packet(outp);
865                 return CM_ERROR_ISDIR;
866         }
867
868         /* now all we have to do is open the file itself */
869         fidp = smb_FindFID(vcp, 0, SMB_FLAG_CREATE);
870         osi_assert(fidp);
871         
872         /* save a pointer to the vnode */
873         fidp->scp = scp;
874         
875         /* compute open mode */
876         if (openMode != 1) fidp->flags |= SMB_FID_OPENREAD;
877         if (openMode == 1 || openMode == 2)
878                 fidp->flags |= SMB_FID_OPENWRITE;
879
880         smb_ReleaseFID(fidp);
881         
882         cm_Open(scp, 0, userp);
883
884         /* copy out remainder of the parms */
885         parmSlot = 0;
886         outp->parmsp[parmSlot] = fidp->fid; parmSlot++;
887         lock_ObtainMutex(&scp->mx);
888         if (extraInfo) {
889                 outp->parmsp[parmSlot] = smb_Attributes(scp); parmSlot++;
890                 smb_SearchTimeFromUnixTime(&dosTime, scp->clientModTime);
891                 outp->parmsp[parmSlot] = (unsigned short)(dosTime & 0xffff); parmSlot++;
892                 outp->parmsp[parmSlot] = (unsigned short)((dosTime>>16) & 0xffff); parmSlot++;
893                 outp->parmsp[parmSlot] = (unsigned short) (scp->length.LowPart & 0xffff);
894                         parmSlot++;
895                 outp->parmsp[parmSlot] = (unsigned short) ((scp->length.LowPart >> 16) & 0xffff);
896                         parmSlot++;
897                 outp->parmsp[parmSlot] = openMode; parmSlot++;
898                 outp->parmsp[parmSlot] = 0; parmSlot++; /* file type 0 ==> normal file or dir */
899                 outp->parmsp[parmSlot] = 0; parmSlot++; /* IPC junk */
900         }
901         /* and the final "always present" stuff */
902         outp->parmsp[parmSlot] = openAction; parmSlot++;
903         /* next write out the "unique" ID */
904         outp->parmsp[parmSlot] = (unsigned short) (scp->fid.vnode & 0xffff); parmSlot++;
905         outp->parmsp[parmSlot] = (unsigned short) (scp->fid.volume & 0xffff); parmSlot++;
906         outp->parmsp[parmSlot] = 0; parmSlot++;
907         if (returnEALength) {
908                 outp->parmsp[parmSlot] = 0; parmSlot++;
909                 outp->parmsp[parmSlot] = 0; parmSlot++;
910         }
911         lock_ReleaseMutex(&scp->mx);
912         outp->totalData = 0;            /* total # of data bytes */
913         outp->totalParms = parmSlot * 2;        /* shorts are two bytes */
914
915         smb_SendTran2Packet(vcp, outp, op);
916         
917         smb_FreeTran2Packet(outp);
918
919         cm_ReleaseUser(userp);
920         /* leave scp held since we put it in fidp->scp */
921         return 0;
922 }
923
924 long smb_ReceiveTran2FindFirst(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *outp)
925 {
926         return CM_ERROR_BADOP;
927 }
928
929 long smb_ReceiveTran2FindNext(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *outp)
930 {
931         return CM_ERROR_BADOP;
932 }
933
934 long smb_ReceiveTran2QFSInfo(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *op)
935 {
936         smb_tran2Packet_t *outp;
937         smb_tran2QFSInfo_t qi;
938         int responseSize;
939         osi_hyper_t temp;
940         static char FSname[6] = {'A', 0, 'F', 0, 'S', 0};
941         
942         osi_Log1(afsd_logp, "T2 QFSInfo type 0x%x", p->parmsp[0]);
943
944         switch (p->parmsp[0]) {
945         case 1: responseSize = sizeof(qi.u.allocInfo); break;
946         case 2: responseSize = sizeof(qi.u.volumeInfo); break;
947         case 0x102: responseSize = sizeof(qi.u.FSvolumeInfo); break;
948         case 0x103: responseSize = sizeof(qi.u.FSsizeInfo); break;
949         case 0x104: responseSize = sizeof(qi.u.FSdeviceInfo); break;
950         case 0x105: responseSize = sizeof(qi.u.FSattributeInfo); break;
951         default: return CM_ERROR_INVAL;
952         }
953
954         outp = smb_GetTran2ResponsePacket(vcp, p, op, 0, responseSize);
955         switch (p->parmsp[0]) {
956         case 1:
957                 /* alloc info */
958                 qi.u.allocInfo.FSID = 0;
959                 qi.u.allocInfo.sectorsPerAllocUnit = 1;
960                 qi.u.allocInfo.totalAllocUnits = 0x7fffffff;
961                 qi.u.allocInfo.availAllocUnits = 0x3fffffff;
962                 qi.u.allocInfo.bytesPerSector = 1024;
963                 break;
964
965         case 2:
966                 /* volume info */
967         qi.u.volumeInfo.vsn = 1234;
968         qi.u.volumeInfo.vnCount = 4;
969                 /* we're supposed to pad it out with zeroes to the end */
970                 memset(&qi.u.volumeInfo.label, 0, sizeof(qi.u.volumeInfo.label));
971         memcpy(qi.u.volumeInfo.label, "AFS", 4);
972                 break;
973
974         case 0x102:
975                 /* FS volume info */
976                 memset((char *)&qi.u.FSvolumeInfo.vct, 0, sizeof(FILETIME));
977                 qi.u.FSvolumeInfo.vsn = 1234;
978                 qi.u.FSvolumeInfo.vnCount = 8;
979                 memcpy(qi.u.FSvolumeInfo.label, "A\0F\0S\0\0", 8);
980                 break;
981
982         case 0x103:
983                 /* FS size info */
984                 temp.HighPart = 0;
985                 temp.LowPart = 0x7fffffff;
986                 qi.u.FSsizeInfo.totalAllocUnits = temp;
987                 temp.LowPart = 0x3fffffff;
988                 qi.u.FSsizeInfo.availAllocUnits = temp;
989                 qi.u.FSsizeInfo.sectorsPerAllocUnit = 1;
990                 qi.u.FSsizeInfo.bytesPerSector = 1024;
991                 break;
992
993         case 0x104:
994                 /* FS device info */
995                 qi.u.FSdeviceInfo.devType = 0;  /* don't have a number */
996                 qi.u.FSdeviceInfo.characteristics = 0x50; /* remote, virtual */
997                 break;
998
999         case 0x105:
1000                 /* FS attribute info */
1001                 /* attributes, defined in WINNT.H:
1002                  *      FILE_CASE_SENSITIVE_SEARCH      0x1
1003                  *      FILE_CASE_PRESERVED_NAMES       0x2
1004                  *      <no name defined>               0x4000
1005                  *         If bit 0x4000 is not set, Windows 95 thinks
1006                  *         we can't handle long (non-8.3) names,
1007                  *         despite our protestations to the contrary.
1008                  */
1009                 qi.u.FSattributeInfo.attributes = 0x4003;
1010                 qi.u.FSattributeInfo.maxCompLength = 255;
1011                 qi.u.FSattributeInfo.FSnameLength = 6;
1012                 memcpy(qi.u.FSattributeInfo.FSname, FSname, 6);
1013                 break;
1014         }
1015         
1016         /* copy out return data, and set corresponding sizes */
1017         outp->totalParms = 0;
1018         outp->totalData = responseSize;
1019         memcpy(outp->datap, &qi, responseSize);
1020
1021         /* send and free the packets */
1022         smb_SendTran2Packet(vcp, outp, op);
1023         smb_FreeTran2Packet(outp);
1024
1025         return 0;
1026 }
1027
1028 long smb_ReceiveTran2SetFSInfo(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *outp)
1029 {
1030         return CM_ERROR_BADOP;
1031 }
1032
1033 struct smb_ShortNameRock {
1034         char *maskp;
1035         unsigned int vnode;
1036         char *shortName;
1037         size_t shortNameLen;
1038 };
1039
1040 int cm_GetShortNameProc(cm_scache_t *scp, cm_dirEntry_t *dep, void *vrockp,
1041         osi_hyper_t *offp)
1042 {
1043         struct smb_ShortNameRock *rockp;
1044         char *shortNameEnd;
1045
1046         rockp = vrockp;
1047         /* compare both names and vnodes, though probably just comparing vnodes
1048          * would be safe enough.
1049          */
1050         if (stricmp(dep->name, rockp->maskp) != 0)
1051                 return 0;
1052         if (ntohl(dep->fid.vnode) != rockp->vnode)
1053                 return 0;
1054         /* This is the entry */
1055         cm_Gen8Dot3Name(dep, rockp->shortName, &shortNameEnd);
1056         rockp->shortNameLen = shortNameEnd - rockp->shortName;
1057         return CM_ERROR_STOPNOW;
1058 }
1059
1060 long cm_GetShortName(char *pathp, cm_user_t *userp, cm_req_t *reqp,
1061         char *tidPathp, int vnode, char *shortName, size_t *shortNameLenp)
1062 {
1063         struct smb_ShortNameRock rock;
1064         char *lastNamep;
1065         cm_space_t *spacep;
1066         cm_scache_t *dscp;
1067         int caseFold = CM_FLAG_FOLLOW | CM_FLAG_CASEFOLD;
1068         long code;
1069         osi_hyper_t thyper;
1070
1071         spacep = cm_GetSpace();
1072         smb_StripLastComponent(spacep->data, &lastNamep, pathp);
1073
1074         code = cm_NameI(cm_rootSCachep, spacep->data, caseFold, userp, tidPathp,
1075                         reqp, &dscp);
1076         cm_FreeSpace(spacep);
1077         if (code) return code;
1078
1079         if (!lastNamep) lastNamep = pathp;
1080         else lastNamep++;
1081         thyper.LowPart = 0;
1082         thyper.HighPart = 0;
1083         rock.shortName = shortName;
1084         rock.vnode = vnode;
1085         rock.maskp = lastNamep;
1086         code = cm_ApplyDir(dscp, cm_GetShortNameProc, &rock, &thyper, userp,
1087                            reqp, NULL);
1088
1089         cm_ReleaseSCache(dscp);
1090
1091         if (code == 0)
1092                 return CM_ERROR_NOSUCHFILE;
1093         if (code == CM_ERROR_STOPNOW) {
1094                 *shortNameLenp = rock.shortNameLen;
1095                 return 0;
1096         }
1097         return code;
1098 }
1099
1100 long smb_ReceiveTran2QPathInfo(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *opx)
1101 {
1102         smb_tran2Packet_t *outp;
1103         unsigned long dosTime;
1104         FILETIME ft;
1105         unsigned short infoLevel;
1106         int nbytesRequired;
1107         unsigned short attributes;
1108         unsigned long extAttributes;
1109         char shortName[13];
1110         unsigned int len;
1111         cm_user_t *userp;
1112         cm_space_t *spacep;
1113         cm_scache_t *scp, *dscp;
1114         long code;
1115         char *op;
1116         char *tidPathp;
1117         char *lastComp;
1118         cm_req_t req;
1119
1120         cm_InitReq(&req);
1121
1122         infoLevel = p->parmsp[0];
1123         if (infoLevel == 6) nbytesRequired = 0;
1124         else if (infoLevel == 1) nbytesRequired = 22;
1125         else if (infoLevel == 2) nbytesRequired = 26;
1126         else if (infoLevel == 0x101) nbytesRequired = 40;
1127         else if (infoLevel == 0x102) nbytesRequired = 24;
1128         else if (infoLevel == 0x103) nbytesRequired = 4;
1129         else if (infoLevel == 0x108) nbytesRequired = 30;
1130         else {
1131                 osi_Log2(afsd_logp, "Bad Tran2 op 0x%x infolevel 0x%x",
1132                          p->opcode, infoLevel);
1133                 smb_SendTran2Error(vcp, p, opx, CM_ERROR_INVAL);
1134                 return 0;
1135         }
1136         osi_Log2(afsd_logp, "T2 QPathInfo type 0x%x path %s", infoLevel,
1137                  osi_LogSaveString(afsd_logp, (char *)(&p->parmsp[3])));
1138
1139         outp = smb_GetTran2ResponsePacket(vcp, p, opx, 2, nbytesRequired);
1140
1141         if (infoLevel > 0x100)
1142                 outp->totalParms = 2;
1143         else
1144                 outp->totalParms = 0;
1145         outp->totalData = nbytesRequired;
1146         
1147         /* now, if we're at infoLevel 6, we're only being asked to check
1148          * the syntax, so we just OK things now.  In particular, we're *not*
1149          * being asked to verify anything about the state of any parent dirs.
1150          */
1151         if (infoLevel == 6) {
1152                 smb_SendTran2Packet(vcp, outp, opx);
1153                 smb_FreeTran2Packet(outp);
1154                 return 0;
1155         }
1156         
1157         userp = smb_GetTran2User(vcp, p);
1158         if(!userp) {
1159                 osi_Log1(afsd_logp, "ReceiveTran2QPathInfo unable to resolve user [%d]", p->uid);
1160                 smb_FreeTran2Packet(outp);
1161                 return CM_ERROR_BADSMB;
1162         }
1163
1164         tidPathp = smb_GetTIDPath(vcp, p->tid);
1165
1166         /*
1167          * XXX Strange hack XXX
1168          *
1169          * As of Patch 7 (13 January 98), we are having the following problem:
1170          * In NT Explorer 4.0, whenever we click on a directory, AFS gets
1171          * requests to look up "desktop.ini" in all the subdirectories.
1172          * This can cause zillions of timeouts looking up non-existent cells
1173          * and volumes, especially in the top-level directory.
1174          *
1175          * We have not found any way to avoid this or work around it except
1176          * to explicitly ignore the requests for mount points that haven't
1177          * yet been evaluated and for directories that haven't yet been
1178          * fetched.
1179          */
1180         if (infoLevel == 0x101) {
1181                 spacep = cm_GetSpace();
1182                 smb_StripLastComponent(spacep->data, &lastComp,
1183                                         (char *)(&p->parmsp[3]));
1184                 /* Make sure that lastComp is not NULL */
1185                 if (lastComp) {
1186                     if (strcmp(lastComp, "\\desktop.ini") == 0) {
1187                 code = cm_NameI(cm_rootSCachep, spacep->data,
1188                                 CM_FLAG_CASEFOLD
1189                                 | CM_FLAG_DIRSEARCH
1190                                 | CM_FLAG_FOLLOW,
1191                                 userp, tidPathp, &req, &dscp);
1192                 if (code == 0) {
1193                     if (dscp->fileType == CM_SCACHETYPE_MOUNTPOINT
1194                          && !dscp->mountRootFidp)
1195                         code = CM_ERROR_NOSUCHFILE;
1196                     else if (dscp->fileType == CM_SCACHETYPE_DIRECTORY) {
1197                         cm_buf_t *bp = buf_Find(dscp, &hzero);
1198                         if (bp)
1199                             buf_Release(bp);
1200                         else
1201                             code = CM_ERROR_NOSUCHFILE;
1202                     }
1203                     cm_ReleaseSCache(dscp);
1204                     if (code) {
1205                         cm_FreeSpace(spacep);
1206                         cm_ReleaseUser(userp);
1207                         smb_SendTran2Error(vcp, p, opx, code);
1208                         smb_FreeTran2Packet(outp);
1209                         return 0;
1210                     }
1211                 }
1212             }
1213         }
1214                 cm_FreeSpace(spacep);
1215         }
1216
1217         /* now do namei and stat, and copy out the info */
1218         code = cm_NameI(cm_rootSCachep, (char *)(&p->parmsp[3]),
1219                 CM_FLAG_FOLLOW | CM_FLAG_CASEFOLD, userp, tidPathp, &req, &scp);
1220
1221         if (code) {
1222                 cm_ReleaseUser(userp);
1223                 smb_SendTran2Error(vcp, p, opx, code);
1224                 smb_FreeTran2Packet(outp);
1225                 return 0;
1226         }
1227
1228         lock_ObtainMutex(&scp->mx);
1229         code = cm_SyncOp(scp, NULL, userp, &req, 0,
1230                 CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
1231         if (code) goto done;
1232         
1233         /* now we have the status in the cache entry, and everything is locked.
1234          * Marshall the output data.
1235          */
1236         op = outp->datap;
1237         /* for info level 108, figure out short name */
1238         if (infoLevel == 0x108) {
1239                 code = cm_GetShortName((char *)(&p->parmsp[3]), userp, &req,
1240                                         tidPathp, scp->fid.vnode, shortName,
1241                                         (size_t *) &len);
1242                 if (code) {
1243                         goto done;
1244                 }
1245
1246                 op = outp->datap;
1247                 *((u_long *)op) = len * 2; op += 4;
1248                 mbstowcs((unsigned short *)op, shortName, len);
1249                 op += (len * 2);
1250
1251                 goto done;
1252         }
1253         if (infoLevel == 1 || infoLevel == 2) {
1254                 smb_SearchTimeFromUnixTime(&dosTime, scp->clientModTime);
1255                 *((u_long *)op) = dosTime; op += 4;     /* creation time */
1256                 *((u_long *)op) = dosTime; op += 4;     /* access time */
1257                 *((u_long *)op) = dosTime; op += 4;     /* write time */
1258                 *((u_long *)op) = scp->length.LowPart; op += 4; /* length */
1259                 *((u_long *)op) = scp->length.LowPart; op += 4; /* alloc size */
1260                 attributes = smb_Attributes(scp);
1261                 *((u_short *)op) = attributes; op += 2; /* attributes */
1262         }
1263         else if (infoLevel == 0x101) {
1264                 smb_LargeSearchTimeFromUnixTime(&ft, scp->clientModTime);
1265                 *((FILETIME *)op) = ft; op += 8;        /* creation time */
1266                 *((FILETIME *)op) = ft; op += 8;        /* last access time */
1267                 *((FILETIME *)op) = ft; op += 8;        /* last write time */
1268                 *((FILETIME *)op) = ft; op += 8;        /* last change time */
1269                 extAttributes = smb_ExtAttributes(scp);
1270                 *((u_long *)op) = extAttributes; op += 4; /* extended attribs */
1271                 *((u_long *)op) = 0; op += 4;   /* don't know what this is */
1272         }
1273         else if (infoLevel == 0x102) {
1274                 *((LARGE_INTEGER *)op) = scp->length; op += 8;  /* alloc size */
1275                 *((LARGE_INTEGER *)op) = scp->length; op += 8;  /* EOF */
1276                 *((u_long *)op) = scp->linkCount; op += 4;
1277                 *op++ = 0;
1278                 *op++ = 0;
1279                 *op++ = (scp->fileType == CM_SCACHETYPE_DIRECTORY ? 1 : 0);
1280                 *op++ = 0;
1281         }
1282         else if (infoLevel == 0x103) {
1283                 memset(op, 0, 4); op += 4;      /* EA size */
1284         }
1285
1286         /* now, if we are being asked about extended attrs, return a 0 size */
1287         if (infoLevel == 2) {
1288                 *((u_long *)op) = 0; op += 4;
1289         }
1290         
1291
1292         /* send and free the packets */
1293 done:
1294         lock_ReleaseMutex(&scp->mx);
1295         cm_ReleaseSCache(scp);
1296         cm_ReleaseUser(userp);
1297         if (code == 0) smb_SendTran2Packet(vcp, outp, opx);
1298         else smb_SendTran2Error(vcp, p, opx, code);
1299         smb_FreeTran2Packet(outp);
1300
1301         return 0;
1302 }
1303
1304 long smb_ReceiveTran2SetPathInfo(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *outp)
1305 {
1306         return CM_ERROR_BADOP;
1307 }
1308
1309 long smb_ReceiveTran2QFileInfo(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *opx)
1310 {
1311         smb_tran2Packet_t *outp;
1312         FILETIME ft;
1313         unsigned long attributes;
1314         unsigned short infoLevel;
1315         int nbytesRequired;
1316         unsigned short fid;
1317         cm_user_t *userp;
1318         smb_fid_t *fidp;
1319         cm_scache_t *scp;
1320         char *op;
1321         long code;
1322         cm_req_t req;
1323
1324         cm_InitReq(&req);
1325
1326         fid = p->parmsp[0];
1327         fidp = smb_FindFID(vcp, fid, 0);
1328
1329         if (fidp == NULL) {
1330                 smb_SendTran2Error(vcp, p, opx, CM_ERROR_BADFD);
1331                 return 0;
1332         }
1333
1334         infoLevel = p->parmsp[1];
1335         if (infoLevel == 0x101) nbytesRequired = 40;
1336         else if (infoLevel == 0x102) nbytesRequired = 24;
1337         else if (infoLevel == 0x103) nbytesRequired = 4;
1338         else if (infoLevel == 0x104) nbytesRequired = 6;
1339         else {
1340                 osi_Log2(afsd_logp, "Bad Tran2 op 0x%x infolevel 0x%x",
1341                          p->opcode, infoLevel);
1342                 smb_SendTran2Error(vcp, p, opx, CM_ERROR_INVAL);
1343                 return 0;
1344         }
1345         osi_Log2(afsd_logp, "T2 QFileInfo type 0x%x fid %d", infoLevel, fid);
1346
1347         outp = smb_GetTran2ResponsePacket(vcp, p, opx, 2, nbytesRequired);
1348
1349         if (infoLevel > 0x100)
1350                 outp->totalParms = 2;
1351         else
1352                 outp->totalParms = 0;
1353         outp->totalData = nbytesRequired;
1354
1355         userp = smb_GetTran2User(vcp, p);
1356     if(!userp) {
1357         osi_Log1(afsd_logp, "ReceiveTran2QFileInfo unable to resolve user [%d]", p->uid);
1358         code = CM_ERROR_BADSMB;
1359         goto done;
1360     }
1361
1362         scp = fidp->scp;
1363         lock_ObtainMutex(&scp->mx);
1364         code = cm_SyncOp(scp, NULL, userp, &req, 0,
1365                          CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
1366         if (code) goto done;
1367
1368         /* now we have the status in the cache entry, and everything is locked.
1369          * Marshall the output data.
1370          */
1371         op = outp->datap;
1372         if (infoLevel == 0x101) {
1373                 smb_LargeSearchTimeFromUnixTime(&ft, scp->clientModTime);
1374                 *((FILETIME *)op) = ft; op += 8;        /* creation time */
1375                 *((FILETIME *)op) = ft; op += 8;        /* last access time */
1376                 *((FILETIME *)op) = ft; op += 8;        /* last write time */
1377                 *((FILETIME *)op) = ft; op += 8;        /* last change time */
1378                 attributes = smb_ExtAttributes(scp);
1379                 *((u_long *)op) = attributes; op += 4;
1380                 *((u_long *)op) = 0; op += 4;
1381         }
1382         else if (infoLevel == 0x102) {
1383                 *((LARGE_INTEGER *)op) = scp->length; op += 8;  /* alloc size */
1384                 *((LARGE_INTEGER *)op) = scp->length; op += 8;  /* EOF */
1385                 *((u_long *)op) = scp->linkCount; op += 4;
1386                 *op++ = ((fidp->flags & SMB_FID_DELONCLOSE) ? 1 : 0);
1387                 *op++ = (scp->fileType == CM_SCACHETYPE_DIRECTORY ? 1 : 0);
1388                 *op++ = 0;
1389                 *op++ = 0;
1390         }
1391         else if (infoLevel == 0x103) {
1392                 *((u_long *)op) = 0; op += 4;
1393         }
1394         else if (infoLevel == 0x104) {
1395                 unsigned long len;
1396                 char *name;
1397
1398                 if (fidp->NTopen_wholepathp)
1399                         name = fidp->NTopen_wholepathp;
1400                 else
1401                         name = "\\";    /* probably can't happen */
1402                 len = strlen(name);
1403                 outp->totalData = (len*2) + 4;  /* this is actually what we want to return */
1404                 *((u_long *)op) = len * 2; op += 4;
1405                 mbstowcs((unsigned short *)op, name, len); op += (len * 2);
1406         }
1407
1408         /* send and free the packets */
1409 done:
1410         lock_ReleaseMutex(&scp->mx);
1411         cm_ReleaseUser(userp);
1412         smb_ReleaseFID(fidp);
1413         if (code == 0) smb_SendTran2Packet(vcp, outp, opx);
1414         else smb_SendTran2Error(vcp, p, opx, code);
1415         smb_FreeTran2Packet(outp);
1416
1417         return 0;
1418 }
1419
1420 long smb_ReceiveTran2SetFileInfo(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *op)
1421 {
1422         long code;
1423         unsigned short fid;
1424         smb_fid_t *fidp;
1425         unsigned short infoLevel;
1426         smb_tran2Packet_t *outp;
1427         cm_user_t *userp;
1428         cm_scache_t *scp;
1429         cm_req_t req;
1430
1431         cm_InitReq(&req);
1432
1433         fid = p->parmsp[0];
1434         fidp = smb_FindFID(vcp, fid, 0);
1435
1436         if (fidp == NULL) {
1437                 smb_SendTran2Error(vcp, p, op, CM_ERROR_BADFD);
1438                 return 0;
1439         }
1440
1441         infoLevel = p->parmsp[1];
1442         if (infoLevel > 0x104 || infoLevel < 0x101) {
1443                 osi_Log2(afsd_logp, "Bad Tran2 op 0x%x infolevel 0x%x",
1444                          p->opcode, infoLevel);
1445                 smb_SendTran2Error(vcp, p, op, CM_ERROR_INVAL);
1446                 return 0;
1447         }
1448
1449         if (infoLevel == 0x102 && !(fidp->flags & SMB_FID_OPENDELETE)) {
1450                 smb_SendTran2Error(vcp, p, op, CM_ERROR_NOACCESS);
1451                 return 0;
1452         }
1453         if ((infoLevel == 0x103 || infoLevel == 0x104)
1454             && !(fidp->flags & SMB_FID_OPENWRITE)) {
1455                 smb_SendTran2Error(vcp, p, op, CM_ERROR_NOACCESS);
1456                 return 0;
1457         }
1458
1459         osi_Log1(afsd_logp, "T2 SFileInfo type 0x%x", infoLevel);
1460
1461         outp = smb_GetTran2ResponsePacket(vcp, p, op, 2, 0);
1462
1463         outp->totalParms = 2;
1464         outp->totalData = 0;
1465
1466         userp = smb_GetTran2User(vcp, p);
1467     if(!userp) {
1468         osi_Log1(afsd_logp,"ReceiveTran2SetFileInfo unable to resolve user [%d]", p->uid);
1469         code = CM_ERROR_BADSMB;
1470         goto done;
1471     }
1472
1473         scp = fidp->scp;
1474
1475         if (infoLevel == 0x101) {
1476                 FILETIME lastMod;
1477                 unsigned int attribute;
1478                 cm_attr_t attr;
1479
1480                 /* lock the vnode with a callback; we need the current status
1481                  * to determine what the new status is, in some cases.
1482                  */
1483                 lock_ObtainMutex(&scp->mx);
1484                 code = cm_SyncOp(scp, NULL, userp, &req, 0,
1485                                  CM_SCACHESYNC_GETSTATUS
1486                                  | CM_SCACHESYNC_NEEDCALLBACK);
1487                 if (code) {
1488                         lock_ReleaseMutex(&scp->mx);
1489                         goto done;
1490                 }
1491
1492                 /* prepare for setattr call */
1493                 attr.mask = 0;
1494                 
1495                 lastMod = *((FILETIME *)(p->datap + 16));
1496                 /* when called as result of move a b, lastMod is (-1, -1). 
1497          * If the check for -1 is not present, timestamp
1498                  * of the resulting file will be 1969 (-1)
1499                  */
1500                 if (LargeIntegerNotEqualToZero(*((LARGE_INTEGER *)&lastMod)) && 
1501             lastMod.dwLowDateTime != -1 && lastMod.dwHighDateTime != -1) {
1502                         attr.mask |= CM_ATTRMASK_CLIENTMODTIME;
1503                         smb_UnixTimeFromLargeSearchTime(&attr.clientModTime,
1504                                                         &lastMod);
1505                         fidp->flags |= SMB_FID_MTIMESETDONE;
1506                 }
1507                 
1508                 attribute = *((u_long *)(p->datap + 32));
1509                 if (attribute != 0) {
1510                         if ((scp->unixModeBits & 0222)
1511                             && (attribute & 1) != 0) {
1512                                 /* make a writable file read-only */
1513                                 attr.mask |= CM_ATTRMASK_UNIXMODEBITS;
1514                                 attr.unixModeBits = scp->unixModeBits & ~0222;
1515                         }
1516                         else if ((scp->unixModeBits & 0222) == 0
1517                                  && (attribute & 1) == 0) {
1518                                 /* make a read-only file writable */
1519                                 attr.mask |= CM_ATTRMASK_UNIXMODEBITS;
1520                                 attr.unixModeBits = scp->unixModeBits | 0222;
1521                         }
1522                 }
1523                 lock_ReleaseMutex(&scp->mx);
1524
1525                 /* call setattr */
1526                 if (attr.mask)
1527                         code = cm_SetAttr(scp, &attr, userp, &req);
1528                 else
1529                         code = 0;
1530         }
1531         else if (infoLevel == 0x103 || infoLevel == 0x104) {
1532                 LARGE_INTEGER size = *((LARGE_INTEGER *)(p->datap));
1533                 cm_attr_t attr;
1534
1535                 attr.mask = CM_ATTRMASK_LENGTH;
1536                 attr.length.LowPart = size.LowPart;
1537                 attr.length.HighPart = size.HighPart;
1538                 code = cm_SetAttr(scp, &attr, userp, &req);
1539         }
1540         else if (infoLevel == 0x102) {
1541                 if (*((char *)(p->datap))) {
1542                         code = cm_CheckNTDelete(fidp->NTopen_dscp, scp, userp,
1543                                                 &req);
1544                         if (code == 0)
1545                                 fidp->flags |= SMB_FID_DELONCLOSE;
1546                 }
1547                 else {
1548                         code = 0;
1549                         fidp->flags &= ~SMB_FID_DELONCLOSE;
1550                 }
1551         }
1552 done:
1553         cm_ReleaseUser(userp);
1554         smb_ReleaseFID(fidp);
1555         if (code == 0) smb_SendTran2Packet(vcp, outp, op);
1556         else smb_SendTran2Error(vcp, p, op, code);
1557         smb_FreeTran2Packet(outp);
1558
1559         return 0;
1560 }
1561
1562 long smb_ReceiveTran2FSCTL(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *outp)
1563 {
1564         return CM_ERROR_BADOP;
1565 }
1566
1567 long smb_ReceiveTran2IOCTL(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *outp)
1568 {
1569         return CM_ERROR_BADOP;
1570 }
1571
1572 long smb_ReceiveTran2FindNotifyFirst(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *outp)
1573 {
1574         return CM_ERROR_BADOP;
1575 }
1576
1577 long smb_ReceiveTran2FindNotifyNext(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *outp)
1578 {
1579         return CM_ERROR_BADOP;
1580 }
1581
1582 long smb_ReceiveTran2MKDir(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *outp)
1583 {
1584         return CM_ERROR_BADOP;
1585 }
1586
1587 long smb_ApplyV3DirListPatches(cm_scache_t *dscp,
1588         smb_dirListPatch_t **dirPatchespp, int infoLevel, cm_user_t *userp,
1589         cm_req_t *reqp)
1590 {
1591         long code;
1592         cm_scache_t *scp;
1593         cm_scache_t *targetScp;                 /* target if scp is a symlink */
1594         char *dptr;
1595         long dosTime;
1596         FILETIME ft;
1597         int shortTemp;
1598         unsigned short attr;
1599         unsigned long lattr;
1600         smb_dirListPatch_t *patchp;
1601         smb_dirListPatch_t *npatchp;
1602         
1603         for(patchp = *dirPatchespp; patchp; patchp =
1604                 (smb_dirListPatch_t *) osi_QNext(&patchp->q)) {
1605                 code = cm_GetSCache(&patchp->fid, &scp, userp, reqp);
1606                 if (code) continue;
1607                 lock_ObtainMutex(&scp->mx);
1608                 code = cm_SyncOp(scp, NULL, userp, reqp, 0,
1609                         CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
1610                 if (code) {
1611                         lock_ReleaseMutex(&scp->mx);
1612                         cm_ReleaseSCache(scp);
1613                         continue;
1614                 }
1615                 
1616                 /* now watch for a symlink */
1617                 if (scp->fileType == CM_SCACHETYPE_SYMLINK) {
1618                         lock_ReleaseMutex(&scp->mx);
1619                         code = cm_EvaluateSymLink(dscp, scp, &targetScp, userp,
1620                                                   reqp);
1621                         if (code == 0) {
1622                                 /* we have a more accurate file to use (the
1623                                  * target of the symbolic link).  Otherwise,
1624                                  * we'll just use the symlink anyway.
1625                                  */
1626                                 osi_Log2(afsd_logp, "symlink vp %x to vp %x",
1627                                          scp, targetScp);
1628                                 cm_ReleaseSCache(scp);
1629                                 scp = targetScp;
1630                         }
1631                         lock_ObtainMutex(&scp->mx);
1632                 }
1633
1634                 dptr = patchp->dptr;
1635
1636                 if (infoLevel >= 0x101) {
1637                         /* get filetime */
1638                         smb_LargeSearchTimeFromUnixTime(&ft, scp->clientModTime);
1639
1640                         /* copy to Creation Time */
1641                         *((FILETIME *)dptr) = ft;
1642                         dptr += 8;
1643
1644                         /* copy to Last Access Time */
1645                         *((FILETIME *)dptr) = ft;
1646                         dptr += 8;
1647
1648                         /* copy to Last Write Time */
1649                         *((FILETIME *)dptr) = ft;
1650                         dptr += 8;
1651
1652                         /* copy to Change Time */
1653                         *((FILETIME *)dptr) = ft;
1654                         dptr += 8;
1655
1656                         /* Use length for both file length and alloc length */
1657                         *((LARGE_INTEGER *)dptr) = scp->length;
1658                         dptr += 8;
1659                         *((LARGE_INTEGER *)dptr) = scp->length;
1660                         dptr += 8;
1661
1662                         /* Copy attributes */
1663                         lattr = smb_ExtAttributes(scp);
1664             /* merge in hidden (dot file) attribute */
1665                         if( patchp->flags & SMB_DIRLISTPATCH_DOTFILE )
1666                                 lattr |= SMB_ATTR_HIDDEN;
1667                         *((u_long *)dptr) = lattr;
1668                         dptr += 4;
1669                 }
1670                 else {
1671                         /* get dos time */
1672                         smb_SearchTimeFromUnixTime(&dosTime, scp->clientModTime);
1673
1674                         /* and copy out date */
1675                         shortTemp = (dosTime>>16) & 0xffff;
1676                         *((u_short *)dptr) = shortTemp;
1677                         dptr += 2;
1678
1679                         /* copy out creation time */
1680                         shortTemp = dosTime & 0xffff;
1681                         *((u_short *)dptr) = shortTemp;
1682                         dptr += 2;
1683
1684                         /* and copy out date */
1685                         shortTemp = (dosTime>>16) & 0xffff;
1686                         *((u_short *)dptr) = shortTemp;
1687                         dptr += 2;
1688                         
1689                         /* copy out access time */
1690                         shortTemp = dosTime & 0xffff;
1691                         *((u_short *)dptr) = shortTemp;
1692                         dptr += 2;
1693
1694                         /* and copy out date */
1695                         shortTemp = (dosTime>>16) & 0xffff;
1696                         *((u_short *)dptr) = shortTemp;
1697                         dptr += 2;
1698                         
1699                         /* copy out mod time */
1700                         shortTemp = dosTime & 0xffff;
1701                         *((u_short *)dptr) = shortTemp;
1702                         dptr += 2;
1703
1704                         /* copy out file length and alloc length,
1705                          * using the same for both
1706                          */
1707                         *((u_long *)dptr) = scp->length.LowPart;
1708                         dptr += 4;
1709                         *((u_long *)dptr) = scp->length.LowPart;
1710                         dptr += 4;
1711
1712                         /* finally copy out attributes as short */
1713                         attr = smb_Attributes(scp);
1714             /* merge in hidden (dot file) attribute */
1715             if( patchp->flags & SMB_DIRLISTPATCH_DOTFILE )
1716                 attr |= SMB_ATTR_HIDDEN;
1717                         *dptr++ = attr & 0xff;
1718                         *dptr++ = (attr >> 8) & 0xff;
1719                 }
1720
1721                 lock_ReleaseMutex(&scp->mx);
1722                 cm_ReleaseSCache(scp);
1723         }
1724         
1725         /* now free the patches */
1726         for(patchp = *dirPatchespp; patchp; patchp = npatchp) {
1727                 npatchp = (smb_dirListPatch_t *) osi_QNext(&patchp->q);
1728                 free(patchp);
1729         }
1730         
1731         /* and mark the list as empty */
1732         *dirPatchespp = NULL;
1733
1734         return code;
1735 }
1736
1737 /* do a case-folding search of the star name mask with the name in namep.
1738  * Return 1 if we match, otherwise 0.
1739  */
1740 int smb_V3MatchMask(char *namep, char *maskp, int flags)
1741 {
1742         unsigned char tcp1, tcp2;       /* Pattern characters */
1743         unsigned char tcn1;             /* Name characters */
1744         int sawDot = 0, sawStar = 0;
1745         char *starNamep, *starMaskp;
1746         static char nullCharp[] = {0};
1747
1748         /* make sure we only match 8.3 names, if requested */
1749         if ((flags & CM_FLAG_8DOT3) && !cm_Is8Dot3(namep)) return 0;
1750
1751         /* loop */
1752         while (1) {
1753                 /* Next pattern character */
1754                 tcp1 = *maskp++;
1755
1756                 /* Next name character */
1757                 tcn1 = *namep;
1758
1759                 if (tcp1 == 0) {
1760                         /* 0 - end of pattern */
1761                         if (tcn1 == 0)
1762                                 return 1;
1763                         else
1764                                 return 0;
1765                 }
1766                 else if (tcp1 == '.' || tcp1 == '"') {
1767                         if (sawDot) {
1768                                 if (tcn1 == '.') {
1769                                         namep++;
1770                                         continue;
1771                                 } else
1772                                         return 0;
1773                         }
1774                         else {
1775                                 /*
1776                                  * first dot in pattern;
1777                                  * must match dot or end of name
1778                                  */
1779                                 sawDot = 1;
1780                                 if (tcn1 == 0)
1781                                         continue;
1782                                 else if (tcn1 == '.') {
1783                                         sawStar = 0;
1784                                         namep++;
1785                                         continue;
1786                                 }
1787                                 else
1788                                         return 0;
1789                         }
1790                 }
1791                 else if (tcp1 == '?') {
1792                         if (tcn1 == 0 || tcn1 == '.')
1793                                 return 0;
1794                         namep++;
1795                         continue;
1796                 }
1797                 else if (tcp1 == '>') {
1798                         if (tcn1 != 0 && tcn1 != '.')
1799                                 namep++;
1800                         continue;
1801                 }
1802                 else if (tcp1 == '*' || tcp1 == '<') {
1803                         tcp2 = *maskp++;
1804                         if (tcp2 == 0)
1805                                 return 1;
1806                         else if (tcp2 == '.' || tcp2 == '"') {
1807                                 while (tcn1 != '.' && tcn1 != 0)
1808                                         tcn1 = *++namep;
1809                                 if (tcn1 == 0) {
1810                                         if (sawDot)
1811                                                 return 0;
1812                                         else
1813                                                 continue;
1814                                 }
1815                                 else {
1816                                         namep++;
1817                                         continue;
1818                                 }
1819                         }
1820                         else {
1821                                 /*
1822                                  * pattern character after '*' is not null or
1823                                  * period.  If it is '?' or '>', we are not
1824                                  * going to understand it.  If it is '*' or
1825                                  * '<', we are going to skip over it.  None of
1826                                  * these are likely, I hope.
1827                                  */
1828                                 /* skip over '*' and '<' */
1829                                 while (tcp2 == '*' || tcp2 == '<')
1830                                         tcp2 = *maskp++;
1831
1832                                 /* skip over characters that don't match tcp2 */
1833                                 while (tcn1 != '.' && tcn1 != 0
1834                                         && cm_foldUpper[tcn1] != cm_foldUpper[tcp2])
1835                                         tcn1 = *++namep;
1836
1837                                 /* No match */
1838                                 if (tcn1 == '.' || tcn1 == 0)
1839                                         return 0;
1840
1841                                 /* Remember where we are */
1842                                 sawStar = 1;
1843                                 starMaskp = maskp;
1844                                 starNamep = namep;
1845
1846                                 namep++;
1847                                 continue;
1848                         }
1849                 }
1850                 else {
1851                         /* tcp1 is not a wildcard */
1852                         if (cm_foldUpper[tcn1] == cm_foldUpper[tcp1]) {
1853                                 /* they match */
1854                                 namep++;
1855                                 continue;
1856                         }
1857                         /* if trying to match a star pattern, go back */
1858                         if (sawStar) {
1859                                 maskp = starMaskp - 2;
1860                                 namep = starNamep + 1;
1861                                 sawStar = 0;
1862                                 continue;
1863                         }
1864                         /* that's all */
1865                         return 0;
1866                 }
1867         }
1868 }
1869
1870 long smb_ReceiveTran2SearchDir(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *opx)
1871 {
1872         int attribute;
1873         long nextCookie;
1874         char *tp;
1875         long code;
1876         char *pathp;
1877         cm_dirEntry_t *dep;
1878         int maxCount;
1879         smb_dirListPatch_t *dirListPatchesp;
1880         smb_dirListPatch_t *curPatchp;
1881         cm_buf_t *bufferp;
1882         long temp;
1883         long orbytes;                   /* # of bytes in this output record */
1884         long ohbytes;                   /* # of bytes, except file name */
1885         long onbytes;                   /* # of bytes in name, incl. term. null */
1886         osi_hyper_t dirLength;
1887         osi_hyper_t bufferOffset;
1888         osi_hyper_t curOffset;
1889         osi_hyper_t thyper;
1890         smb_dirSearch_t *dsp;
1891         cm_scache_t *scp;
1892         long entryInDir;
1893         long entryInBuffer;
1894         cm_pageHeader_t *pageHeaderp;
1895         cm_user_t *userp = NULL;
1896         int slotInPage;
1897         int returnedNames;
1898         long nextEntryCookie;
1899         int numDirChunks;               /* # of 32 byte dir chunks in this entry */
1900         char *op;                       /* output data ptr */
1901         char *origOp;                   /* original value of op */
1902         cm_space_t *spacep;             /* for pathname buffer */
1903         long maxReturnData;             /* max # of return data */
1904         long maxReturnParms;            /* max # of return parms */
1905         long bytesInBuffer;             /* # data bytes in the output buffer */
1906         int starPattern;
1907         char *maskp;                    /* mask part of path */
1908         int infoLevel;
1909         int searchFlags;
1910         int eos;
1911         smb_tran2Packet_t *outp;        /* response packet */
1912         char *tidPathp;
1913         int align;
1914         char shortName[13];             /* 8.3 name if needed */
1915         int NeedShortName;
1916         char *shortNameEnd;
1917         int fileType;
1918         cm_fid_t fid;
1919         
1920         cm_req_t req;
1921
1922         cm_InitReq(&req);
1923
1924         eos = 0;
1925         if (p->opcode == 1) {
1926                 /* find first; obtain basic parameters from request */
1927                 attribute = p->parmsp[0];
1928                 maxCount = p->parmsp[1];
1929                 infoLevel = p->parmsp[3];
1930                 searchFlags = p->parmsp[2];
1931                 dsp = smb_NewDirSearch(1);
1932                 dsp->attribute = attribute;
1933                 pathp = ((char *) p->parmsp) + 12;      /* points to path */
1934                 nextCookie = 0;
1935                 maskp = strrchr(pathp, '\\');
1936                 if (maskp == NULL) maskp = pathp;
1937                 else maskp++;   /* skip over backslash */
1938                 strcpy(dsp->mask, maskp);       /* and save mask */
1939                 /* track if this is likely to match a lot of entries */
1940                 starPattern = smb_V3IsStarMask(maskp);
1941         }
1942         else {
1943                 osi_assert(p->opcode == 2);
1944                 /* find next; obtain basic parameters from request or open dir file */
1945                 dsp = smb_FindDirSearch(p->parmsp[0]);
1946                 if (!dsp) return CM_ERROR_BADFD;
1947                 attribute = dsp->attribute;
1948                 maxCount = p->parmsp[1];
1949                 infoLevel = p->parmsp[2];
1950                 searchFlags = p->parmsp[5];
1951                 pathp = NULL;
1952                 nextCookie = p->parmsp[3] | (p->parmsp[4] << 16);
1953                 maskp = dsp->mask;
1954                 starPattern = 1;        /* assume, since required a Find Next */
1955         }
1956
1957         osi_Log4(afsd_logp,
1958                  "T2 search dir attr 0x%x, info level %d, max count %d, flags 0x%x",
1959                  attribute, infoLevel, maxCount, searchFlags);
1960
1961         osi_Log2(afsd_logp, "...T2 search op %d, nextCookie 0x%x",
1962                  p->opcode, nextCookie);
1963
1964         if (infoLevel >= 0x101)
1965                 searchFlags &= ~4;      /* no resume keys */
1966
1967         dirListPatchesp = NULL;
1968
1969         maxReturnData = p->maxReturnData;
1970         if (p->opcode == 1)     /* find first */
1971                 maxReturnParms = 10;    /* bytes */
1972         else
1973                 maxReturnParms = 8;     /* bytes */
1974
1975 #ifndef CM_CONFIG_MULTITRAN2RESPONSES
1976         if (maxReturnData > 6000) maxReturnData = 6000;
1977 #endif /* CM_CONFIG_MULTITRAN2RESPONSES */
1978
1979         outp = smb_GetTran2ResponsePacket(vcp, p, opx, maxReturnParms,
1980                                           maxReturnData);
1981
1982         osi_Log1(afsd_logp, "T2 receive search dir %s",
1983                         osi_LogSaveString(afsd_logp, pathp));
1984         
1985         /* bail out if request looks bad */
1986     if (p->opcode == 1 && !pathp) {
1987         smb_ReleaseDirSearch(dsp);
1988         smb_FreeTran2Packet(outp);
1989         return CM_ERROR_BADSMB;
1990     }
1991         
1992         osi_Log2(afsd_logp, "T2 dir search cookie 0x%x, connection %d",
1993                 nextCookie, dsp->cookie);
1994
1995         userp = smb_GetTran2User(vcp, p);
1996     if (!userp) {
1997         osi_Log1(afsd_logp, "T2 dir search unable to resolve user [%d]", p->uid);
1998         smb_ReleaseDirSearch(dsp);
1999         smb_FreeTran2Packet(outp);
2000         return CM_ERROR_BADSMB;
2001     }
2002
2003         /* try to get the vnode for the path name next */
2004         lock_ObtainMutex(&dsp->mx);
2005         if (dsp->scp) {
2006                 scp = dsp->scp;
2007                 cm_HoldSCache(scp);
2008                 code = 0;
2009         }
2010         else {
2011                 spacep = cm_GetSpace();
2012                 smb_StripLastComponent(spacep->data, NULL, pathp);
2013                 lock_ReleaseMutex(&dsp->mx);
2014
2015                 tidPathp = smb_GetTIDPath(vcp, p->tid);
2016                 code = cm_NameI(cm_rootSCachep, spacep->data,
2017                                 CM_FLAG_FOLLOW | CM_FLAG_CASEFOLD,
2018                                 userp, tidPathp, &req, &scp);
2019                 cm_FreeSpace(spacep);
2020
2021                 lock_ObtainMutex(&dsp->mx);
2022                 if (code == 0) {
2023                         if (dsp->scp != 0) cm_ReleaseSCache(dsp->scp);
2024                         dsp->scp = scp;
2025                         /* we need one hold for the entry we just stored into,
2026                          * and one for our own processing.  When we're done
2027                          * with this function, we'll drop the one for our own
2028                          * processing.  We held it once from the namei call,
2029                          * and so we do another hold now.
2030                          */
2031                         cm_HoldSCache(scp);
2032                         lock_ObtainMutex(&scp->mx);
2033                         if ((scp->flags & CM_SCACHEFLAG_BULKSTATTING) == 0
2034                             && LargeIntegerGreaterOrEqualToZero(scp->bulkStatProgress)) {
2035                                 scp->flags |= CM_SCACHEFLAG_BULKSTATTING;
2036                                 dsp->flags |= SMB_DIRSEARCH_BULKST;
2037                         }
2038                         lock_ReleaseMutex(&scp->mx);
2039                 }
2040         }
2041         lock_ReleaseMutex(&dsp->mx);
2042         if (code) {
2043                 cm_ReleaseUser(userp);
2044                 smb_FreeTran2Packet(outp);
2045                 smb_DeleteDirSearch(dsp);
2046                 smb_ReleaseDirSearch(dsp);
2047                 return code;
2048         }
2049
2050         /* get the directory size */
2051         lock_ObtainMutex(&scp->mx);
2052         code = cm_SyncOp(scp, NULL, userp, &req, 0,
2053                 CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
2054         if (code) {
2055                 lock_ReleaseMutex(&scp->mx);
2056                 cm_ReleaseSCache(scp);
2057                 cm_ReleaseUser(userp);
2058                 smb_FreeTran2Packet(outp);
2059                 smb_DeleteDirSearch(dsp);
2060                 smb_ReleaseDirSearch(dsp);
2061                 return code;
2062         }
2063         
2064         dirLength = scp->length;
2065         bufferp = NULL;
2066         bufferOffset.LowPart = bufferOffset.HighPart = 0;
2067         curOffset.HighPart = 0;
2068         curOffset.LowPart = nextCookie;
2069         origOp = outp->datap;
2070
2071         code = 0;
2072         returnedNames = 0;
2073         bytesInBuffer = 0;
2074         while (1) {
2075                 op = origOp;
2076                 if (searchFlags & 4)
2077                         /* skip over resume key */
2078                         op += 4;
2079
2080                 /* make sure that curOffset.LowPart doesn't point to the first
2081                  * 32 bytes in the 2nd through last dir page, and that it doesn't
2082                  * point at the first 13 32-byte chunks in the first dir page,
2083                  * since those are dir and page headers, and don't contain useful
2084                  * information.
2085                  */
2086                 temp = curOffset.LowPart & (2048-1);
2087                 if (curOffset.HighPart == 0 && curOffset.LowPart < 2048) {
2088                         /* we're in the first page */
2089                         if (temp < 13*32) temp = 13*32;
2090                 }
2091                 else {
2092                         /* we're in a later dir page */
2093                         if (temp < 32) temp = 32;
2094                 }
2095                 
2096                 /* make sure the low order 5 bits are zero */
2097                 temp &= ~(32-1);
2098                 
2099                 /* now put temp bits back ito curOffset.LowPart */
2100                 curOffset.LowPart &= ~(2048-1);
2101                 curOffset.LowPart |= temp;
2102
2103             /* check if we've passed the dir's EOF */
2104             if (LargeIntegerGreaterThanOrEqualTo(curOffset, dirLength)) {
2105                 eos = 1;
2106                 break;
2107             }
2108
2109             /* check if we've returned all the names that will fit in the
2110              * response packet; we check return count as well as the number
2111              * of bytes requested.  We check the # of bytes after we find
2112              * the dir entry, since we'll need to check its size.
2113              */
2114             if (returnedNames >= maxCount) {
2115                 break;
2116             }
2117                 
2118             /* see if we can use the bufferp we have now; compute in which
2119              * page the current offset would be, and check whether that's
2120              * the offset of the buffer we have.  If not, get the buffer.
2121              */
2122             thyper.HighPart = curOffset.HighPart;
2123             thyper.LowPart = curOffset.LowPart & ~(buf_bufferSize-1);
2124             if (!bufferp || !LargeIntegerEqualTo(thyper, bufferOffset)) {
2125                         /* wrong buffer */
2126                 if (bufferp) {
2127                     buf_Release(bufferp);
2128                     bufferp = NULL;
2129                         }   
2130                         lock_ReleaseMutex(&scp->mx);
2131                         lock_ObtainRead(&scp->bufCreateLock);
2132                         code = buf_Get(scp, &thyper, &bufferp);
2133                         lock_ReleaseRead(&scp->bufCreateLock);
2134
2135                         /* now, if we're doing a star match, do bulk fetching
2136                          * of all of the status info for files in the dir.
2137                          */
2138                         if (starPattern) {
2139                                 smb_ApplyV3DirListPatches(scp, &dirListPatchesp,
2140                                                           infoLevel, userp,
2141                                                           &req);
2142                                 if ((dsp->flags & SMB_DIRSEARCH_BULKST)
2143                                     && LargeIntegerGreaterThanOrEqualTo(
2144                                                 thyper, scp->bulkStatProgress)) {
2145                                         /* Don't bulk stat if risking timeout */
2146                                         int now = GetCurrentTime();
2147                                         if (now - req.startTime > 5000) {
2148                                                 scp->bulkStatProgress = thyper;
2149                                                 scp->flags &= ~CM_SCACHEFLAG_BULKSTATTING;
2150                                                 dsp->flags &= ~SMB_DIRSEARCH_BULKST;
2151                                         } else
2152                                                 cm_TryBulkStat(scp, &thyper,
2153                                                                userp, &req);
2154                                 }
2155                         }
2156
2157                         lock_ObtainMutex(&scp->mx);
2158                         if (code) break;
2159                         bufferOffset = thyper;
2160
2161                         /* now get the data in the cache */
2162                         while (1) {
2163                                 code = cm_SyncOp(scp, bufferp, userp, &req,
2164                                         PRSFS_LOOKUP,
2165                                         CM_SCACHESYNC_NEEDCALLBACK
2166                                         | CM_SCACHESYNC_READ);
2167                                 if (code) break;
2168                                 
2169                                 if (cm_HaveBuffer(scp, bufferp, 0)) break;
2170                                 
2171                                 /* otherwise, load the buffer and try again */
2172                                 code = cm_GetBuffer(scp, bufferp, NULL, userp,
2173                                                     &req);
2174                                 if (code) break;
2175                         }
2176                         if (code) {
2177                                 buf_Release(bufferp);
2178                                 bufferp = NULL;
2179                                 break;
2180                         }
2181                 }       /* if (wrong buffer) ... */
2182                 
2183                 /* now we have the buffer containing the entry we're interested
2184                  * in; copy it out if it represents a non-deleted entry.
2185                  */
2186                 entryInDir = curOffset.LowPart & (2048-1);
2187                 entryInBuffer = curOffset.LowPart & (buf_bufferSize - 1);
2188
2189                 /* page header will help tell us which entries are free.  Page
2190                  * header can change more often than once per buffer, since
2191                  * AFS 3 dir page size may be less than (but not more than)
2192                  * a buffer package buffer.
2193                  */
2194                 /* only look intra-buffer */
2195                 temp = curOffset.LowPart & (buf_bufferSize - 1);
2196                 temp &= ~(2048 - 1);    /* turn off intra-page bits */
2197                 pageHeaderp = (cm_pageHeader_t *) (bufferp->datap + temp);
2198
2199                 /* now determine which entry we're looking at in the page.
2200                  * If it is free (there's a free bitmap at the start of the
2201                  * dir), we should skip these 32 bytes.
2202                  */
2203                 slotInPage = (entryInDir & 0x7e0) >> 5;
2204                 if (!(pageHeaderp->freeBitmap[slotInPage>>3]
2205                         & (1 << (slotInPage & 0x7)))) {
2206                         /* this entry is free */
2207                         numDirChunks = 1;       /* only skip this guy */
2208                         goto nextEntry;
2209                 }
2210
2211                 tp = bufferp->datap + entryInBuffer;
2212                 dep = (cm_dirEntry_t *) tp;     /* now points to AFS3 dir entry */
2213
2214                 /* while we're here, compute the next entry's location, too,
2215                  * since we'll need it when writing out the cookie into the dir
2216                  * listing stream.
2217                  *
2218                  * XXXX Probably should do more sanity checking.
2219                  */
2220                 numDirChunks = cm_NameEntries(dep->name, &onbytes);
2221                 
2222                 /* compute offset of cookie representing next entry */
2223                 nextEntryCookie = curOffset.LowPart
2224                                     + (CM_DIR_CHUNKSIZE * numDirChunks);
2225
2226                 /* Need 8.3 name? */
2227                 NeedShortName = 0;
2228                 if (infoLevel == 0x104
2229                     && dep->fid.vnode != 0
2230                     && !cm_Is8Dot3(dep->name)) {
2231                         cm_Gen8Dot3Name(dep, shortName, &shortNameEnd);
2232                         NeedShortName = 1;
2233                 }
2234
2235                 if (dep->fid.vnode != 0
2236                     && (smb_V3MatchMask(dep->name, maskp, CM_FLAG_CASEFOLD)
2237                         || (NeedShortName
2238                             && smb_V3MatchMask(shortName, maskp,
2239                                                 CM_FLAG_CASEFOLD)))) {
2240
2241                         /* Eliminate entries that don't match requested
2242                            attributes */
2243                     if (smb_hideDotFiles && !(dsp->attribute & SMB_ATTR_HIDDEN) && 
2244                         smb_IsDotFile(dep->name))
2245                         goto nextEntry; /* no hidden files */
2246                     
2247                     if (!(dsp->attribute & SMB_ATTR_DIRECTORY))  /* no directories */
2248                     {
2249                             /* We have already done the cm_TryBulkStat above */
2250                             fid.cell = scp->fid.cell;
2251                             fid.volume = scp->fid.volume;
2252                             fid.vnode = ntohl(dep->fid.vnode);
2253                             fid.unique = ntohl(dep->fid.unique);
2254                             fileType = cm_FindFileType(&fid);
2255                             /*osi_Log2(afsd_logp, "smb_ReceiveTran2SearchDir: file %s "
2256                               "has filetype %d", dep->name,
2257                               fileType);*/
2258                             if (fileType == CM_SCACHETYPE_DIRECTORY)
2259                               goto nextEntry;
2260                         }
2261
2262                         /* finally check if this name will fit */
2263
2264                         /* standard dir entry stuff */
2265                         if (infoLevel < 0x101)
2266                                 ohbytes = 23;   /* pre-NT */
2267                         else if (infoLevel == 0x103)
2268                                 ohbytes = 12;   /* NT names only */
2269                         else
2270                                 ohbytes = 64;   /* NT */
2271
2272                         if (infoLevel == 0x104)
2273                                 ohbytes += 26;  /* Short name & length */
2274
2275                         if (searchFlags & 4) {
2276                                 ohbytes += 4;   /* if resume key required */
2277                         }
2278
2279                         if (infoLevel != 1
2280                             && infoLevel != 0x101
2281                             && infoLevel != 0x103)
2282                                 ohbytes += 4;   /* EASIZE */
2283
2284                         /* add header to name & term. null */
2285                         orbytes = onbytes + ohbytes + 1;
2286
2287                         /* now, we round up the record to a 4 byte alignment,
2288                          * and we make sure that we have enough room here for
2289                          * even the aligned version (so we don't have to worry
2290                          * about an * overflow when we pad things out below).
2291                          * That's the reason for the alignment arithmetic below.
2292                          */
2293                         if (infoLevel >= 0x101)
2294                                 align = (4 - (orbytes & 3)) & 3;
2295                         else
2296                                 align = 0;
2297                         if (orbytes + bytesInBuffer + align > maxReturnData)
2298                                 break;
2299
2300                         /* this is one of the entries to use: it is not deleted
2301                          * and it matches the star pattern we're looking for.
2302                          * Put out the name, preceded by its length.
2303                          */
2304                         /* First zero everything else */
2305                         memset(origOp, 0, ohbytes);
2306
2307                         if (infoLevel <= 0x101)
2308                                 *(origOp + ohbytes - 1) = (unsigned char) onbytes;
2309                         else if (infoLevel == 0x103)
2310                                 *((u_long *)(op + 8)) = onbytes;
2311                         else
2312                                 *((u_long *)(op + 60)) = onbytes;
2313                         strcpy(origOp+ohbytes, dep->name);
2314
2315                         /* Short name if requested and needed */
2316                         if (infoLevel == 0x104) {
2317                                 if (NeedShortName) {
2318                                         strcpy(op + 70, shortName);
2319                                         *(op + 68) = shortNameEnd - shortName;
2320                                 }
2321                         }
2322
2323                         /* now, adjust the # of entries copied */
2324                         returnedNames++;
2325
2326                         /* NextEntryOffset and FileIndex */
2327                         if (infoLevel >= 101) {
2328                                 int entryOffset = orbytes + align;
2329                                 *((u_long *)op) = entryOffset;
2330                                 *((u_long *)(op+4)) = nextEntryCookie;
2331                         }
2332
2333                         /* now we emit the attribute.  This is tricky, since
2334                          * we need to really stat the file to find out what
2335                          * type of entry we've got.  Right now, we're copying
2336                          * out data from * a buffer, while holding the scp
2337                          * locked, so it isn't really convenient to stat
2338                          * something now.  We'll put in a place holder
2339                          * now, and make a second pass before returning this
2340                          * to get the real attributes.  So, we just skip the
2341                          * data for now, and adjust it later.  We allocate a
2342                          * patch record to make it easy to find this point
2343                          * later.  The replay will happen at a time when it is
2344                          * safe to unlock the directory.
2345                          */
2346                         if (infoLevel != 0x103) {
2347                                 curPatchp = malloc(sizeof(*curPatchp));
2348                                 osi_QAdd((osi_queue_t **) &dirListPatchesp,
2349                                          &curPatchp->q);
2350                                 curPatchp->dptr = op;
2351                                 if (infoLevel >= 0x101)
2352                                         curPatchp->dptr += 8;
2353
2354                 if (smb_hideDotFiles && smb_IsDotFile(dep->name)) {
2355                     curPatchp->flags = SMB_DIRLISTPATCH_DOTFILE;
2356                 }
2357                 else
2358                     curPatchp->flags = 0;
2359
2360                                 curPatchp->fid.cell = scp->fid.cell;
2361                                 curPatchp->fid.volume = scp->fid.volume;
2362                                 curPatchp->fid.vnode = ntohl(dep->fid.vnode);
2363                                 curPatchp->fid.unique = ntohl(dep->fid.unique);
2364
2365                                 /* temp */
2366                                 curPatchp->dep = dep;
2367                         }
2368
2369                         if (searchFlags & 4)
2370                                 /* put out resume key */
2371                                 *((u_long *)origOp) = nextEntryCookie;
2372
2373                         /* Adjust byte ptr and count */
2374                         origOp += orbytes;      /* skip entire record */
2375                         bytesInBuffer += orbytes;
2376
2377                         /* and pad the record out */
2378                         while (--align >= 0) {
2379                                 *origOp++ = 0;
2380                                 bytesInBuffer++;
2381                         }
2382                         
2383                 }       /* if we're including this name */
2384                 
2385 nextEntry:
2386                 /* and adjust curOffset to be where the new cookie is */
2387                 thyper.HighPart = 0;
2388                 thyper.LowPart = CM_DIR_CHUNKSIZE * numDirChunks;
2389                 curOffset = LargeIntegerAdd(thyper, curOffset);
2390         }               /* while copying data for dir listing */
2391
2392         /* release the mutex */
2393         lock_ReleaseMutex(&scp->mx);
2394         if (bufferp) buf_Release(bufferp);
2395
2396         /* apply and free last set of patches; if not doing a star match, this
2397          * will be empty, but better safe (and freeing everything) than sorry.
2398          */
2399         smb_ApplyV3DirListPatches(scp, &dirListPatchesp, infoLevel, userp,
2400                                   &req);
2401         
2402         /* now put out the final parameters */
2403         if (returnedNames == 0) eos = 1;
2404         if (p->opcode == 1) {
2405                 /* find first */
2406                 outp->parmsp[0] = (unsigned short) dsp->cookie;
2407                 outp->parmsp[1] = returnedNames;
2408                 outp->parmsp[2] = eos;
2409                 outp->parmsp[3] = 0;            /* nothing wrong with EAS */
2410                 outp->parmsp[4] = 0;    /* don't need last name to continue
2411                                          * search, cookie is enough.  Normally,
2412                                          * this is the offset of the file name
2413                                          * of the last entry returned.
2414                                          */
2415                 outp->totalParms = 10;  /* in bytes */
2416         }
2417         else {
2418                 /* find next */
2419                 outp->parmsp[0] = returnedNames;
2420                 outp->parmsp[1] = eos;
2421                 outp->parmsp[2] = 0;    /* EAS error */
2422                 outp->parmsp[3] = 0;    /* last name, as above */
2423                 outp->totalParms = 8;   /* in bytes */
2424         }
2425
2426         /* return # of bytes in the buffer */
2427         outp->totalData = bytesInBuffer;
2428
2429         osi_Log2(afsd_logp, "T2 search dir done, %d names, code %d",
2430                 returnedNames, code);
2431
2432         /* Return error code if unsuccessful on first request */
2433         if (code == 0 && p->opcode == 1 && returnedNames == 0)
2434                 code = CM_ERROR_NOSUCHFILE;
2435
2436         /* if we're supposed to close the search after this request, or if
2437          * we're supposed to close the search if we're done, and we're done,
2438          * or if something went wrong, close the search.
2439          */
2440         /* ((searchFlags & 1) || ((searchFlags & 2) && eos) */
2441         if ((searchFlags & 1) || (returnedNames == 0) || ((searchFlags & 2) &&
2442                                                           eos) || code != 0)
2443             smb_DeleteDirSearch(dsp);
2444         if (code)
2445                 smb_SendTran2Error(vcp, p, opx, code);
2446         else {
2447                 smb_SendTran2Packet(vcp, outp, opx);
2448         }
2449         smb_FreeTran2Packet(outp);
2450         smb_ReleaseDirSearch(dsp);
2451         cm_ReleaseSCache(scp);
2452         cm_ReleaseUser(userp);
2453         return 0;
2454 }
2455
2456 long smb_ReceiveV3FindClose(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
2457 {
2458         int dirHandle;
2459         smb_dirSearch_t *dsp;
2460
2461         dirHandle = smb_GetSMBParm(inp, 0);
2462         
2463         osi_Log1(afsd_logp, "SMB3 find close handle %d", dirHandle);
2464
2465         dsp = smb_FindDirSearch(dirHandle);
2466         
2467         if (!dsp)
2468                 return CM_ERROR_BADFD;
2469         
2470         /* otherwise, we have an FD to destroy */
2471         smb_DeleteDirSearch(dsp);
2472         smb_ReleaseDirSearch(dsp);
2473         
2474         /* and return results */
2475         smb_SetSMBDataLength(outp, 0);
2476
2477         return 0;
2478 }
2479
2480 long smb_ReceiveV3FindNotifyClose(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
2481 {
2482         smb_SetSMBDataLength(outp, 0);
2483         return 0;
2484 }
2485
2486 long smb_ReceiveV3OpenX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
2487 {
2488         char *pathp;
2489         long code;
2490         cm_space_t *spacep;
2491         int excl;
2492         cm_user_t *userp;
2493         cm_scache_t *dscp;              /* dir we're dealing with */
2494         cm_scache_t *scp;               /* file we're creating */
2495         cm_attr_t setAttr;
2496         int initialModeBits;
2497         smb_fid_t *fidp;
2498         int attributes;
2499         char *lastNamep;
2500         long dosTime;
2501         int openFun;
2502         int trunc;
2503         int openMode;
2504         int extraInfo;
2505         int openAction;
2506         int parmSlot;                   /* which parm we're dealing with */
2507         char *tidPathp;
2508         cm_req_t req;
2509
2510         cm_InitReq(&req);
2511
2512         scp = NULL;
2513         
2514         extraInfo = (smb_GetSMBParm(inp, 2) & 1);       /* return extra info */
2515         openFun = smb_GetSMBParm(inp, 8);       /* open function */
2516         excl = ((openFun & 3) == 0);
2517         trunc = ((openFun & 3) == 2);           /* truncate it */
2518         openMode = (smb_GetSMBParm(inp, 3) & 0x7);
2519         openAction = 0;                 /* tracks what we did */
2520
2521         attributes = smb_GetSMBParm(inp, 5);
2522         dosTime = smb_GetSMBParm(inp, 6) | (smb_GetSMBParm(inp, 7) << 16);
2523         
2524         /* compute initial mode bits based on read-only flag in attributes */
2525         initialModeBits = 0666;
2526         if (attributes & 1) initialModeBits &= ~0222;
2527         
2528         pathp = smb_GetSMBData(inp, NULL);
2529
2530         spacep = inp->spacep;
2531         smb_StripLastComponent(spacep->data, &lastNamep, pathp);
2532
2533         if (lastNamep && strcmp(lastNamep, SMB_IOCTL_FILENAME) == 0) {
2534                 /* special case magic file name for receiving IOCTL requests
2535          * (since IOCTL calls themselves aren't getting through).
2536          */
2537 #ifdef NOTSERVICE
2538         osi_Log0(afsd_logp, "IOCTL Open");
2539 #endif
2540
2541                 fidp = smb_FindFID(vcp, 0, SMB_FLAG_CREATE);
2542                 smb_SetupIoctlFid(fidp, spacep);
2543
2544                 /* set inp->fid so that later read calls in same msg can find fid */
2545                 inp->fid = fidp->fid;
2546         
2547                 /* copy out remainder of the parms */
2548                 parmSlot = 2;
2549                 smb_SetSMBParm(outp, parmSlot, fidp->fid); parmSlot++;
2550                 if (extraInfo) {
2551                         smb_SetSMBParm(outp, parmSlot, /* attrs */ 0); parmSlot++;
2552                         smb_SetSMBParm(outp, parmSlot, 0); parmSlot++;  /* mod time */
2553                         smb_SetSMBParm(outp, parmSlot, 0); parmSlot++;
2554                         smb_SetSMBParm(outp, parmSlot, 0); parmSlot++;  /* len */
2555                         smb_SetSMBParm(outp, parmSlot, 0x7fff); parmSlot++;
2556                         smb_SetSMBParm(outp, parmSlot, openMode); parmSlot++;
2557                         smb_SetSMBParm(outp, parmSlot, 0); parmSlot++; /* file type 0 ==> normal file or dir */
2558                         smb_SetSMBParm(outp, parmSlot, 0); parmSlot++; /* IPC junk */
2559                 }
2560                 /* and the final "always present" stuff */
2561                 smb_SetSMBParm(outp, parmSlot, /* openAction found existing file */ 1); parmSlot++;
2562                 /* next write out the "unique" ID */
2563                 smb_SetSMBParm(outp, parmSlot, 0x1234); parmSlot++;
2564                 smb_SetSMBParm(outp, parmSlot, 0x5678); parmSlot++;
2565                 smb_SetSMBParm(outp, parmSlot, 0); parmSlot++;
2566                 smb_SetSMBDataLength(outp, 0);
2567
2568                 /* and clean up fid reference */
2569                 smb_ReleaseFID(fidp);
2570                 return 0;
2571         }
2572
2573 #ifdef DEBUG_VERBOSE
2574     {
2575         char *hexp, *asciip;
2576         asciip = (lastNamep ? lastNamep : pathp );
2577         hexp = osi_HexifyString(asciip);
2578         DEBUG_EVENT2("AFS", "V3Open H[%s] A[%s]", hexp, asciip );
2579         free(hexp);
2580     }
2581 #endif
2582     userp = smb_GetUser(vcp, inp);
2583
2584         dscp = NULL;
2585         tidPathp = smb_GetTIDPath(vcp, ((smb_t *)inp)->tid);
2586         code = cm_NameI(cm_rootSCachep, pathp,
2587                 CM_FLAG_FOLLOW | CM_FLAG_CASEFOLD,
2588                 userp, tidPathp, &req, &scp);
2589         if (code != 0) {
2590                 code = cm_NameI(cm_rootSCachep, spacep->data,
2591                                 CM_FLAG_FOLLOW | CM_FLAG_CASEFOLD,
2592                                 userp, tidPathp, &req, &dscp);
2593
2594                 if (code) {
2595                         cm_ReleaseUser(userp);
2596                         return code;
2597                 }
2598         
2599                 /* otherwise, scp points to the parent directory.  Do a lookup,
2600                  * and truncate the file if we find it, otherwise we create the
2601                  * file.
2602                  */
2603                 if (!lastNamep) lastNamep = pathp;
2604                 else lastNamep++;
2605                 code = cm_Lookup(dscp, lastNamep, CM_FLAG_CASEFOLD, userp,
2606                                  &req, &scp);
2607                 if (code && code != CM_ERROR_NOSUCHFILE) {
2608                         cm_ReleaseSCache(dscp);
2609                         cm_ReleaseUser(userp);
2610                         return code;
2611                 }
2612         }
2613         
2614         /* if we get here, if code is 0, the file exists and is represented by
2615          * scp.  Otherwise, we have to create it.  The dir may be represented
2616          * by dscp, or we may have found the file directly.  If code is non-zero,
2617          * scp is NULL.
2618          */
2619         if (code == 0) {
2620                 code = cm_CheckOpen(scp, openMode, trunc, userp, &req);
2621                 if (code) {
2622                         if (dscp) cm_ReleaseSCache(dscp);
2623                         cm_ReleaseSCache(scp);
2624                         cm_ReleaseUser(userp);
2625                         return code;
2626                 }
2627
2628                 if (excl) {
2629                         /* oops, file shouldn't be there */
2630                         if (dscp) cm_ReleaseSCache(dscp);
2631                         cm_ReleaseSCache(scp);
2632                         cm_ReleaseUser(userp);
2633                         return CM_ERROR_EXISTS;
2634                 }
2635
2636                 if (trunc) {
2637                         setAttr.mask = CM_ATTRMASK_LENGTH;
2638                         setAttr.length.LowPart = 0;
2639                         setAttr.length.HighPart = 0;
2640                         code = cm_SetAttr(scp, &setAttr, userp, &req);
2641                         openAction = 3; /* truncated existing file */
2642                 }
2643                 else openAction = 1;    /* found existing file */
2644         }
2645         else if (!(openFun & 0x10)) {
2646                 /* don't create if not found */
2647                 if (dscp) cm_ReleaseSCache(dscp);
2648                 cm_ReleaseUser(userp);
2649                 return CM_ERROR_NOSUCHFILE;
2650         }
2651         else {
2652                 osi_assert(dscp != NULL);
2653                 osi_Log1(afsd_logp, "smb_ReceiveV3OpenX creating file %s",
2654                                 osi_LogSaveString(afsd_logp, lastNamep));
2655                 openAction = 2; /* created file */
2656                 setAttr.mask = CM_ATTRMASK_CLIENTMODTIME;
2657                 smb_UnixTimeFromDosUTime(&setAttr.clientModTime, dosTime);
2658                 code = cm_Create(dscp, lastNamep, 0, &setAttr, &scp, userp,
2659                                  &req);
2660                 if (code == 0 && (dscp->flags & CM_SCACHEFLAG_ANYWATCH))
2661                         smb_NotifyChange(FILE_ACTION_ADDED,
2662                                          FILE_NOTIFY_CHANGE_FILE_NAME,
2663                                          dscp, lastNamep, NULL, TRUE);
2664                 if (!excl && code == CM_ERROR_EXISTS) {
2665                         /* not an exclusive create, and someone else tried
2666                          * creating it already, then we open it anyway.  We
2667                          * don't bother retrying after this, since if this next
2668                          * fails, that means that the file was deleted after we
2669                          * started this call.
2670                          */
2671                         code = cm_Lookup(dscp, lastNamep, CM_FLAG_CASEFOLD,
2672                                          userp, &req, &scp);
2673                         if (code == 0) {
2674                                 if (trunc) {
2675                                         setAttr.mask = CM_ATTRMASK_LENGTH;
2676                                         setAttr.length.LowPart = 0;
2677                                         setAttr.length.HighPart = 0;
2678                                         code = cm_SetAttr(scp, &setAttr, userp,
2679                                                           &req);
2680                                 }
2681                         }       /* lookup succeeded */
2682                 }
2683         }
2684         
2685         /* we don't need this any longer */
2686         if (dscp) cm_ReleaseSCache(dscp);
2687
2688         if (code) {
2689                 /* something went wrong creating or truncating the file */
2690                 if (scp) cm_ReleaseSCache(scp);
2691                 cm_ReleaseUser(userp);
2692                 return code;
2693         }
2694         
2695         /* make sure we're about to open a file */
2696         if (scp->fileType != CM_SCACHETYPE_FILE) {
2697                 cm_ReleaseSCache(scp);
2698                 cm_ReleaseUser(userp);
2699                 return CM_ERROR_ISDIR;
2700         }
2701
2702         /* now all we have to do is open the file itself */
2703         fidp = smb_FindFID(vcp, 0, SMB_FLAG_CREATE);
2704         osi_assert(fidp);
2705         
2706         /* save a pointer to the vnode */
2707         fidp->scp = scp;
2708         
2709         /* compute open mode */
2710         if (openMode != 1) fidp->flags |= SMB_FID_OPENREAD;
2711         if (openMode == 1 || openMode == 2)
2712                 fidp->flags |= SMB_FID_OPENWRITE;
2713
2714         smb_ReleaseFID(fidp);
2715         
2716         cm_Open(scp, 0, userp);
2717
2718         /* set inp->fid so that later read calls in same msg can find fid */
2719         inp->fid = fidp->fid;
2720         
2721         /* copy out remainder of the parms */
2722         parmSlot = 2;
2723         smb_SetSMBParm(outp, parmSlot, fidp->fid); parmSlot++;
2724         lock_ObtainMutex(&scp->mx);
2725         if (extraInfo) {
2726                 smb_SetSMBParm(outp, parmSlot, smb_Attributes(scp)); parmSlot++;
2727                 smb_DosUTimeFromUnixTime(&dosTime, scp->clientModTime);
2728                 smb_SetSMBParm(outp, parmSlot, dosTime & 0xffff); parmSlot++;
2729                 smb_SetSMBParm(outp, parmSlot, (dosTime>>16) & 0xffff); parmSlot++;
2730                 smb_SetSMBParm(outp, parmSlot, scp->length.LowPart & 0xffff); parmSlot++;
2731                 smb_SetSMBParm(outp, parmSlot, (scp->length.LowPart >> 16) & 0xffff); parmSlot++;
2732                 smb_SetSMBParm(outp, parmSlot, openMode); parmSlot++;
2733                 smb_SetSMBParm(outp, parmSlot, 0); parmSlot++; /* file type 0 ==> normal file or dir */
2734                 smb_SetSMBParm(outp, parmSlot, 0); parmSlot++; /* IPC junk */
2735         }
2736         /* and the final "always present" stuff */
2737         smb_SetSMBParm(outp, parmSlot, openAction); parmSlot++;
2738         /* next write out the "unique" ID */
2739         smb_SetSMBParm(outp, parmSlot, scp->fid.vnode & 0xffff); parmSlot++;
2740         smb_SetSMBParm(outp, parmSlot, scp->fid.volume & 0xffff); parmSlot++;
2741         smb_SetSMBParm(outp, parmSlot, 0); parmSlot++;
2742         lock_ReleaseMutex(&scp->mx);
2743         smb_SetSMBDataLength(outp, 0);
2744
2745         osi_Log1(afsd_logp, "SMB OpenX opening fid %d", fidp->fid);
2746
2747         cm_ReleaseUser(userp);
2748         /* leave scp held since we put it in fidp->scp */
2749         return 0;
2750 }
2751
2752 long smb_ReceiveV3LockingX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
2753 {
2754         cm_req_t req;
2755         cm_user_t *userp;
2756         unsigned short fid;
2757         smb_fid_t *fidp;
2758         cm_scache_t *scp;
2759         unsigned char LockType;
2760         unsigned short NumberOfUnlocks, NumberOfLocks;
2761         unsigned long Timeout;
2762         char *op;
2763         LARGE_INTEGER LOffset, LLength;
2764         smb_waitingLock_t *waitingLock;
2765         void *lockp;
2766         long code;
2767         int i;
2768
2769         cm_InitReq(&req);
2770
2771         fid = smb_GetSMBParm(inp, 2);
2772         fid = smb_ChainFID(fid, inp);
2773
2774         fidp = smb_FindFID(vcp, fid, 0);
2775         if (!fidp || (fidp->flags & SMB_FID_IOCTL)) {
2776                 return CM_ERROR_BADFD;
2777         }
2778         /* set inp->fid so that later read calls in same msg can find fid */
2779         inp->fid = fid;
2780
2781         userp = smb_GetUser(vcp, inp);
2782
2783         scp = fidp->scp;
2784
2785         lock_ObtainMutex(&scp->mx);
2786         code = cm_SyncOp(scp, NULL, userp, &req, 0,
2787                          CM_SCACHESYNC_NEEDCALLBACK
2788                          | CM_SCACHESYNC_GETSTATUS
2789                          | CM_SCACHESYNC_LOCK);
2790         if (code) goto doneSync;
2791
2792         LockType = smb_GetSMBParm(inp, 3) & 0xff;
2793         Timeout = (smb_GetSMBParm(inp, 5) << 16) + smb_GetSMBParm(inp, 4);
2794         NumberOfUnlocks = smb_GetSMBParm(inp, 6);
2795         NumberOfLocks = smb_GetSMBParm(inp, 7);
2796
2797         op = smb_GetSMBData(inp, NULL);
2798
2799         for (i=0; i<NumberOfUnlocks; i++) {
2800                 if (LockType & 0x10) {
2801                         /* Large Files */
2802                         LOffset.HighPart = *((LONG *)(op + 4));
2803                         LOffset.LowPart = *((DWORD *)(op + 8));
2804                         LLength.HighPart = *((LONG *)(op + 12));
2805                         LLength.LowPart = *((DWORD *)(op + 16));
2806                         op += 20;
2807                 }
2808                 else {
2809                         /* Not Large Files */
2810                         LOffset.HighPart = 0;
2811                         LOffset.LowPart = *((DWORD *)(op + 2));
2812                         LLength.HighPart = 0;
2813                         LLength.LowPart = *((DWORD *)(op + 6));
2814                         op += 10;
2815                 }
2816                 if (LargeIntegerNotEqualToZero(LOffset))
2817                         continue;
2818                 /* Do not check length -- length check done in cm_Unlock */
2819
2820                 code = cm_Unlock(scp, LockType, LOffset, LLength, userp, &req);
2821                 if (code) goto done;
2822         }
2823
2824         for (i=0; i<NumberOfLocks; i++) {
2825                 if (LockType & 0x10) {
2826                         /* Large Files */
2827                         LOffset.HighPart = *((LONG *)(op + 4));
2828                         LOffset.LowPart = *((DWORD *)(op + 8));
2829                         LLength.HighPart = *((LONG *)(op + 12));
2830                         LLength.LowPart = *((DWORD *)(op + 16));
2831                         op += 20;
2832                 }
2833                 else {
2834                         /* Not Large Files */
2835                         LOffset.HighPart = 0;
2836                         LOffset.LowPart = *((DWORD *)(op + 2));
2837                         LLength.HighPart = 0;
2838                         LLength.LowPart = *((DWORD *)(op + 6));
2839                         op += 10;
2840                 }
2841                 if (LargeIntegerNotEqualToZero(LOffset))
2842                         continue;
2843                 if (LargeIntegerLessThan(LOffset, scp->length))
2844                         continue;
2845
2846                 code = cm_Lock(scp, LockType, LOffset, LLength, Timeout,
2847                                 userp, &req, &lockp);
2848                 if (code == CM_ERROR_WOULDBLOCK && Timeout != 0) {
2849                         /* Put on waiting list */
2850                         waitingLock = malloc(sizeof(smb_waitingLock_t));
2851                         waitingLock->vcp = vcp;
2852                         waitingLock->inp = smb_CopyPacket(inp);
2853                         waitingLock->outp = smb_CopyPacket(outp);
2854                         waitingLock->timeRemaining = Timeout;
2855                         waitingLock->lockp = lockp;
2856                         lock_ObtainWrite(&smb_globalLock);
2857                         osi_QAdd((osi_queue_t **)&smb_allWaitingLocks,
2858                                  &waitingLock->q);
2859                         osi_Wakeup((long) &smb_allWaitingLocks);
2860                         lock_ReleaseWrite(&smb_globalLock);
2861                         /* don't send reply immediately */
2862                         outp->flags |= SMB_PACKETFLAG_NOSEND;
2863                 }
2864                 if (code) break;
2865         }
2866
2867         if (code) {
2868                 /* release any locks acquired before the failure */
2869         }
2870         else
2871                 smb_SetSMBDataLength(outp, 0);
2872 done:
2873         cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_LOCK);
2874 doneSync:
2875         lock_ReleaseMutex(&scp->mx);
2876         cm_ReleaseUser(userp);
2877         smb_ReleaseFID(fidp);
2878
2879         return code;
2880 }
2881
2882 long smb_ReceiveV3GetAttributes(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
2883 {
2884         unsigned short fid;
2885         smb_fid_t *fidp;
2886         cm_scache_t *scp;
2887         long code;
2888         long searchTime;
2889         cm_user_t *userp;
2890         cm_req_t req;
2891
2892         cm_InitReq(&req);
2893
2894         fid = smb_GetSMBParm(inp, 0);
2895         fid = smb_ChainFID(fid, inp);
2896         
2897         fidp = smb_FindFID(vcp, fid, 0);
2898         if (!fidp || (fidp->flags & SMB_FID_IOCTL)) {
2899                 return CM_ERROR_BADFD;
2900         }
2901         
2902         userp = smb_GetUser(vcp, inp);
2903         
2904         scp = fidp->scp;
2905         
2906         /* otherwise, stat the file */
2907         lock_ObtainMutex(&scp->mx);
2908         code = cm_SyncOp(scp, NULL, userp, &req, 0,
2909                 CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
2910         if (code) goto done;
2911
2912         /* decode times.  We need a search time, but the response to this
2913          * call provides the date first, not the time, as returned in the
2914          * searchTime variable.  So we take the high-order bits first.
2915          */
2916         smb_SearchTimeFromUnixTime(&searchTime, scp->clientModTime);
2917         smb_SetSMBParm(outp, 0, (searchTime >> 16) & 0xffff);   /* ctime */
2918         smb_SetSMBParm(outp, 1, searchTime & 0xffff);
2919         smb_SetSMBParm(outp, 2, (searchTime >> 16) & 0xffff);   /* atime */
2920         smb_SetSMBParm(outp, 3, searchTime & 0xffff);
2921         smb_SetSMBParm(outp, 4, (searchTime >> 16) & 0xffff);   /* mtime */
2922         smb_SetSMBParm(outp, 5, searchTime & 0xffff);
2923         
2924         /* now handle file size and allocation size */
2925         smb_SetSMBParm(outp, 6, scp->length.LowPart & 0xffff);          /* file size */
2926         smb_SetSMBParm(outp, 7, (scp->length.LowPart >> 16) & 0xffff);
2927         smb_SetSMBParm(outp, 8, scp->length.LowPart & 0xffff);          /* alloc size */
2928         smb_SetSMBParm(outp, 9, (scp->length.LowPart >> 16) & 0xffff);
2929         
2930         /* file attribute */
2931         smb_SetSMBParm(outp, 10, smb_Attributes(scp));
2932         
2933         /* and finalize stuff */
2934         smb_SetSMBDataLength(outp, 0);
2935         code = 0;
2936
2937 done:
2938         lock_ReleaseMutex(&scp->mx);
2939         cm_ReleaseUser(userp);
2940         smb_ReleaseFID(fidp);
2941         return code;
2942 }
2943
2944 long smb_ReceiveV3SetAttributes(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
2945 {
2946         unsigned short fid;
2947         smb_fid_t *fidp;
2948         cm_scache_t *scp;
2949         long code;
2950         long searchTime;
2951         long unixTime;
2952         cm_user_t *userp;
2953         cm_attr_t attrs;
2954         cm_req_t req;
2955
2956         cm_InitReq(&req);
2957
2958         fid = smb_GetSMBParm(inp, 0);
2959         fid = smb_ChainFID(fid, inp);
2960         
2961         fidp = smb_FindFID(vcp, fid, 0);
2962         if (!fidp || (fidp->flags & SMB_FID_IOCTL)) {
2963                 return CM_ERROR_BADFD;
2964         }
2965         
2966         userp = smb_GetUser(vcp, inp);
2967         
2968         scp = fidp->scp;
2969         
2970         /* now prepare to call cm_setattr.  This message only sets various times,
2971          * and AFS only implements mtime, and we'll set the mtime if that's
2972          * requested.  The others we'll ignore.
2973          */
2974         searchTime = smb_GetSMBParm(inp, 5) | (smb_GetSMBParm(inp, 6) << 16);
2975         
2976         if (searchTime != 0) {
2977                 smb_UnixTimeFromSearchTime(&unixTime, searchTime);
2978
2979             if ( unixTime != -1 ) {
2980                 attrs.mask = CM_ATTRMASK_CLIENTMODTIME;
2981                 attrs.clientModTime = unixTime;
2982                 code = cm_SetAttr(scp, &attrs, userp, &req);
2983
2984                 osi_Log1(afsd_logp, "SMB receive V3SetAttributes [fid=%ld]", fid);
2985             } else {
2986                 osi_Log1(afsd_logp, "**smb_UnixTimeFromSearchTime failed searchTime=%ld", searchTime);
2987             }
2988         }
2989         else code = 0;
2990
2991         cm_ReleaseUser(userp);
2992         smb_ReleaseFID(fidp);
2993         return code;
2994 }
2995
2996
2997 long smb_ReceiveV3ReadX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
2998 {
2999         osi_hyper_t offset;
3000         long count, finalCount;
3001         unsigned short fd;
3002         smb_fid_t *fidp;
3003         long code;
3004         cm_user_t *userp;
3005         char *op;
3006         
3007         fd = smb_GetSMBParm(inp, 2);
3008         count = smb_GetSMBParm(inp, 5);
3009         offset.HighPart = 0;    /* too bad */
3010         offset.LowPart = smb_GetSMBParm(inp, 3) | (smb_GetSMBParm(inp, 4) << 16);
3011         
3012         osi_Log3(afsd_logp, "smb_ReceiveV3Read fd %d, off 0x%x, size 0x%x",
3013                 fd, offset.LowPart, count);
3014         
3015         fd = smb_ChainFID(fd, inp);
3016         fidp = smb_FindFID(vcp, fd, 0);
3017         if (!fidp) {
3018                 return CM_ERROR_BADFD;
3019         }
3020         /* set inp->fid so that later read calls in same msg can find fid */
3021         inp->fid = fd;
3022
3023         if (fidp->flags & SMB_FID_IOCTL) {
3024                 return smb_IoctlV3Read(fidp, vcp, inp, outp);
3025         }
3026         
3027         userp = smb_GetUser(vcp, inp);
3028
3029         /* 0 and 1 are reserved for request chaining, were setup by our caller,
3030          * and will be further filled in after we return.
3031          */
3032         smb_SetSMBParm(outp, 2, 0);     /* remaining bytes, for pipes */
3033         smb_SetSMBParm(outp, 3, 0);     /* resvd */
3034         smb_SetSMBParm(outp, 4, 0);     /* resvd */
3035         smb_SetSMBParm(outp, 5, count); /* # of bytes we're going to read */
3036         /* fill in #6 when we have all the parameters' space reserved */
3037         smb_SetSMBParm(outp, 7, 0);     /* resv'd */
3038         smb_SetSMBParm(outp, 8, 0);     /* resv'd */
3039         smb_SetSMBParm(outp, 9, 0);     /* resv'd */
3040         smb_SetSMBParm(outp, 10, 0);    /* resv'd */
3041         smb_SetSMBParm(outp, 11, 0);    /* reserved */
3042
3043         /* get op ptr after putting in the parms, since otherwise we don't
3044          * know where the data really is.
3045          */
3046         op = smb_GetSMBData(outp, NULL);
3047         
3048         /* now fill in offset from start of SMB header to first data byte (to op) */
3049         smb_SetSMBParm(outp, 6, ((int) (op - outp->data)));
3050
3051         /* set the packet data length the count of the # of bytes */
3052         smb_SetSMBDataLength(outp, count);
3053
3054 #ifndef DJGPP
3055         code = smb_ReadData(fidp, &offset, count, op, userp, &finalCount);
3056 #else /* DJGPP */
3057         code = smb_ReadData(fidp, &offset, count, op, userp, &finalCount, FALSE);
3058 #endif /* !DJGPP */
3059
3060         /* fix some things up */
3061         smb_SetSMBParm(outp, 5, finalCount);
3062         smb_SetSMBDataLength(outp, finalCount);
3063
3064         smb_ReleaseFID(fidp);
3065
3066         cm_ReleaseUser(userp);
3067         return code;
3068 }
3069         
3070 /*
3071  * Values for createDisp, copied from NTDDK.H
3072  *
3073  *  FILE_SUPERSEDE      0       (???)
3074  *  FILE_OPEN           1       (open)
3075  *  FILE_CREATE         2       (exclusive)
3076  *  FILE_OPEN_IF        3       (non-exclusive)
3077  *  FILE_OVERWRITE      4       (open & truncate, but do not create)
3078  *  FILE_OVERWRITE_IF   5       (open & truncate, or create)
3079  */
3080
3081 long smb_ReceiveNTCreateX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
3082 {
3083         char *pathp, *realPathp;
3084         long code;
3085         cm_space_t *spacep;
3086         cm_user_t *userp;
3087         cm_scache_t *dscp;              /* parent dir */
3088         cm_scache_t *scp;               /* file to create or open */
3089         cm_attr_t setAttr;
3090         char *lastNamep;
3091     char *treeStartp;
3092         unsigned short nameLength;
3093         unsigned int flags;
3094         unsigned int requestOpLock;
3095         unsigned int requestBatchOpLock;
3096         unsigned int mustBeDir;
3097     unsigned int treeCreate;
3098         int realDirFlag;
3099         unsigned int desiredAccess;
3100         unsigned int extAttributes;
3101         unsigned int createDisp;
3102         unsigned int createOptions;
3103         int initialModeBits;
3104         unsigned short baseFid;
3105         smb_fid_t *baseFidp;
3106         smb_fid_t *fidp;
3107         cm_scache_t *baseDirp;
3108         unsigned short openAction;
3109         int parmSlot;
3110         long fidflags;
3111         FILETIME ft;
3112         LARGE_INTEGER sz;
3113         char *tidPathp;
3114         BOOL foundscp;
3115         cm_req_t req;
3116
3117         cm_InitReq(&req);
3118
3119     treeCreate = FALSE;
3120         foundscp = FALSE;
3121         scp = NULL;
3122
3123         nameLength = smb_GetSMBOffsetParm(inp, 2, 1);
3124         flags = smb_GetSMBOffsetParm(inp, 3, 1)
3125                   | (smb_GetSMBOffsetParm(inp, 4, 1) << 16);
3126         requestOpLock = flags & 0x02;
3127         requestBatchOpLock = flags & 0x04;
3128         mustBeDir = flags & 0x08;
3129
3130         /*
3131          * Why all of a sudden 32-bit FID?
3132          * We will reject all bits higher than 16.
3133          */
3134         if (smb_GetSMBOffsetParm(inp, 6, 1) != 0)
3135                 return CM_ERROR_INVAL;
3136         baseFid = smb_GetSMBOffsetParm(inp, 5, 1);
3137         desiredAccess = smb_GetSMBOffsetParm(inp, 7, 1)
3138                           | (smb_GetSMBOffsetParm(inp, 8, 1) << 16);
3139         extAttributes = smb_GetSMBOffsetParm(inp, 13, 1)
3140                           | (smb_GetSMBOffsetParm(inp, 14, 1) << 16);
3141         createDisp = smb_GetSMBOffsetParm(inp, 17, 1)
3142                         | (smb_GetSMBOffsetParm(inp, 18, 1) << 16);
3143         createOptions = smb_GetSMBOffsetParm(inp, 19, 1)
3144                           | (smb_GetSMBOffsetParm(inp, 20, 1) << 16);
3145
3146         /* mustBeDir is never set; createOptions directory bit seems to be
3147          * more important
3148          */
3149         if (createOptions & 1)
3150                 realDirFlag = 1;
3151         else if (createOptions & 0x40)
3152                 realDirFlag = 0;
3153         else
3154                 realDirFlag = -1;
3155
3156         /*
3157          * compute initial mode bits based on read-only flag in
3158          * extended attributes
3159          */
3160         initialModeBits = 0666;
3161         if (extAttributes & 1) initialModeBits &= ~0222;
3162
3163         pathp = smb_GetSMBData(inp, NULL);
3164         /* Sometimes path is not null-terminated, so we make a copy. */
3165         realPathp = malloc(nameLength+1);
3166         memcpy(realPathp, pathp, nameLength);
3167         realPathp[nameLength] = 0;
3168
3169         spacep = inp->spacep;
3170         smb_StripLastComponent(spacep->data, &lastNamep, realPathp);
3171
3172     osi_Log1(afsd_logp,"NTCreateX for [%s]",osi_LogSaveString(afsd_logp,realPathp));
3173     osi_Log4(afsd_logp,"NTCreateX da=[%x] ea=[%x] cd=[%x] co=[%x]", desiredAccess, extAttributes, createDisp, createOptions);
3174
3175         if (lastNamep && strcmp(lastNamep, SMB_IOCTL_FILENAME) == 0) {
3176                 /* special case magic file name for receiving IOCTL requests
3177                  * (since IOCTL calls themselves aren't getting through).
3178                  */
3179                 fidp = smb_FindFID(vcp, 0, SMB_FLAG_CREATE);
3180                 smb_SetupIoctlFid(fidp, spacep);
3181
3182                 /* set inp->fid so that later read calls in same msg can find fid */
3183                 inp->fid = fidp->fid;
3184
3185                 /* out parms */
3186                 parmSlot = 2;
3187                 smb_SetSMBParmByte(outp, parmSlot, 0);  /* oplock */
3188                 smb_SetSMBParm(outp, parmSlot, fidp->fid); parmSlot++;
3189                 smb_SetSMBParmLong(outp, parmSlot, 1); parmSlot += 2; /* Action */
3190                 /* times */
3191                 memset(&ft, 0, sizeof(ft));
3192                 smb_SetSMBParmDouble(outp, parmSlot, (char *)&ft); parmSlot += 4;
3193                 smb_SetSMBParmDouble(outp, parmSlot, (char *)&ft); parmSlot += 4;
3194                 smb_SetSMBParmDouble(outp, parmSlot, (char *)&ft); parmSlot += 4;
3195                 smb_SetSMBParmDouble(outp, parmSlot, (char *)&ft); parmSlot += 4;
3196                 smb_SetSMBParmLong(outp, parmSlot, 0); parmSlot += 2; /* attr */
3197                 sz.HighPart = 0x7fff; sz.LowPart = 0;
3198                 smb_SetSMBParmDouble(outp, parmSlot, (char *)&sz); parmSlot += 4; /* alen */
3199                 smb_SetSMBParmDouble(outp, parmSlot, (char *)&sz); parmSlot += 4; /* len */
3200                 smb_SetSMBParm(outp, parmSlot, 0); parmSlot++;  /* filetype */
3201                 smb_SetSMBParm(outp, parmSlot, 0); parmSlot++;  /* dev state */
3202                 smb_SetSMBParmByte(outp, parmSlot, 0);  /* is a dir? */
3203                 smb_SetSMBDataLength(outp, 0);
3204
3205                 /* clean up fid reference */
3206                 smb_ReleaseFID(fidp);
3207                 free(realPathp);
3208                 return 0;
3209         }
3210
3211 #ifdef DEBUG_VERBOSE
3212     {
3213         char *hexp, *asciip;