smb-extended-20040724
[openafs.git] / src / WINNT / afsd / smb.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 //#define NOSERVICE 1
11
12 #include <afs/param.h>
13 #include <afs/stds.h>
14
15 #ifndef DJGPP
16 #include <windows.h>
17 #else
18 #include <sys/timeb.h>
19 #include <tzfile.h>
20 #endif /* !DJGPP */
21 #include <stddef.h>
22 #include <stdlib.h>
23 #include <malloc.h>
24 #include <string.h>
25 #include <stdio.h>
26 #include <time.h>
27
28 #include <osi.h>
29 #include <ntstatus.h>
30
31 #include "afsd.h"
32
33 #include "smb.h"
34 #include "lanahelper.h"
35
36 /* These characters are illegal in Windows filenames */
37 static char *illegalChars = "\\/:*?\"<>|";
38 BOOL isWindows2000 = FALSE;
39
40 smb_vc_t *dead_vcp = NULL;
41 smb_vc_t *active_vcp = NULL;
42
43 /* TODO; logout mechanism needs to be thread-safe */
44 char *loggedOutName = NULL;
45 smb_user_t *loggedOutUserp = NULL;
46 unsigned long loggedOutTime;
47 int loggedOut = 0;
48 int smbShutdownFlag = 0;
49
50 int smb_LogoffTokenTransfer;
51 unsigned long smb_LogoffTransferTimeout;
52
53 DWORD last_msg_time = 0;
54
55 long ongoingOps = 0;
56
57 unsigned int sessionGen = 0;
58
59 extern void afsi_log(char *pattern, ...);
60 extern HANDLE afsi_file;
61
62 osi_hyper_t hzero = {0, 0};
63 osi_hyper_t hones = {0xFFFFFFFF, -1};
64
65 osi_log_t *  smb_logp;
66 osi_rwlock_t smb_globalLock;
67 osi_rwlock_t smb_rctLock;
68 osi_mutex_t  smb_ListenerLock;
69  
70 char smb_LANadapter;
71 unsigned char smb_sharename[NCBNAMSZ+1] = {0};
72
73 /* for debugging */
74 long smb_maxObsConcurrentCalls=0;
75 long smb_concurrentCalls=0;
76
77 smb_dispatch_t smb_dispatchTable[SMB_NOPCODES];
78
79 smb_packet_t *smb_packetFreeListp;
80 smb_ncb_t *smb_ncbFreeListp;
81
82 int smb_NumServerThreads;
83
84 int numNCBs, numSessions, numVCs;
85
86 int smb_maxVCPerServer;
87 int smb_maxMpxRequests;
88
89 int smb_authType = SMB_AUTH_EXTENDED; /* type of SMB auth to use. One of SMB_AUTH_* */
90 HANDLE smb_lsaHandle;
91 ULONG smb_lsaSecPackage;
92 LSA_STRING smb_lsaLogonOrigin;
93
94 #define NCBmax MAXIMUM_WAIT_OBJECTS
95 EVENT_HANDLE NCBavails[NCBmax], NCBevents[NCBmax];
96 EVENT_HANDLE **NCBreturns;
97 DWORD NCBsessions[NCBmax];
98 NCB *NCBs[NCBmax];
99 struct smb_packet *bufs[NCBmax];
100
101 #define Sessionmax MAXIMUM_WAIT_OBJECTS
102 EVENT_HANDLE SessionEvents[Sessionmax];
103 unsigned short LSNs[Sessionmax];
104 int lanas[Sessionmax];
105 BOOL dead_sessions[Sessionmax];
106 LANA_ENUM lana_list;
107
108 /* for raw I/O */
109 osi_mutex_t smb_RawBufLock;
110 #ifdef DJGPP
111 #define SMB_RAW_BUFS 4
112 dos_ptr smb_RawBufs;
113 int smb_RawBufSel[SMB_RAW_BUFS];
114 #else
115 char *smb_RawBufs;
116 #endif /* DJGPP */
117
118 #define SMB_MASKFLAG_TILDE 1
119 #define SMB_MASKFLAG_CASEFOLD 2
120
121 #define RAWTIMEOUT INFINITE
122
123 /* for raw write */
124 typedef struct raw_write_cont {
125         long code;
126         osi_hyper_t offset;
127         long count;
128 #ifndef DJGPP
129         char *buf;
130 #else
131         dos_ptr buf;
132 #endif /* DJGPP */
133         int writeMode;
134         long alreadyWritten;
135 } raw_write_cont_t;
136
137 /* dir search stuff */
138 long smb_dirSearchCounter = 1;
139 smb_dirSearch_t *smb_firstDirSearchp;
140 smb_dirSearch_t *smb_lastDirSearchp;
141
142 /* hide dot files? */
143 int smb_hideDotFiles;
144
145 /* global state about V3 protocols */
146 int smb_useV3;          /* try to negotiate V3 */
147
148 #ifndef DJGPP
149 static showErrors = 1;
150 /* MessageBox or something like it */
151 int (_stdcall *smb_MBfunc)(HWND, LPCTSTR, LPCTSTR, UINT) = NULL;
152 extern HANDLE WaitToTerminate;
153 #endif /* DJGPP */
154
155 /* GMT time info:
156  * Time in Unix format of midnight, 1/1/1970 local time.
157  * When added to dosUTime, gives Unix (AFS) time.
158  */
159 long smb_localZero;
160
161 /* Time difference for converting to kludge-GMT */
162 int smb_NowTZ;
163
164 char *smb_localNamep = NULL;
165
166 smb_vc_t *smb_allVCsp;
167
168 smb_username_t *usernamesp = NULL;
169
170 smb_waitingLock_t *smb_allWaitingLocks;
171
172 /* forward decl */
173 void smb_DispatchPacket(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp,
174                                                 NCB *ncbp, raw_write_cont_t *rwcp);
175 void smb_NetbiosInit();
176 #ifdef DJGPP
177 #ifndef AFS_WIN95_ENV
178 DWORD smb_ServerExceptionFilter(void);
179 #endif
180
181 extern char cm_HostName[];
182 extern char cm_confDir[];
183 #endif
184
185 #ifdef DJGPP
186 #define LPTSTR char *
187 #define GetComputerName(str, sizep) \
188        strcpy((str), cm_HostName); \
189        *(sizep) = strlen(cm_HostName)
190 #endif /* DJGPP */
191
192 extern char AFSConfigKeyName[];
193
194 char smb_ServerDomainName[MAX_COMPUTERNAME_LENGTH + 1] = ""; /* domain name */
195 int smb_ServerDomainNameLength = 0;
196 char smb_ServerOS[] = "Windows 5.0"; /* Faux OS String */
197 int smb_ServerOSLength = sizeof(smb_ServerOS);
198 char smb_ServerLanManager[] = "Windows 2000 LAN Manager"; /* Faux LAN Manager string */
199 int smb_ServerLanManagerLength = sizeof(smb_ServerLanManager);
200
201 /* Faux server GUID. This is never checked. */
202 GUID smb_ServerGUID = { 0x40015cb8, 0x058a, 0x44fc, { 0xae, 0x7e, 0xbb, 0x29, 0x52, 0xee, 0x7e, 0xff }};
203
204 /*
205  * Demo expiration
206  *
207  * To build an expiring version, comment out the definition of NOEXPIRE,
208  * and set the definition of EXPIREDATE to the desired value.
209  */
210 #define NOEXPIRE 1
211 #define EXPIREDATE 834000000            /* Wed Jun 5 1996 */
212
213
214 char * myCrt_Dispatch(int i)
215 {
216         switch (i)
217         {
218         default:
219                 return "unknown SMB op";
220         case 0x00:
221                 return "(00)ReceiveCoreMakeDir";
222         case 0x01:
223                 return "(01)ReceiveCoreRemoveDir";
224         case 0x02:
225                 return "(02)ReceiveCoreOpen";
226         case 0x03:
227                 return "(03)ReceiveCoreCreate";
228         case 0x04:
229                 return "(04)ReceiveCoreClose";
230         case 0x05:
231                 return "(05)ReceiveCoreFlush";
232         case 0x06:
233                 return "(06)ReceiveCoreUnlink";
234         case 0x07:
235                 return "(07)ReceiveCoreRename";
236         case 0x08:
237                 return "(08)ReceiveCoreGetFileAttributes";
238         case 0x09:
239                 return "(09)ReceiveCoreSetFileAttributes";
240         case 0x0a:
241                 return "(0a)ReceiveCoreRead";
242         case 0x0b:
243                 return "(0b)ReceiveCoreWrite";
244         case 0x0c:
245                 return "(0c)ReceiveCoreLockRecord";
246         case 0x0d:
247                 return "(0d)ReceiveCoreUnlockRecord";
248         case 0x0e:
249                 return "(0e)SendCoreBadOp";
250         case 0x0f:
251                 return "(0f)ReceiveCoreCreate";
252         case 0x10:
253                 return "(10)ReceiveCoreCheckPath";
254         case 0x11:
255                 return "(11)SendCoreBadOp";
256         case 0x12:
257                 return "(12)ReceiveCoreSeek";
258         case 0x1a:
259                 return "(1a)ReceiveCoreReadRaw";
260         case 0x1d:
261                 return "(1d)ReceiveCoreWriteRawDummy";
262         case 0x22:
263                 return "(22)ReceiveV3SetAttributes";
264         case 0x23:
265                 return "(23)ReceiveV3GetAttributes";
266         case 0x24:
267                 return "(24)ReceiveV3LockingX";
268         case 0x25:
269                 return "(25)ReceiveV3Trans";
270         case 0x26:
271                 return "(26)ReceiveV3Trans[aux]";
272         case 0x29:
273                 return "(29)SendCoreBadOp";
274         case 0x2b:
275                 return "(2b)ReceiveCoreEcho";
276         case 0x2d:
277                 return "(2d)ReceiveV3OpenX";
278         case 0x2e:
279                 return "(2e)ReceiveV3ReadX";
280         case 0x32:
281                 return "(32)ReceiveV3Tran2A";
282         case 0x33:
283                 return "(33)ReceiveV3Tran2A[aux]";
284         case 0x34:
285                 return "(34)ReceiveV3FindClose";
286         case 0x35:
287                 return "(35)ReceiveV3FindNotifyClose";
288         case 0x70:
289                 return "(70)ReceiveCoreTreeConnect";
290         case 0x71:
291                 return "(71)ReceiveCoreTreeDisconnect";
292         case 0x72:
293                 return "(72)ReceiveNegotiate";
294         case 0x73:
295                 return "(73)ReceiveV3SessionSetupX";
296         case 0x74:
297                 return "(74)ReceiveV3UserLogoffX";
298         case 0x75:
299                 return "(75)ReceiveV3TreeConnectX";
300         case 0x80:
301                 return "(80)ReceiveCoreGetDiskAttributes";
302         case 0x81:
303                 return "(81)ReceiveCoreSearchDir";
304         case 0xA0:
305                 return "(A0)ReceiveNTTransact";
306         case 0xA2:
307                 return "(A2)ReceiveNTCreateX";
308         case 0xA4:
309                 return "(A4)ReceiveNTCancel";
310         case 0xc0:
311                 return "(c0)SendCoreBadOp";
312         case 0xc1:
313                 return "(c1)SendCoreBadOp";
314         case 0xc2:
315                 return "(c2)SendCoreBadOp";
316         case 0xc3:
317                 return "(c3)SendCoreBadOp";
318         }
319 }
320
321 char * myCrt_2Dispatch(int i)
322 {
323         switch (i)
324         {
325         default:
326                 return "unknown SMB op-2";
327         case 0:
328                 return "S(00)CreateFile";
329         case 1:
330                 return "S(01)FindFirst";
331         case 2:
332                 return "S(02)FindNext"; /* FindNext */
333         case 3:
334                 return "S(03)QueryFileSystem_ReceiveTran2QFSInfo";
335         case 4:
336                 return "S(04)??";
337         case 5:
338                 return "S(05)QueryFileInfo_ReceiveTran2QPathInfo";
339         case 6:
340                 return "S(06)SetFileInfo_ReceiveTran2SetPathInfo";
341         case 7:
342                 return "S(07)SetInfoHandle_ReceiveTran2QFileInfo";
343         case 8:
344                 return "S(08)??_ReceiveTran2SetFileInfo";
345         case 9:
346                 return "S(09)??_ReceiveTran2FSCTL";
347         case 10:
348                 return "S(0a)_ReceiveTran2IOCTL";
349         case 11:
350                 return "S(0b)_ReceiveTran2FindNotifyFirst";
351         case 12:
352                 return "S(0c)_ReceiveTran2FindNotifyNext";
353         case 13:
354                 return "S(0d)CreateDirectory_ReceiveTran2MKDir";
355         }
356 }
357
358 char * myCrt_RapDispatch(int i)
359 {
360         switch(i)
361         {
362         default:
363                 return "unknown RAP OP";
364         case 0:
365                 return "RAP(0)NetShareEnum";
366         case 1:
367                 return "RAP(1)NetShareGetInfo";
368         case 13:
369                 return "RAP(13)NetServerGetInfo";
370         case 63:
371                 return "RAP(63)NetWkStaGetInfo";
372         }
373 }
374
375 /* scache must be locked */
376 unsigned int smb_Attributes(cm_scache_t *scp)
377 {
378         unsigned int attrs;
379
380         if (scp->fileType == CM_SCACHETYPE_DIRECTORY
381                 || scp->fileType == CM_SCACHETYPE_MOUNTPOINT)
382                 attrs = SMB_ATTR_DIRECTORY;
383         else
384                 attrs = 0;
385
386         /*
387          * We used to mark a file RO if it was in an RO volume, but that
388          * turns out to be impolitic in NT.  See defect 10007.
389          */
390 #ifdef notdef
391         if ((scp->unixModeBits & 0222) == 0 || (scp->flags & CM_SCACHEFLAG_RO))
392 #endif
393         if ((scp->unixModeBits & 0222) == 0)
394                 attrs |= SMB_ATTR_READONLY;     /* turn on read-only flag */
395
396         return attrs;
397 }
398
399 /* Check if the named file/dir is a dotfile/dotdir */
400 /* String pointed to by lastComp can have leading slashes, but otherwise should have
401    no other patch components */
402 unsigned int smb_IsDotFile(char *lastComp) {
403         char *s;
404         if(lastComp) {
405                 /* skip over slashes */
406         for(s=lastComp;*s && (*s == '\\' || *s == '/'); s++);
407         }
408         else
409                 return 0;
410
411     /* nulls, curdir and parent dir doesn't count */
412         if(!*s) return 0;
413         if(*s == '.') {
414                 if(!*(s + 1)) return 0;
415                 if(*(s+1) == '.' && !*(s + 2)) return 0;
416                 return 1;
417         }
418         return 0;
419 }
420
421 static int ExtractBits(WORD bits, short start, short len)
422 {
423         int end;
424         WORD num;
425
426         end = start + len;
427         
428         num = bits << (16 - end);
429         num = num >> ((16 - end) + start);
430
431         return (int)num;
432 }
433
434 #ifndef DJGPP
435 void ShowUnixTime(char *FuncName, long unixTime)
436 {
437         FILETIME ft;
438         WORD wDate, wTime;
439
440         smb_LargeSearchTimeFromUnixTime(&ft, unixTime);
441                 
442         if (!FileTimeToDosDateTime(&ft, &wDate, &wTime))
443                 osi_Log1(smb_logp, "Failed to convert filetime to dos datetime: %d", GetLastError());
444         else {
445                 int day, month, year, sec, min, hour;
446                 char msg[256];
447
448                 day = ExtractBits(wDate, 0, 5);
449                 month = ExtractBits(wDate, 5, 4);
450                 year = ExtractBits(wDate, 9, 7) + 1980;
451
452                 sec = ExtractBits(wTime, 0, 5);
453                 min = ExtractBits(wTime, 5, 6);
454                 hour = ExtractBits(wTime, 11, 5);
455
456                 sprintf(msg, "%s = %02d-%02d-%04d %02d:%02d:%02d", FuncName, month, day, year, hour, min, sec);
457                 osi_Log1(smb_logp, "%s", osi_LogSaveString(smb_logp, msg));
458         }
459 }
460 #endif /* DJGPP */
461
462 #ifndef DJGPP
463 /* Determine if we are observing daylight savings time */
464 void GetTimeZoneInfo(BOOL *pDST, LONG *pDstBias, LONG *pBias)
465 {
466         TIME_ZONE_INFORMATION timeZoneInformation;
467         SYSTEMTIME utc, local, localDST;
468
469         /* Get the time zone info. NT uses this to calc if we are in DST. */
470         GetTimeZoneInformation(&timeZoneInformation);
471  
472         /* Return the daylight bias */
473         *pDstBias = timeZoneInformation.DaylightBias;
474
475         /* Return the bias */
476         *pBias = timeZoneInformation.Bias;
477
478         /* Now determine if DST is being observed */
479
480         /* Get the UTC (GMT) time */
481         GetSystemTime(&utc);
482
483         /* Convert UTC time to local time using the time zone info.  If we are
484            observing DST, the calculated local time will include this. 
485         */
486         SystemTimeToTzSpecificLocalTime(&timeZoneInformation, &utc, &localDST);
487
488         /* Set the daylight bias to 0.  The daylight bias is the amount of change
489            in time that we use for daylight savings time.  By setting this to 0
490            we cause there to be no change in time during daylight savings time. 
491         */
492         timeZoneInformation.DaylightBias = 0;
493
494         /* Convert the utc time to local time again, but this time without any
495            adjustment for daylight savings time. 
496         */
497         SystemTimeToTzSpecificLocalTime(&timeZoneInformation, &utc, &local);
498
499         /* If the two times are different, then it means that the localDST that
500            we calculated includes the daylight bias, and therefore we are
501            observing daylight savings time.
502         */
503         *pDST = localDST.wHour != local.wHour;
504 }
505 #else
506 /* Determine if we are observing daylight savings time */
507 void GetTimeZoneInfo(BOOL *pDST, LONG *pDstBias, LONG *pBias)
508 {
509         struct timeb t;
510
511         ftime(&t);
512         *pDST = t.dstflag;
513         *pDstBias = -60;    /* where can this be different? */
514         *pBias = t.timezone;
515 }
516 #endif /* DJGPP */
517  
518
519 void CompensateForSmbClientLastWriteTimeBugs(long *pLastWriteTime)
520 {
521         BOOL dst;       /* Will be TRUE if observing DST */
522         LONG dstBias;   /* Offset from local time if observing DST */
523         LONG bias;      /* Offset from GMT for local time */
524
525         /*
526          * This function will adjust the last write time to compensate
527          * for two bugs in the smb client:
528          *
529          *    1) During Daylight Savings Time, the LastWriteTime is ahead
530          *       in time by the DaylightBias (ignoring the sign - the
531          *       DaylightBias is always stored as a negative number).  If
532          *       the DaylightBias is -60, then the LastWriteTime will be
533          *       ahead by 60 minutes.
534          *
535          *    2) If the local time zone is a positive offset from GMT, then
536          *       the LastWriteTime will be the correct local time plus the
537          *       Bias (ignoring the sign - a positive offset from GMT is
538          *       always stored as a negative Bias).  If the Bias is -120,
539          *       then the LastWriteTime will be ahead by 120 minutes.
540          *
541          *    These bugs can occur at the same time.
542          */
543
544         GetTimeZoneInfo(&dst, &dstBias, &bias);
545
546         /* First adjust for DST */
547         if (dst)
548                 *pLastWriteTime -= (-dstBias * 60);     /* Convert dstBias to seconds */
549
550         /* Now adjust for a positive offset from GMT (a negative bias). */
551         if (bias < 0)
552                 *pLastWriteTime -= (-bias * 60);        /* Convert bias to seconds */
553 }               
554
555 /*
556  * Calculate the difference (in seconds) between local time and GMT.
557  * This enables us to convert file times to kludge-GMT.
558  */
559 static void
560 smb_CalculateNowTZ()
561 {
562         time_t t;
563         struct tm gmt_tm, local_tm;
564         int days, hours, minutes, seconds;
565
566         t = time(NULL);
567         gmt_tm = *(gmtime(&t));
568         local_tm = *(localtime(&t));
569
570         days = local_tm.tm_yday - gmt_tm.tm_yday;
571         hours = 24 * days + local_tm.tm_hour - gmt_tm.tm_hour
572 #ifdef COMMENT
573         /* There is a problem with DST immediately after the time change
574          * which may continue to exist until the machine is rebooted
575          */
576         - (local_tm.tm_isdst ? 1 : 0)
577 #endif /* COMMENT */
578         ;
579         minutes = 60 * hours + local_tm.tm_min - gmt_tm.tm_min;
580         seconds = 60 * minutes + local_tm.tm_sec - gmt_tm.tm_sec;
581
582         smb_NowTZ = seconds;
583 }
584
585 #ifndef DJGPP
586 void smb_LargeSearchTimeFromUnixTime(FILETIME *largeTimep, long unixTime)
587 {
588         struct tm *ltp;
589         SYSTEMTIME stm;
590         struct tm localJunk;
591         long ersatz_unixTime;
592
593         /*
594          * Must use kludge-GMT instead of real GMT.
595          * kludge-GMT is computed by adding time zone difference to localtime.
596          *
597          * real GMT would be:
598          * ltp = gmtime(&unixTime);
599          */
600         ersatz_unixTime = unixTime - smb_NowTZ;
601         ltp = localtime(&ersatz_unixTime);
602
603         /* if we fail, make up something */
604         if (!ltp) {
605                 ltp = &localJunk;
606                 localJunk.tm_year = 89 - 20;
607                 localJunk.tm_mon = 4;
608                 localJunk.tm_mday = 12;
609                 localJunk.tm_hour = 0;
610                 localJunk.tm_min = 0;
611                 localJunk.tm_sec = 0;
612         }
613
614         stm.wYear = ltp->tm_year + 1900;
615         stm.wMonth = ltp->tm_mon + 1;
616         stm.wDayOfWeek = ltp->tm_wday;
617         stm.wDay = ltp->tm_mday;
618         stm.wHour = ltp->tm_hour;
619         stm.wMinute = ltp->tm_min;
620         stm.wSecond = ltp->tm_sec;
621         stm.wMilliseconds = 0;
622
623         SystemTimeToFileTime(&stm, largeTimep);
624 }
625 #else /* DJGPP */
626 void smb_LargeSearchTimeFromUnixTime(FILETIME *largeTimep, long unixTime)
627 {
628         /* unixTime: seconds since 1/1/1970 00:00:00 GMT */
629         /* FILETIME: 100ns intervals since 1/1/1601 00:00:00 ??? */
630         LARGE_INTEGER *ft = (LARGE_INTEGER *) largeTimep;
631         LARGE_INTEGER ut;
632         int leap_years = 89;   /* leap years betw 1/1/1601 and 1/1/1970 */
633
634         /* set ft to number of 100ns intervals betw 1/1/1601 and 1/1/1970 GMT */
635         *ft = ConvertLongToLargeInteger(((EPOCH_YEAR-1601) * 365 + leap_years)
636                                    * 24 * 60);
637         *ft = LargeIntegerMultiplyByLong(*ft, 60);
638         *ft = LargeIntegerMultiplyByLong(*ft, 10000000);
639
640         /* add unix time */
641         ut = ConvertLongToLargeInteger(unixTime);
642         ut = LargeIntegerMultiplyByLong(ut, 10000000);
643         *ft = LargeIntegerAdd(*ft, ut);
644 }
645 #endif /* !DJGPP */
646
647 #ifndef DJGPP
648 void smb_UnixTimeFromLargeSearchTime(long *unixTimep, FILETIME *largeTimep)
649 {
650         SYSTEMTIME stm;
651         struct tm lt;
652         long save_timezone;
653
654         FileTimeToSystemTime(largeTimep, &stm);
655
656         lt.tm_year = stm.wYear - 1900;
657         lt.tm_mon = stm.wMonth - 1;
658         lt.tm_wday = stm.wDayOfWeek;
659         lt.tm_mday = stm.wDay;
660         lt.tm_hour = stm.wHour;
661         lt.tm_min = stm.wMinute;
662         lt.tm_sec = stm.wSecond;
663         lt.tm_isdst = -1;
664
665         save_timezone = _timezone;
666         _timezone += smb_NowTZ;
667         *unixTimep = mktime(&lt);
668         _timezone = save_timezone;
669 }
670 #else /* DJGPP */
671 void smb_UnixTimeFromLargeSearchTime(long *unixTimep, FILETIME *largeTimep)
672 {
673         /* unixTime: seconds since 1/1/1970 00:00:00 GMT */
674         /* FILETIME: 100ns intervals since 1/1/1601 00:00:00 GMT? */
675         LARGE_INTEGER *ft = (LARGE_INTEGER *) largeTimep;
676         LARGE_INTEGER a;
677         int leap_years = 89;
678
679         /* set to number of 100ns intervals betw 1/1/1601 and 1/1/1970 */
680         a = ConvertLongToLargeInteger(((EPOCH_YEAR-1601) * 365 + leap_years) * 24 * 60);
681         a = LargeIntegerMultiplyByLong(a, 60);
682         a = LargeIntegerMultiplyByLong(a, 10000000);
683
684         /* subtract it from ft */
685         a = LargeIntegerSubtract(*ft, a);
686
687         /* divide down to seconds */
688         *unixTimep = LargeIntegerDivideByLong(a, 10000000);
689 }
690 #endif /* !DJGPP */
691
692 void smb_SearchTimeFromUnixTime(long *dosTimep, long unixTime)
693 {
694         struct tm *ltp;
695         int dosDate;
696         int dosTime;
697         struct tm localJunk;
698
699         ltp = localtime((time_t*) &unixTime);
700
701         /* if we fail, make up something */
702         if (!ltp) {
703                 ltp = &localJunk;
704                 localJunk.tm_year = 89 - 20;
705                 localJunk.tm_mon = 4;
706                 localJunk.tm_mday = 12;
707                 localJunk.tm_hour = 0;
708                 localJunk.tm_min = 0;
709                 localJunk.tm_sec = 0;
710         }       
711
712         dosDate = ((ltp->tm_year-80)<<9) | ((ltp->tm_mon+1) << 5) | (ltp->tm_mday);
713         dosTime = (ltp->tm_hour<<11) | (ltp->tm_min << 5) | (ltp->tm_sec / 2);
714         *dosTimep = (dosDate<<16) | dosTime;
715 }       
716
717 void smb_UnixTimeFromSearchTime(long *unixTimep, long searchTime)
718 {
719         unsigned short dosDate;
720         unsigned short dosTime;
721         struct tm localTm;
722         
723         dosDate = searchTime & 0xffff;
724         dosTime = (searchTime >> 16) & 0xffff;
725         
726         localTm.tm_year = 80 + ((dosDate>>9) & 0x3f);
727         localTm.tm_mon = ((dosDate >> 5) & 0xf) - 1;    /* January is 0 in localTm */
728         localTm.tm_mday = (dosDate) & 0x1f;
729         localTm.tm_hour = (dosTime>>11) & 0x1f;
730         localTm.tm_min = (dosTime >> 5) & 0x3f;
731         localTm.tm_sec = (dosTime & 0x1f) * 2;
732         localTm.tm_isdst = -1;                          /* compute whether DST in effect */
733
734         *unixTimep = mktime(&localTm);
735 }
736
737 void smb_DosUTimeFromUnixTime(long *dosUTimep, long unixTime)
738 {
739         *dosUTimep = unixTime - smb_localZero;
740 }
741
742 void smb_UnixTimeFromDosUTime(long *unixTimep, long dosTime)
743 {
744 #ifndef DJGPP
745         *unixTimep = dosTime + smb_localZero;
746 #else /* DJGPP */
747         /* dosTime seems to be already adjusted for GMT */
748         *unixTimep = dosTime;
749 #endif /* !DJGPP */
750 }
751
752 smb_vc_t *smb_FindVC(unsigned short lsn, int flags, int lana)
753 {
754         smb_vc_t *vcp;
755
756         lock_ObtainWrite(&smb_rctLock);
757         for(vcp = smb_allVCsp; vcp; vcp=vcp->nextp) {
758                 if (lsn == vcp->lsn && lana == vcp->lana) {
759                         vcp->refCount++;
760                         break;
761                 }
762         }
763         if (!vcp && (flags & SMB_FLAG_CREATE)) {
764                 vcp = malloc(sizeof(*vcp));
765                 memset(vcp, 0, sizeof(*vcp));
766         vcp->vcID = numVCs++;
767                 vcp->refCount = 1;
768                 vcp->tidCounter = 1;
769                 vcp->fidCounter = 1;
770                 vcp->uidCounter = 1;  /* UID 0 is reserved for blank user */
771                 vcp->nextp = smb_allVCsp;
772                 smb_allVCsp = vcp;
773                 lock_InitializeMutex(&vcp->mx, "vc_t mutex");
774                 vcp->lsn = lsn;
775                 vcp->lana = lana;
776         vcp->secCtx = NULL;
777
778                 if (smb_authType == SMB_AUTH_NTLM || smb_authType == SMB_AUTH_EXTENDED) {
779             /* We must obtain a challenge for extended auth 
780              * in case the client negotiates smb v3 
781              */
782             NTSTATUS nts,ntsEx;
783                         MSV1_0_LM20_CHALLENGE_REQUEST lsaReq;
784                         PMSV1_0_LM20_CHALLENGE_RESPONSE lsaResp;
785                         ULONG lsaRespSize;
786
787                         lsaReq.MessageType = MsV1_0Lm20ChallengeRequest;
788
789                         nts = LsaCallAuthenticationPackage( smb_lsaHandle,
790                                                 smb_lsaSecPackage,
791                                                 &lsaReq,
792                                                 sizeof(lsaReq),
793                                                 &lsaResp,
794                                                 &lsaRespSize,
795                                                 &ntsEx);
796                         osi_assert(nts == STATUS_SUCCESS); /* this had better work! */
797
798                         memcpy(vcp->encKey, lsaResp->ChallengeToClient, MSV1_0_CHALLENGE_LENGTH);
799             LsaFreeReturnBuffer(lsaResp);
800                 }
801                 else
802                         memset(vcp->encKey, 0, MSV1_0_CHALLENGE_LENGTH);
803         }
804         lock_ReleaseWrite(&smb_rctLock);
805         return vcp;
806 }
807
808 int smb_IsStarMask(char *maskp)
809 {
810         int i;
811         char tc;
812         
813         for(i=0; i<11; i++) {
814                 tc = *maskp++;
815                 if (tc == '?' || tc == '*' || tc == '>') return 1;        
816         }       
817         return 0;
818 }
819
820 void smb_ReleaseVC(smb_vc_t *vcp)
821 {
822         lock_ObtainWrite(&smb_rctLock);
823         osi_assert(vcp->refCount-- > 0);
824         lock_ReleaseWrite(&smb_rctLock);
825 }
826
827 void smb_HoldVC(smb_vc_t *vcp)
828 {
829         lock_ObtainWrite(&smb_rctLock);
830         vcp->refCount++;
831         lock_ReleaseWrite(&smb_rctLock);
832 }
833
834 smb_tid_t *smb_FindTID(smb_vc_t *vcp, unsigned short tid, int flags)
835 {
836         smb_tid_t *tidp;
837
838         lock_ObtainWrite(&smb_rctLock);
839         for(tidp = vcp->tidsp; tidp; tidp = tidp->nextp) {
840                 if (tid == tidp->tid) {
841                         tidp->refCount++;
842                         break;
843                 }       
844         }
845         if (!tidp && (flags & SMB_FLAG_CREATE)) {
846                 tidp = malloc(sizeof(*tidp));
847                 memset(tidp, 0, sizeof(*tidp));
848                 tidp->nextp = vcp->tidsp;
849                 tidp->refCount = 1;
850                 tidp->vcp = vcp;
851         vcp->refCount++;
852                 vcp->tidsp = tidp;
853                 lock_InitializeMutex(&tidp->mx, "tid_t mutex");
854                 tidp->tid = tid;
855         }
856         lock_ReleaseWrite(&smb_rctLock);
857         return tidp;
858 }       
859
860 void smb_ReleaseTID(smb_tid_t *tidp)
861 {
862         smb_tid_t *tp;
863         smb_tid_t **ltpp;
864         cm_user_t *userp;
865     smb_vc_t  *vcp;
866
867         userp = NULL;
868     vcp = NULL;
869         lock_ObtainWrite(&smb_rctLock);
870         osi_assert(tidp->refCount-- > 0);
871         if (tidp->refCount == 0 && (tidp->flags & SMB_TIDFLAG_DELETE)) {
872                 ltpp = &tidp->vcp->tidsp;
873                 for(tp = *ltpp; tp; ltpp = &tp->nextp, tp = *ltpp) {
874                         if (tp == tidp) break;
875                 }
876                 osi_assert(tp != NULL);
877                 *ltpp = tp->nextp;
878                 lock_FinalizeMutex(&tidp->mx);
879                 userp = tidp->userp;    /* remember to drop ref later */
880         vcp = tidp->vcp;
881         }
882         lock_ReleaseWrite(&smb_rctLock);
883         if (userp) {
884                 cm_ReleaseUser(userp);
885         }       
886     if (vcp) {
887         smb_ReleaseVC(vcp);
888     }
889 }       
890
891 smb_user_t *smb_FindUID(smb_vc_t *vcp, unsigned short uid, int flags)
892 {
893         smb_user_t *uidp = NULL;
894
895         lock_ObtainWrite(&smb_rctLock);
896         for(uidp = vcp->usersp; uidp; uidp = uidp->nextp) {
897                 if (uid == uidp->userID) {
898                         uidp->refCount++;
899                         osi_LogEvent("AFS smb_FindUID (Find by UID)",NULL," VCP[%x] found-uid[%d] name[%s]",(int)vcp,uidp->userID,(uidp->unp) ? uidp->unp->name : "");
900                 break;
901                 }
902         }
903         if (!uidp && (flags & SMB_FLAG_CREATE)) {
904                 uidp = malloc(sizeof(*uidp));
905                 memset(uidp, 0, sizeof(*uidp));
906                 uidp->nextp = vcp->usersp;
907                 uidp->refCount = 1;
908                 uidp->vcp = vcp;
909         vcp->refCount++;
910                 vcp->usersp = uidp;
911                 lock_InitializeMutex(&uidp->mx, "user_t mutex");
912                 uidp->userID = uid;
913                 osi_LogEvent("AFS smb_FindUID (Find by UID)",NULL,"VCP[%x] new-uid[%d] name[%s]",(int)vcp,uidp->userID,(uidp->unp ? uidp->unp->name : ""));
914         }
915         lock_ReleaseWrite(&smb_rctLock);
916         return uidp;
917 }       
918
919 smb_username_t *smb_FindUserByName(char *usern, char *machine, int flags)
920 {
921         smb_username_t *unp= NULL;
922
923         lock_ObtainWrite(&smb_rctLock);
924         for(unp = usernamesp; unp; unp = unp->nextp) {
925                 if (stricmp(unp->name, usern) == 0 &&
926                         stricmp(unp->machine, machine) == 0) {
927                         unp->refCount++;
928                         break;
929                 }
930         }
931         if (!unp && (flags & SMB_FLAG_CREATE)) {
932                 unp = malloc(sizeof(*unp));
933                 memset(unp, 0, sizeof(*unp));
934                 unp->refCount = 1;
935                 unp->nextp = usernamesp;
936                 unp->name = strdup(usern);
937                 unp->machine = strdup(machine);
938                 usernamesp = unp;
939                 lock_InitializeMutex(&unp->mx, "username_t mutex");
940         }
941         lock_ReleaseWrite(&smb_rctLock);
942         return unp;
943 }       
944
945 smb_user_t *smb_FindUserByNameThisSession(smb_vc_t *vcp, char *usern)
946 {
947         smb_user_t *uidp= NULL;
948
949         lock_ObtainWrite(&smb_rctLock);
950         for(uidp = vcp->usersp; uidp; uidp = uidp->nextp) {
951                 if (!uidp->unp) 
952             continue;
953                 if (stricmp(uidp->unp->name, usern) == 0) {
954             uidp->refCount++;
955                         osi_LogEvent("AFS smb_FindUserByNameThisSession",NULL,"VCP[%x] uid[%d] match-name[%s]",(int)vcp,uidp->userID,usern);
956             break;
957                 } else
958             continue;
959         }       
960         lock_ReleaseWrite(&smb_rctLock);
961         return uidp;
962 }
963 void smb_ReleaseUID(smb_user_t *uidp)
964 {
965         smb_user_t *up;
966         smb_user_t **lupp;
967         cm_user_t *userp;
968     smb_vc_t  *vcp;
969
970         userp = NULL;
971     vcp = NULL;
972         lock_ObtainWrite(&smb_rctLock);
973         osi_assert(uidp->refCount-- > 0);
974         if (uidp->refCount == 0 && (uidp->flags & SMB_USERFLAG_DELETE)) {
975                 lupp = &uidp->vcp->usersp;
976                 for(up = *lupp; up; lupp = &up->nextp, up = *lupp) {
977                         if (up == uidp) break;
978                 }
979                 osi_assert(up != NULL);
980                 *lupp = up->nextp;
981                 lock_FinalizeMutex(&uidp->mx);
982                 if (uidp->unp) {
983                         userp = uidp->unp->userp;       /* remember to drop ref later */
984             uidp->unp->userp = NULL;
985         }
986         vcp = uidp->vcp;
987         uidp->vcp = NULL;
988         }               
989         lock_ReleaseWrite(&smb_rctLock);
990         if (userp) {
991                 cm_ReleaseUserVCRef(userp);
992                 cm_ReleaseUser(userp);
993         }       
994     if (vcp) {
995         smb_ReleaseVC(vcp);
996     }
997 }       
998
999 /* retrieve a held reference to a user structure corresponding to an incoming
1000  * request.
1001  * corresponding release function is cm_ReleaseUser.
1002  */
1003 cm_user_t *smb_GetUser(smb_vc_t *vcp, smb_packet_t *inp)
1004 {
1005         smb_user_t *uidp;
1006         cm_user_t *up;
1007         smb_t *smbp;
1008
1009         smbp = (smb_t *) inp;
1010         uidp = smb_FindUID(vcp, smbp->uid, 0);
1011         if ((!uidp) ||  (!uidp->unp))
1012                 return NULL;
1013         
1014         lock_ObtainMutex(&uidp->mx);
1015         up = uidp->unp->userp;
1016         cm_HoldUser(up);
1017         lock_ReleaseMutex(&uidp->mx);
1018
1019         smb_ReleaseUID(uidp);
1020         
1021         return up;
1022 }
1023
1024 /*
1025  * Return a pointer to a pathname extracted from a TID structure.  The
1026  * TID structure is not held; assume it won't go away.
1027  */
1028 char *smb_GetTIDPath(smb_vc_t *vcp, unsigned short tid)
1029 {
1030         smb_tid_t *tidp;
1031         char *tpath;
1032
1033         tidp = smb_FindTID(vcp, tid, 0);
1034     if (!tidp) 
1035         return NULL;
1036         tpath = tidp->pathname;
1037         smb_ReleaseTID(tidp);
1038         return tpath;
1039 }
1040
1041 /* check to see if we have a chained fid, that is, a fid that comes from an
1042  * OpenAndX message that ran earlier in this packet.  In this case, the fid
1043  * field in a read, for example, request, isn't set, since the value is
1044  * supposed to be inherited from the openAndX call.
1045  */
1046 int smb_ChainFID(int fid, smb_packet_t *inp)
1047 {
1048         if (inp->fid == 0 || inp->inCount == 0) 
1049                 return fid;
1050         else 
1051                 return inp->fid;
1052 }
1053
1054 /* are we a priv'd user?  What does this mean on NT? */
1055 int smb_SUser(cm_user_t *userp)
1056 {
1057         return 1;
1058 }
1059
1060 /* find a file ID.  If we pass in 0 we select an used File ID.
1061  * If the SMB_FLAG_CREATE flag is set, we allocate a new  
1062  * smb_fid_t data structure if desired File ID cannot be found.
1063  */
1064 smb_fid_t *smb_FindFID(smb_vc_t *vcp, unsigned short fid, int flags)
1065 {
1066         smb_fid_t *fidp;
1067         int newFid = 0;
1068         
1069     if (fid == 0 && !(flags & SMB_FLAG_CREATE))
1070         return NULL;
1071
1072         lock_ObtainWrite(&smb_rctLock);
1073         /* figure out if we need to allocate a new file ID */
1074         if (fid == 0) {
1075                 newFid = 1;
1076                 fid = vcp->fidCounter;
1077         }
1078
1079 retry:
1080         for(fidp = vcp->fidsp; fidp; fidp = (smb_fid_t *) osi_QNext(&fidp->q)) {
1081                 if (fid == fidp->fid) {
1082                         if (newFid) {
1083                                 fid++;
1084                 if (fid == 0) 
1085                                         fid = 1;
1086                 goto retry;
1087             }
1088                         fidp->refCount++;
1089             break;
1090                 }
1091     }
1092     if (!fidp && (flags & SMB_FLAG_CREATE)) {
1093         char eventName[MAX_PATH];
1094         EVENT_HANDLE event;
1095         sprintf(eventName,"fid_t event vcp=%d fid=%d", vcp->vcID, fid);
1096         event = thrd_CreateEvent(NULL, FALSE, TRUE, eventName);
1097         if ( GetLastError() == ERROR_ALREADY_EXISTS ) {
1098             afsi_log("Event Object Already Exists: %s", eventName);
1099             thrd_CloseHandle(event);
1100             fid++;
1101             if (fid == 0)
1102                 fid = 1;
1103             goto retry;
1104         }
1105
1106                 fidp = malloc(sizeof(*fidp));
1107         memset(fidp, 0, sizeof(*fidp));
1108                 osi_QAdd((osi_queue_t **)&vcp->fidsp, &fidp->q);
1109         fidp->refCount = 1;
1110         fidp->vcp = vcp;
1111         vcp->refCount++;
1112         lock_InitializeMutex(&fidp->mx, "fid_t mutex");
1113         fidp->fid = fid;
1114                 fidp->curr_chunk = fidp->prev_chunk = -2;
1115                 fidp->raw_write_event = event;
1116         if (newFid) {
1117             vcp->fidCounter = fid+1;
1118             if (vcp->fidCounter == 0) 
1119                 vcp->fidCounter = 1;
1120         }
1121     }
1122     lock_ReleaseWrite(&smb_rctLock);
1123     return fidp;
1124 }
1125
1126 void smb_ReleaseFID(smb_fid_t *fidp)
1127 {
1128         cm_scache_t *scp;
1129     smb_vc_t *vcp = NULL;
1130     smb_ioctl_t *ioctlp;
1131
1132     if (!fidp)
1133         return;
1134
1135         scp = NULL;
1136         lock_ObtainWrite(&smb_rctLock);
1137         osi_assert(fidp->refCount-- > 0);
1138     if (fidp->refCount == 0 && (fidp->flags & SMB_FID_DELETE)) {
1139                 vcp = fidp->vcp;
1140                 if (!(fidp->flags & SMB_FID_IOCTL))
1141                         scp = fidp->scp;
1142                 osi_QRemove((osi_queue_t **) &vcp->fidsp, &fidp->q);
1143                 thrd_CloseHandle(fidp->raw_write_event);
1144
1145                 /* and see if there is ioctl stuff to free */
1146         ioctlp = fidp->ioctlp;
1147         if (ioctlp) {
1148                         if (ioctlp->prefix) cm_FreeSpace(ioctlp->prefix);
1149                         if (ioctlp->inAllocp) free(ioctlp->inAllocp);
1150                         if (ioctlp->outAllocp) free(ioctlp->outAllocp);
1151                         free(ioctlp);
1152         }
1153
1154         free(fidp);
1155
1156         /* do not call smb_ReleaseVC() because we already have the lock */
1157         vcp->refCount--;
1158     }
1159         lock_ReleaseWrite(&smb_rctLock);
1160
1161         /* now release the scache structure */
1162         if (scp) 
1163                 cm_ReleaseSCache(scp);
1164 }
1165
1166 /*
1167  * Case-insensitive search for one string in another;
1168  * used to find variable names in submount pathnames.
1169  */
1170 static char *smb_stristr(char *str1, char *str2)
1171 {
1172         char *cursor;
1173
1174         for (cursor = str1; *cursor; cursor++)
1175                 if (stricmp(cursor, str2) == 0)
1176                         return cursor;
1177
1178         return NULL;
1179 }
1180
1181 /*
1182  * Substitute a variable value for its name in a submount pathname.  Variable
1183  * name has been identified by smb_stristr() and is in substr.  Variable name
1184  * length (plus one) is in substr_size.  Variable value is in newstr.
1185  */
1186 static void smb_subst(char *str1, char *substr, unsigned int substr_size,
1187         char *newstr)
1188 {
1189         char temp[1024];
1190
1191         strcpy(temp, substr + substr_size - 1);
1192         strcpy(substr, newstr);
1193         strcat(str1, temp);
1194 }
1195
1196 char VNUserName[] = "%USERNAME%";
1197 char VNLCUserName[] = "%LCUSERNAME%";
1198 char VNComputerName[] = "%COMPUTERNAME%";
1199 char VNLCComputerName[] = "%LCCOMPUTERNAME%";
1200
1201 #ifdef DJGPP
1202 /* List available shares */
1203 int smb_ListShares()
1204 {
1205         char sbmtpath[256];
1206         char pathName[256];
1207         char shareBuf[4096];
1208         int num_shares=0;
1209         char *this_share;
1210         int len;
1211         char *p;
1212         int print_afs = 0;
1213         int code;
1214
1215         /*strcpy(shareNameList[num_shares], "all");
1216          strcpy(pathNameList[num_shares++], "/afs");*/
1217         fprintf(stderr, "The following shares are available:\n");
1218         fprintf(stderr, "Share Name (AFS Path)\n");
1219         fprintf(stderr, "---------------------\n");
1220         fprintf(stderr, "\\\\%s\\%-16s (%s)\n", smb_localNamep, "ALL", cm_mountRoot);
1221
1222 #ifndef DJGPP
1223         code = GetWindowsDirectory(sbmtpath, sizeof(sbmtpath));
1224         if (code == 0 || code > sizeof(sbmtpath)) return -1;
1225 #else
1226         strcpy(sbmtpath, cm_confDir);
1227 #endif /* !DJGPP */
1228         strcat(sbmtpath, "/afsdsbmt.ini");
1229         len = GetPrivateProfileString("AFS Submounts", NULL, NULL,
1230                                                                    shareBuf, sizeof(shareBuf),
1231                                                                    sbmtpath);
1232         if (len == 0) {
1233                 return num_shares;
1234         }
1235
1236         this_share = shareBuf;
1237         do
1238         {
1239                 print_afs = 0;
1240                 /*strcpy(shareNameList[num_shares], this_share);*/
1241                 len = GetPrivateProfileString("AFS Submounts", this_share,
1242                                                                            NULL,
1243                                                                            pathName, 256,
1244                                                                            sbmtpath);
1245                 if (!len) 
1246                         return num_shares;
1247                 p = pathName;
1248                 if (strncmp(p, cm_mountRoot, strlen(cm_mountRoot)) != 0)
1249             print_afs = 1;
1250                 while (*p) {
1251             if (*p == '\\') *p = '/';    /* change to / */
1252             p++;
1253                 }
1254
1255                 fprintf(stderr, "\\\\%s\\%-16s (%s%s)\n",
1256                                  smb_localNamep, this_share, (print_afs ? cm_mountRoot : "\0"),
1257                                  pathName);
1258                 num_shares++;
1259                 while (*this_share != 0) this_share++;  /* find next NUL */
1260                 this_share++;   /* skip past the NUL */
1261         } while (*this_share != 0);  /* stop at final NUL */
1262
1263         return num_shares;
1264 }
1265 #endif /* DJGPP */
1266 /* find a shareName in the table of submounts */
1267 int smb_FindShare(smb_vc_t *vcp, smb_user_t *uidp, char *shareName,
1268         char **pathNamep)
1269 {
1270         DWORD len;
1271         char pathName[1024];
1272         char *var;
1273         char temp[1024];
1274         DWORD sizeTemp;
1275 #ifdef DJGPP
1276     char sbmtpath[MAX_PATH];
1277 #endif
1278     char *p, *q;
1279         HKEY parmKey;
1280         DWORD code;
1281     DWORD allSubmount = 1;
1282
1283         if (strcmp(shareName, "IPC$") == 0) {
1284                 *pathNamep = NULL;
1285                 return 0;
1286         }
1287
1288     /* if allSubmounts == 0, only return the //mountRoot/all share 
1289      * if in fact it has been been created in the subMounts table.  
1290      * This is to allow sites that want to restrict access to the 
1291      * world to do so.
1292      */
1293         code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSConfigKeyName,
1294                                                 0, KEY_QUERY_VALUE, &parmKey);
1295         if (code == ERROR_SUCCESS) {
1296         len = sizeof(allSubmount);
1297         code = RegQueryValueEx(parmKey, "AllSubmount", NULL, NULL,
1298                                 (BYTE *) &allSubmount, &len);
1299         if (code != ERROR_SUCCESS) {
1300             allSubmount = 1;
1301         }
1302         RegCloseKey (parmKey);
1303         }
1304
1305         if (allSubmount && _stricmp(shareName, "all") == 0) {
1306                 *pathNamep = NULL;
1307                 return 1;
1308         }
1309
1310     /* In case, the all share is disabled we need to still be able
1311      * to handle ioctl requests 
1312      */
1313         if (_stricmp(shareName, "ioctl$") == 0) {
1314                 *pathNamep = strdup("/.__ioctl__");
1315                 return 1;
1316         }
1317
1318 #ifndef DJGPP
1319         code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SOFTWARE\\OpenAFS\\Client\\Submounts",
1320                                                 0, KEY_QUERY_VALUE, &parmKey);
1321         if (code == ERROR_SUCCESS) {
1322         len = sizeof(pathName);
1323         code = RegQueryValueEx(parmKey, shareName, NULL, NULL,
1324                                 (BYTE *) pathName, &len);
1325                 if (code != ERROR_SUCCESS)
1326                         len = 0;
1327         RegCloseKey (parmKey);
1328         } else {
1329         len = 0;
1330     }   
1331 #else /* DJGPP */
1332     strcpy(sbmtpath, cm_confDir);
1333     strcat(sbmtpath, "/afsdsbmt.ini");
1334         len = GetPrivateProfileString("AFS Submounts", shareName, "",
1335                                   pathName, sizeof(pathName), sbmtpath);
1336 #endif /* !DJGPP */
1337         if (len != 0 && len != sizeof(pathName) - 1) {
1338         /* We can accept either unix or PC style AFS pathnames.  Convert
1339          * Unix-style to PC style here for internal use. 
1340          */
1341         p = pathName;
1342         if (strncmp(p, cm_mountRoot, strlen(cm_mountRoot)) == 0)
1343             p += strlen(cm_mountRoot);  /* skip mount path */
1344         q = p;
1345         while (*q) {
1346             if (*q == '/') *q = '\\';    /* change to \ */
1347             q++;
1348         }
1349
1350         while (1)
1351         {
1352             if (var = smb_stristr(p, VNUserName)) {
1353                 if (uidp && uidp->unp)
1354                     smb_subst(p, var, sizeof(VNUserName),uidp->unp->name);
1355                 else
1356                     smb_subst(p, var, sizeof(VNUserName)," ");
1357             }
1358             else if (var = smb_stristr(p, VNLCUserName)) 
1359             {
1360                 if (uidp && uidp->unp)
1361                     strcpy(temp, uidp->unp->name);
1362                 else 
1363                     strcpy(temp, " ");
1364                 _strlwr(temp);
1365                 smb_subst(p, var, sizeof(VNLCUserName), temp);
1366             }
1367             else if (var = smb_stristr(p, VNComputerName)) 
1368             {
1369                 sizeTemp = sizeof(temp);
1370                 GetComputerName((LPTSTR)temp, &sizeTemp);
1371                 smb_subst(p, var, sizeof(VNComputerName), temp);
1372             }
1373             else if (var = smb_stristr(p, VNLCComputerName)) 
1374             {
1375                 sizeTemp = sizeof(temp);
1376                 GetComputerName((LPTSTR)temp, &sizeTemp);
1377                 _strlwr(temp);
1378                 smb_subst(p, var, sizeof(VNLCComputerName), temp);
1379             }
1380             else     
1381                 break;
1382         }
1383         *pathNamep = strdup(p);
1384         return 1;
1385     } 
1386     else /* create  \\<netbiosName>\<cellname>  */
1387     {
1388         char * p = shareName; 
1389         int rw = 0;
1390
1391         if ( *p == '.' ) {
1392             p++;
1393             rw = 1;
1394         }
1395         /* Get the full name for this cell */
1396         code = cm_SearchCellFile(p, temp, 0, 0);
1397 #ifdef AFS_AFSDB_ENV
1398                 if (code && cm_dnsEnabled) {
1399             int ttl;
1400             code = cm_SearchCellByDNS(p, temp, &ttl, 0, 0);
1401         }
1402 #endif
1403         /* construct the path */
1404         if (code == 0) {     
1405             sprintf(pathName,rw ? "/.%s/" : "/%s/",temp);
1406             *pathNamep = strdup(strlwr(pathName));
1407             return 1;
1408         }
1409         }
1410     /* failure */
1411     *pathNamep = NULL;
1412     return 0;
1413 }
1414
1415 /* Client-side offline caching policy types */
1416 #define CSC_POLICY_MANUAL 0
1417 #define CSC_POLICY_DOCUMENTS 1
1418 #define CSC_POLICY_PROGRAMS 2
1419 #define CSC_POLICY_DISABLE 3
1420
1421 int smb_FindShareCSCPolicy(char *shareName)
1422 {
1423         DWORD len;
1424         char policy[1024];
1425     DWORD dwType;
1426     HKEY hkCSCPolicy;
1427     int  retval = CSC_POLICY_MANUAL;
1428
1429     RegCreateKeyEx( HKEY_LOCAL_MACHINE, 
1430                     "SOFTWARE\\OpenAFS\\Client\\CSCPolicy",
1431                     0, 
1432                     "AFS", 
1433                     REG_OPTION_NON_VOLATILE,
1434                     KEY_READ,
1435                     NULL, 
1436                     &hkCSCPolicy,
1437                     NULL );
1438
1439     len = sizeof(policy);
1440     if ( RegQueryValueEx( hkCSCPolicy, shareName, 0, &dwType, policy, &len ) ||
1441          len == 0) {
1442                 retval = CSC_POLICY_MANUAL;
1443     }
1444         else if (stricmp(policy, "documents") == 0)
1445         {
1446                 retval = CSC_POLICY_DOCUMENTS;
1447         }
1448         else if (stricmp(policy, "programs") == 0)
1449         {
1450                 retval = CSC_POLICY_PROGRAMS;
1451         }
1452         else if (stricmp(policy, "disable") == 0)
1453         {
1454                 retval = CSC_POLICY_DISABLE;
1455         }
1456         
1457     RegCloseKey(hkCSCPolicy);
1458         return retval;
1459 }
1460
1461 /* find a dir search structure by cookie value, and return it held.
1462  * Must be called with smb_globalLock held.
1463  */
1464 smb_dirSearch_t *smb_FindDirSearchNL(long cookie)
1465 {
1466         smb_dirSearch_t *dsp;
1467         
1468         for(dsp = smb_firstDirSearchp; dsp; dsp = (smb_dirSearch_t *) osi_QNext(&dsp->q)) {
1469                 if (dsp->cookie == cookie) {
1470                         if (dsp != smb_firstDirSearchp) {
1471                                 /* move to head of LRU queue, too, if we're not already there */
1472                                 if (smb_lastDirSearchp == (smb_dirSearch_t *) &dsp->q)
1473                                         smb_lastDirSearchp = (smb_dirSearch_t *)
1474                                                 osi_QPrev(&dsp->q);
1475                                 osi_QRemove((osi_queue_t **) &smb_firstDirSearchp, &dsp->q);
1476                                 osi_QAdd((osi_queue_t **) &smb_firstDirSearchp, &dsp->q);
1477                                 if (!smb_lastDirSearchp)
1478                                         smb_lastDirSearchp = (smb_dirSearch_t *) &dsp->q;
1479                         }
1480                         dsp->refCount++;
1481                         break;
1482                 }
1483         }
1484         return dsp;
1485 }
1486
1487 void smb_DeleteDirSearch(smb_dirSearch_t *dsp)
1488 {
1489         lock_ObtainWrite(&smb_globalLock);
1490         dsp->flags |= SMB_DIRSEARCH_DELETE;
1491         lock_ReleaseWrite(&smb_globalLock);
1492         lock_ObtainMutex(&dsp->mx);
1493         if(dsp->scp != NULL) {
1494                 lock_ObtainMutex(&dsp->scp->mx);
1495                 if (dsp->flags & SMB_DIRSEARCH_BULKST) {
1496                         dsp->flags &= ~SMB_DIRSEARCH_BULKST;
1497                     dsp->scp->flags &= ~CM_SCACHEFLAG_BULKSTATTING;
1498                     dsp->scp->bulkStatProgress = hones;
1499                 }       
1500                 lock_ReleaseMutex(&dsp->scp->mx);
1501         }       
1502         lock_ReleaseMutex(&dsp->mx);
1503 }
1504
1505 void smb_ReleaseDirSearch(smb_dirSearch_t *dsp)
1506 {
1507         cm_scache_t *scp;
1508         
1509         scp = NULL;
1510
1511         lock_ObtainWrite(&smb_globalLock);
1512         osi_assert(dsp->refCount-- > 0);
1513         if (dsp->refCount == 0 && (dsp->flags & SMB_DIRSEARCH_DELETE)) {
1514                 if (&dsp->q == (osi_queue_t *) smb_lastDirSearchp)
1515                         smb_lastDirSearchp = (smb_dirSearch_t *) osi_QPrev(&smb_lastDirSearchp->q);
1516                 osi_QRemove((osi_queue_t **) &smb_firstDirSearchp, &dsp->q);
1517                 lock_FinalizeMutex(&dsp->mx);
1518                 scp = dsp->scp;
1519                 free(dsp);
1520         }
1521         lock_ReleaseWrite(&smb_globalLock);
1522
1523         /* do this now to avoid spurious locking hierarchy creation */
1524         if (scp) cm_ReleaseSCache(scp);
1525 }
1526
1527 /* find a dir search structure by cookie value, and return it held */
1528 smb_dirSearch_t *smb_FindDirSearch(long cookie)
1529 {
1530         smb_dirSearch_t *dsp;
1531
1532         lock_ObtainWrite(&smb_globalLock);
1533         dsp = smb_FindDirSearchNL(cookie);
1534         lock_ReleaseWrite(&smb_globalLock);
1535         return dsp;
1536 }
1537
1538 /* GC some dir search entries, in the address space expected by the specific protocol.
1539  * Must be called with smb_globalLock held; release the lock temporarily.
1540  */
1541 #define SMB_DIRSEARCH_GCMAX     10      /* how many at once */
1542 void smb_GCDirSearches(int isV3)
1543 {
1544         smb_dirSearch_t *prevp;
1545         smb_dirSearch_t *tp;
1546         smb_dirSearch_t *victimsp[SMB_DIRSEARCH_GCMAX];
1547         int victimCount;
1548         int i;
1549         
1550         victimCount = 0;        /* how many have we got so far */
1551         for(tp = smb_lastDirSearchp; tp; tp=prevp) {
1552                 /* we'll move tp from queue, so
1553                  * do this early.
1554                  */
1555                 prevp = (smb_dirSearch_t *) osi_QPrev(&tp->q);  
1556                 /* if no one is using this guy, and we're either in the new protocol,
1557                  * or we're in the old one and this is a small enough ID to be useful
1558                  * to the old protocol, GC this guy.
1559                  */
1560                 if (tp->refCount == 0 && (isV3 || tp->cookie <= 255)) {
1561                         /* hold and delete */
1562                         tp->flags |= SMB_DIRSEARCH_DELETE;
1563                         victimsp[victimCount++] = tp;
1564                         tp->refCount++;
1565                 }
1566
1567                 /* don't do more than this */
1568                 if (victimCount >= SMB_DIRSEARCH_GCMAX) break;
1569         }
1570         
1571         /* now release them */
1572         lock_ReleaseWrite(&smb_globalLock);
1573         for(i = 0; i < victimCount; i++) {
1574                 smb_ReleaseDirSearch(victimsp[i]);
1575         }
1576         lock_ObtainWrite(&smb_globalLock);
1577 }
1578
1579 /* function for allocating a dir search entry.  We need these to remember enough context
1580  * since we don't get passed the path from call to call during a directory search.
1581  *
1582  * Returns a held dir search structure, and bumps the reference count on the vnode,
1583  * since it saves a pointer to the vnode.
1584  */
1585 smb_dirSearch_t *smb_NewDirSearch(int isV3)
1586 {
1587         smb_dirSearch_t *dsp;
1588         int counter;
1589         int maxAllowed;
1590
1591         lock_ObtainWrite(&smb_globalLock);
1592         counter = 0;
1593
1594         /* what's the biggest ID allowed in this version of the protocol */
1595         if (isV3) maxAllowed = 65535;
1596         else maxAllowed = 255;
1597
1598         while(1) {
1599                 /* twice so we have enough tries to find guys we GC after one pass;
1600                  * 10 extra is just in case I mis-counted.
1601                  */
1602                 if (++counter > 2*maxAllowed+10) osi_panic("afsd: dir search cookie leak",
1603                                                                                                         __FILE__, __LINE__);
1604                 if (smb_dirSearchCounter > maxAllowed) {        
1605                         smb_dirSearchCounter = 1;
1606                         smb_GCDirSearches(isV3);        /* GC some (drops global lock) */
1607                 }       
1608                 dsp = smb_FindDirSearchNL(smb_dirSearchCounter);
1609                 if (dsp) {
1610                         /* don't need to watch for refcount zero and deleted, since
1611                          * we haven't dropped the global lock.
1612                          */
1613                         dsp->refCount--;
1614                         ++smb_dirSearchCounter;
1615                         continue;
1616                 }       
1617                 
1618                 dsp = malloc(sizeof(*dsp));
1619                 memset(dsp, 0, sizeof(*dsp));
1620                 osi_QAdd((osi_queue_t **) &smb_firstDirSearchp, &dsp->q);
1621                 if (!smb_lastDirSearchp) smb_lastDirSearchp = (smb_dirSearch_t *) &dsp->q;
1622                 dsp->cookie = smb_dirSearchCounter;
1623                 ++smb_dirSearchCounter;
1624                 dsp->refCount = 1;
1625                 lock_InitializeMutex(&dsp->mx, "cm_dirSearch_t");
1626                 dsp->lastTime = osi_Time();
1627                 break;
1628         }       
1629         lock_ReleaseWrite(&smb_globalLock);
1630         return dsp;
1631 }
1632
1633 static smb_packet_t *GetPacket(void)
1634 {
1635         smb_packet_t *tbp;
1636 #ifdef DJGPP
1637         unsigned int npar, seg, tb_sel;
1638 #endif
1639
1640         lock_ObtainWrite(&smb_globalLock);
1641         tbp = smb_packetFreeListp;
1642     if (tbp) 
1643         smb_packetFreeListp = tbp->nextp;
1644         lock_ReleaseWrite(&smb_globalLock);
1645     if (!tbp) {
1646 #ifndef DJGPP
1647         tbp = calloc(65540,1);
1648 #else /* DJGPP */
1649         tbp = malloc(sizeof(smb_packet_t));
1650 #endif /* !DJGPP */
1651         tbp->magic = SMB_PACKETMAGIC;
1652                 tbp->ncbp = NULL;
1653                 tbp->vcp = NULL;
1654                 tbp->resumeCode = 0;
1655                 tbp->inCount = 0;
1656                 tbp->fid = 0;
1657                 tbp->wctp = NULL;
1658                 tbp->inCom = 0;
1659                 tbp->oddByte = 0;
1660                 tbp->ncb_length = 0;
1661                 tbp->flags = 0;
1662         tbp->spacep = NULL;
1663         
1664 #ifdef DJGPP
1665         npar = SMB_PACKETSIZE >> 4;  /* number of paragraphs */
1666         {
1667             signed int retval =
1668                 __dpmi_allocate_dos_memory(npar, &tb_sel); /* DOS segment */
1669             if (retval == -1) {
1670                 afsi_log("Cannot allocate %d paragraphs of DOS memory",
1671                           npar);
1672                 osi_panic("",__FILE__,__LINE__);
1673             }
1674             else {
1675                 afsi_log("Allocated %d paragraphs of DOS mem at 0x%X",
1676                           npar, retval);
1677                 seg = retval;
1678             }
1679         }
1680         tbp->dos_pkt = (seg * 16) + 0;  /* DOS physical address */
1681         tbp->dos_pkt_sel = tb_sel;
1682 #endif /* DJGPP */
1683         }
1684     osi_assert(tbp->magic == SMB_PACKETMAGIC);
1685
1686     return tbp;
1687 }
1688
1689 smb_packet_t *smb_CopyPacket(smb_packet_t *pkt)
1690 {
1691         smb_packet_t *tbp;
1692         tbp = GetPacket();
1693         memcpy(tbp, pkt, sizeof(smb_packet_t));
1694         tbp->wctp = tbp->data + ((unsigned int)pkt->wctp - (unsigned int)pkt->data);
1695         return tbp;
1696 }
1697
1698 static NCB *GetNCB(void)
1699 {
1700         smb_ncb_t *tbp;
1701     NCB *ncbp;
1702 #ifdef DJGPP
1703     unsigned int npar, seg, tb_sel;
1704 #endif /* DJGPP */
1705
1706         lock_ObtainWrite(&smb_globalLock);
1707         tbp = smb_ncbFreeListp;
1708     if (tbp) 
1709         smb_ncbFreeListp = tbp->nextp;
1710         lock_ReleaseWrite(&smb_globalLock);
1711     if (!tbp) {
1712 #ifndef DJGPP
1713         tbp = calloc(sizeof(*tbp),1);
1714 #else /* DJGPP */
1715         tbp = malloc(sizeof(*tbp));
1716         npar = (sizeof(NCB)+15) >> 4;  /* number of paragraphs */
1717         {
1718             signed int retval =
1719                 __dpmi_allocate_dos_memory(npar, &tb_sel); /* DOS segment */
1720             if (retval == -1) {
1721                 afsi_log("Cannot allocate %d paragraphs of DOS mem in GetNCB",
1722                           npar);
1723                 osi_panic("",__FILE__,__LINE__);
1724             } else {
1725                 afsi_log("Allocated %d paragraphs of DOS mem at 0x%X in GetNCB",
1726                           npar, retval);
1727                 seg = retval;
1728             }
1729         }
1730         tbp->dos_ncb = (seg * 16) + 0;  /* DOS physical address */
1731         tbp->dos_ncb_sel = tb_sel;
1732 #endif /* !DJGPP */
1733         tbp->magic = SMB_NCBMAGIC;
1734         }
1735         
1736     osi_assert(tbp->magic == SMB_NCBMAGIC);
1737
1738         memset(&tbp->ncb, 0, sizeof(NCB));
1739     ncbp = &tbp->ncb;
1740 #ifdef DJGPP
1741     dos_memset(tbp->dos_ncb, 0, sizeof(NCB));
1742 #endif /* DJGPP */
1743     return ncbp;
1744 }
1745
1746 void smb_FreePacket(smb_packet_t *tbp)
1747 {
1748     osi_assert(tbp->magic == SMB_PACKETMAGIC);
1749         
1750     lock_ObtainWrite(&smb_globalLock);
1751         tbp->nextp = smb_packetFreeListp;
1752         smb_packetFreeListp = tbp;
1753         tbp->magic = SMB_PACKETMAGIC;
1754         tbp->ncbp = NULL;
1755         tbp->vcp = NULL;
1756         tbp->resumeCode = 0;
1757         tbp->inCount = 0;
1758         tbp->fid = 0;
1759         tbp->wctp = NULL;
1760         tbp->inCom = 0;
1761         tbp->oddByte = 0;
1762         tbp->ncb_length = 0;
1763         tbp->flags = 0;
1764     lock_ReleaseWrite(&smb_globalLock);
1765 }
1766
1767 static void FreeNCB(NCB *bufferp)
1768 {
1769         smb_ncb_t *tbp;
1770         
1771     tbp = (smb_ncb_t *) bufferp;
1772     osi_assert(tbp->magic == SMB_NCBMAGIC);
1773         
1774     lock_ObtainWrite(&smb_globalLock);
1775         tbp->nextp = smb_ncbFreeListp;
1776         smb_ncbFreeListp = tbp;
1777     lock_ReleaseWrite(&smb_globalLock);
1778 }
1779
1780 /* get a ptr to the data part of a packet, and its count */
1781 unsigned char *smb_GetSMBData(smb_packet_t *smbp, int *nbytesp)
1782 {
1783     int parmBytes;
1784     int dataBytes;
1785     unsigned char *afterParmsp;
1786
1787     parmBytes = *smbp->wctp << 1;
1788         afterParmsp = smbp->wctp + parmBytes + 1;
1789         
1790     dataBytes = afterParmsp[0] + (afterParmsp[1]<<8);
1791     if (nbytesp) *nbytesp = dataBytes;
1792         
1793         /* don't forget to skip the data byte count, since it follows
1794      * the parameters; that's where the "2" comes from below.
1795      */
1796     return (unsigned char *) (afterParmsp + 2);
1797 }
1798
1799 /* must set all the returned parameters before playing around with the
1800  * data region, since the data region is located past the end of the
1801  * variable number of parameters.
1802  */
1803 void smb_SetSMBDataLength(smb_packet_t *smbp, unsigned int dsize)
1804 {
1805         unsigned char *afterParmsp;
1806
1807         afterParmsp = smbp->wctp + ((*smbp->wctp)<<1) + 1;
1808         
1809         *afterParmsp++ = dsize & 0xff;
1810         *afterParmsp = (dsize>>8) & 0xff;
1811 }
1812
1813 /* return the parm'th parameter in the smbp packet */
1814 unsigned int smb_GetSMBParm(smb_packet_t *smbp, int parm)
1815 {
1816         int parmCount;
1817         unsigned char *parmDatap;
1818
1819         parmCount = *smbp->wctp;
1820
1821         if (parm >= parmCount) {
1822 #ifndef DJGPP
1823         HANDLE h;
1824                 char *ptbuf[1];
1825                 char s[100];
1826                 h = RegisterEventSource(NULL, AFS_DAEMON_EVENT_NAME);
1827                 sprintf(s, "Bad SMB param %d out of %d, ncb len %d",
1828                                 parm, parmCount, smbp->ncb_length);
1829                 ptbuf[0] = s;
1830                 ReportEvent(h, EVENTLOG_ERROR_TYPE, 0, 1006, NULL,
1831                                         1, smbp->ncb_length, ptbuf, smbp);
1832                 DeregisterEventSource(h);
1833 #else /* DJGPP */
1834                 char s[100];
1835
1836                 sprintf(s, "Bad SMB param %d out of %d, ncb len %d",
1837                                 parm, parmCount, smbp->ncb_length);
1838                 osi_Log0(smb_logp, s);
1839 #endif /* !DJGPP */
1840                 osi_panic(s, __FILE__, __LINE__);
1841         }
1842         parmDatap = smbp->wctp + (2*parm) + 1;
1843         
1844         return parmDatap[0] + (parmDatap[1] << 8);
1845 }
1846
1847 /* return the parm'th parameter in the smbp packet */
1848 unsigned int smb_GetSMBOffsetParm(smb_packet_t *smbp, int parm, int offset)
1849 {
1850         int parmCount;
1851         unsigned char *parmDatap;
1852
1853         parmCount = *smbp->wctp;
1854
1855         if (parm * 2 + offset >= parmCount * 2) {
1856 #ifndef DJGPP
1857                 HANDLE h;
1858                 char *ptbuf[1];
1859                 char s[100];
1860                 h = RegisterEventSource(NULL, AFS_DAEMON_EVENT_NAME);
1861                 sprintf(s, "Bad SMB param %d offset %d out of %d, ncb len %d",
1862                                 parm, offset, parmCount, smbp->ncb_length);
1863                 ptbuf[0] = s;
1864                 ReportEvent(h, EVENTLOG_ERROR_TYPE, 0, 1006, NULL,
1865                                         1, smbp->ncb_length, ptbuf, smbp);
1866                 DeregisterEventSource(h);
1867 #else /* DJGPP */
1868                 char s[100];
1869                 
1870                 sprintf(s, "Bad SMB param %d offset %d out of %d, "
1871                                 "ncb len %d",
1872                                  parm, offset, parmCount, smbp->ncb_length);
1873                 osi_Log0(smb_logp, s);
1874 #endif /* !DJGPP */
1875
1876                 osi_panic(s, __FILE__, __LINE__);
1877         }
1878         parmDatap = smbp->wctp + (2*parm) + 1 + offset;
1879         
1880         return parmDatap[0] + (parmDatap[1] << 8);
1881 }
1882
1883 void smb_SetSMBParm(smb_packet_t *smbp, int slot, unsigned int parmValue)
1884 {
1885         char *parmDatap;
1886
1887         /* make sure we have enough slots */
1888         if (*smbp->wctp <= slot) *smbp->wctp = slot+1;
1889         
1890         parmDatap = smbp->wctp + 2*slot + 1 + smbp->oddByte;
1891         *parmDatap++ = parmValue & 0xff;
1892         *parmDatap = (parmValue>>8) & 0xff;
1893 }
1894
1895 void smb_SetSMBParmLong(smb_packet_t *smbp, int slot, unsigned int parmValue)
1896 {
1897         char *parmDatap;
1898
1899         /* make sure we have enough slots */
1900         if (*smbp->wctp <= slot) *smbp->wctp = slot+2;
1901
1902         parmDatap = smbp->wctp + 2*slot + 1 + smbp->oddByte;
1903         *parmDatap++ = parmValue & 0xff;
1904         *parmDatap++ = (parmValue>>8) & 0xff;
1905         *parmDatap++ = (parmValue>>16) & 0xff;
1906         *parmDatap++ = (parmValue>>24) & 0xff;
1907 }
1908
1909 void smb_SetSMBParmDouble(smb_packet_t *smbp, int slot, char *parmValuep)
1910 {
1911         char *parmDatap;
1912         int i;
1913
1914         /* make sure we have enough slots */
1915         if (*smbp->wctp <= slot) *smbp->wctp = slot+4;
1916
1917         parmDatap = smbp->wctp + 2*slot + 1 + smbp->oddByte;
1918         for (i=0; i<8; i++)
1919                 *parmDatap++ = *parmValuep++;
1920 }
1921
1922 void smb_SetSMBParmByte(smb_packet_t *smbp, int slot, unsigned int parmValue)
1923 {
1924         char *parmDatap;
1925
1926         /* make sure we have enough slots */
1927         if (*smbp->wctp <= slot) {
1928                 if (smbp->oddByte) {
1929                         smbp->oddByte = 0;
1930                         *smbp->wctp = slot+1;
1931                 } else
1932                         smbp->oddByte = 1;
1933         }
1934
1935         parmDatap = smbp->wctp + 2*slot + 1 + (1 - smbp->oddByte);
1936         *parmDatap++ = parmValue & 0xff;
1937 }
1938
1939 void smb_StripLastComponent(char *outPathp, char **lastComponentp, char *inPathp)
1940 {
1941         char *lastSlashp;
1942         
1943         lastSlashp = strrchr(inPathp, '\\');
1944         if (lastComponentp)
1945                 *lastComponentp = lastSlashp;
1946         if (lastSlashp) {
1947                 while (1) {
1948                         if (inPathp == lastSlashp) 
1949                                 break;
1950                         *outPathp++ = *inPathp++;
1951                 }
1952                 *outPathp++ = 0;
1953         }
1954         else {
1955                 *outPathp++ = 0;
1956         }
1957 }
1958
1959 unsigned char *smb_ParseASCIIBlock(unsigned char *inp, char **chainpp)
1960 {
1961         if (*inp++ != 0x4) 
1962                 return NULL;
1963         if (chainpp) {
1964                 *chainpp = inp + strlen(inp) + 1;       /* skip over null-terminated string */
1965         }
1966         return inp;
1967 }
1968
1969 unsigned char *smb_ParseVblBlock(unsigned char *inp, char **chainpp, int *lengthp)
1970 {
1971         int tlen;
1972
1973         if (*inp++ != 0x5) 
1974                 return NULL;
1975         tlen = inp[0] + (inp[1]<<8);
1976         inp += 2;               /* skip length field */
1977         
1978         if (chainpp) {
1979                 *chainpp = inp + tlen;
1980         }
1981         
1982         if (lengthp) 
1983                 *lengthp = tlen;
1984         
1985         return inp;
1986 }       
1987
1988 /* format a packet as a response */
1989 void smb_FormatResponsePacket(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *op)
1990 {
1991         smb_t *outp;
1992         smb_t *inSmbp;
1993
1994         outp = (smb_t *) op;
1995         
1996         /* zero the basic structure through the smb_wct field, and zero the data
1997          * size field, assuming that wct stays zero; otherwise, you have to 
1998          * explicitly set the data size field, too.
1999          */
2000         inSmbp = (smb_t *) inp;
2001         memset(outp, 0, sizeof(smb_t)+2);
2002         outp->id[0] = 0xff;
2003         outp->id[1] = 'S';
2004         outp->id[2] = 'M';
2005         outp->id[3] = 'B';
2006         if (inp) {
2007                 outp->com = inSmbp->com;
2008                 outp->tid = inSmbp->tid;
2009                 outp->pid = inSmbp->pid;
2010                 outp->uid = inSmbp->uid;
2011                 outp->mid = inSmbp->mid;
2012                 outp->res[0] = inSmbp->res[0];
2013                 outp->res[1] = inSmbp->res[1];
2014                 op->inCom = inSmbp->com;
2015         }
2016         outp->reb = 0x80;       /* SERVER_RESP */
2017         outp->flg2 = 0x1;       /* KNOWS_LONG_NAMES */
2018
2019         /* copy fields in generic packet area */
2020         op->wctp = &outp->wct;
2021 }
2022
2023 /* send a (probably response) packet; vcp tells us to whom to send it.
2024  * we compute the length by looking at wct and bcc fields.
2025  */
2026 void smb_SendPacket(smb_vc_t *vcp, smb_packet_t *inp)
2027 {
2028         NCB *ncbp;
2029         int extra;
2030         long code = 0;
2031         unsigned char *tp;
2032         int localNCB = 0;
2033 #ifdef DJGPP
2034         dos_ptr dos_ncb;
2035 #endif /* DJGPP */
2036         
2037         ncbp = inp->ncbp;
2038         if (ncbp == NULL) {
2039                 ncbp = GetNCB();
2040                 localNCB = 1;
2041         }
2042 #ifdef DJGPP
2043         dos_ncb = ((smb_ncb_t *)ncbp)->dos_ncb;
2044 #endif /* DJGPP */
2045  
2046         memset((char *)ncbp, 0, sizeof(NCB));
2047
2048         extra = 2 * (*inp->wctp);       /* space used by parms, in bytes */
2049         tp = inp->wctp + 1+ extra;      /* points to count of data bytes */
2050         extra += tp[0] + (tp[1]<<8);
2051         extra += ((unsigned int)inp->wctp - (unsigned int)inp->data);   /* distance to last wct field */
2052         extra += 3;                     /* wct and length fields */
2053         
2054         ncbp->ncb_length = extra;       /* bytes to send */
2055         ncbp->ncb_lsn = (unsigned char) vcp->lsn;       /* vc to use */
2056         ncbp->ncb_lana_num = vcp->lana;
2057         ncbp->ncb_command = NCBSEND;    /* op means send data */
2058 #ifndef DJGPP
2059         ncbp->ncb_buffer = (char *) inp;/* packet */
2060         code = Netbios(ncbp);
2061 #else /* DJGPP */
2062         ncbp->ncb_buffer = inp->dos_pkt;/* packet */
2063         ((smb_ncb_t*)ncbp)->orig_pkt = inp;
2064
2065         /* copy header information from virtual to DOS address space */
2066         dosmemput((char*)inp, SMB_PACKETSIZE, inp->dos_pkt);
2067         code = Netbios(ncbp, dos_ncb);
2068 #endif /* !DJGPP */
2069         
2070         if (code != 0)
2071                 osi_Log1(smb_logp, "SendPacket failure code %d", code);
2072
2073         if (localNCB)
2074                 FreeNCB(ncbp);
2075 }
2076
2077 void smb_MapNTError(long code, unsigned long *NTStatusp)
2078 {
2079         unsigned long NTStatus;
2080
2081         /* map CM_ERROR_* errors to NT 32-bit status codes */
2082     /* NT Status codes are listed in ntstatus.h not winerror.h */
2083         if (code == CM_ERROR_NOSUCHCELL) {
2084                 NTStatus = 0xC000000FL; /* No such file */
2085         }
2086         else if (code == CM_ERROR_NOSUCHVOLUME) {
2087                 NTStatus = 0xC000000FL; /* No such file */
2088         }
2089         else if (code == CM_ERROR_TIMEDOUT) {
2090                 NTStatus = 0xC00000CFL; /* Sharing Paused */
2091         }
2092         else if (code == CM_ERROR_RETRY) {
2093                 NTStatus = 0xC000022DL; /* Retry */
2094         }
2095         else if (code == CM_ERROR_NOACCESS) {
2096                 NTStatus = 0xC0000022L; /* Access denied */
2097         }
2098         else if (code == CM_ERROR_READONLY) {
2099                 NTStatus = 0xC00000A2L; /* Write protected */
2100         }       
2101         else if (code == CM_ERROR_NOSUCHFILE) {
2102                 NTStatus = 0xC000000FL; /* No such file */
2103         }
2104         else if (code == CM_ERROR_NOSUCHPATH) {
2105                 NTStatus = 0xC000003AL; /* Object path not found */
2106         }               
2107         else if (code == CM_ERROR_TOOBIG) {
2108                 NTStatus = 0xC000007BL; /* Invalid image format */
2109         }
2110         else if (code == CM_ERROR_INVAL) {
2111                 NTStatus = 0xC000000DL; /* Invalid parameter */
2112         }
2113         else if (code == CM_ERROR_BADFD) {
2114                 NTStatus = 0xC0000008L; /* Invalid handle */
2115         }
2116         else if (code == CM_ERROR_BADFDOP) {
2117                 NTStatus = 0xC0000022L; /* Access denied */
2118         }
2119         else if (code == CM_ERROR_EXISTS) {
2120                 NTStatus = 0xC0000035L; /* Object name collision */
2121         }
2122         else if (code == CM_ERROR_NOTEMPTY) {
2123                 NTStatus = 0xC0000101L; /* Directory not empty */
2124         }       
2125         else if (code == CM_ERROR_CROSSDEVLINK) {
2126                 NTStatus = 0xC00000D4L; /* Not same device */
2127         }
2128         else if (code == CM_ERROR_NOTDIR) {
2129                 NTStatus = 0xC0000103L; /* Not a directory */
2130         }
2131         else if (code == CM_ERROR_ISDIR) {
2132                 NTStatus = 0xC00000BAL; /* File is a directory */
2133         }
2134         else if (code == CM_ERROR_BADOP) {
2135                 NTStatus = 0xC09820FFL; /* SMB no support */
2136         }
2137         else if (code == CM_ERROR_BADSHARENAME) {
2138                 NTStatus = 0xC00000CCL; /* Bad network name */
2139         }
2140         else if (code == CM_ERROR_NOIPC) {
2141 #ifdef COMMENT
2142                 NTStatus = 0xC0000022L; /* Access Denied */
2143 #else
2144         NTStatus = 0xC000013DL; /* Remote Resources */
2145 #endif
2146         }
2147         else if (code == CM_ERROR_CLOCKSKEW) {
2148                 NTStatus = 0xC0000133L; /* Time difference at DC */
2149         }
2150         else if (code == CM_ERROR_BADTID) {
2151                 NTStatus = 0xC0982005L; /* SMB bad TID */
2152         }
2153         else if (code == CM_ERROR_USESTD) {
2154                 NTStatus = 0xC09820FBL; /* SMB use standard */
2155         }
2156         else if (code == CM_ERROR_QUOTA) {
2157                 NTStatus = 0xC0000044L; /* Quota exceeded */
2158         }
2159         else if (code == CM_ERROR_SPACE) {
2160                 NTStatus = 0xC000007FL; /* Disk full */
2161         }
2162         else if (code == CM_ERROR_ATSYS) {
2163                 NTStatus = 0xC0000033L; /* Object name invalid */
2164         }
2165         else if (code == CM_ERROR_BADNTFILENAME) {
2166                 NTStatus = 0xC0000033L; /* Object name invalid */
2167         }
2168         else if (code == CM_ERROR_WOULDBLOCK) {
2169                 NTStatus = 0xC0000055L; /* Lock not granted */
2170         }
2171         else if (code == CM_ERROR_PARTIALWRITE) {
2172                 NTStatus = 0xC000007FL; /* Disk full */
2173         }
2174         else if (code == CM_ERROR_BUFFERTOOSMALL) {
2175                 NTStatus = 0xC0000023L; /* Buffer too small */
2176         }
2177     else if (code == CM_ERROR_AMBIGUOUS_FILENAME) {
2178                 NTStatus = 0xC0000035L; /* Object name collision */
2179     }
2180         else if (code == CM_ERROR_BADPASSWORD) {
2181                 NTStatus = 0xC000006DL; /* unknown username or bad password */
2182         }
2183         else if (code == CM_ERROR_BADLOGONTYPE) {
2184                 NTStatus = 0xC000015BL; /* logon type not granted */
2185         }
2186         else if (code == CM_ERROR_GSSCONTINUE) {
2187                 NTStatus = 0xC0000016L; /* more processing required */
2188         }
2189         else {
2190                 NTStatus = 0xC0982001L; /* SMB non-specific error */
2191         }
2192
2193         *NTStatusp = NTStatus;
2194         osi_Log2(smb_logp, "SMB SEND code %x as NT %x", code, NTStatus);
2195 }
2196
2197 void smb_MapCoreError(long code, smb_vc_t *vcp, unsigned short *scodep,
2198         unsigned char *classp)
2199 {
2200         unsigned char class;
2201         unsigned short error;
2202
2203         /* map CM_ERROR_* errors to SMB errors */
2204         if (code == CM_ERROR_NOSUCHCELL) {
2205                 class = 1;
2206                 error = 3;      /* bad path */
2207         }
2208         else if (code == CM_ERROR_NOSUCHVOLUME) {
2209                 class = 1;
2210                 error = 3;      /* bad path */
2211         }
2212         else if (code == CM_ERROR_TIMEDOUT) {
2213                 class = 2;
2214                 error = 81;     /* server is paused */
2215         }
2216         else if (code == CM_ERROR_RETRY) {
2217                 class = 2;      /* shouldn't happen */
2218                 error = 1;
2219         }
2220         else if (code == CM_ERROR_NOACCESS) {
2221                 class = 2;
2222                 error = 4;      /* bad access */
2223         }
2224         else if (code == CM_ERROR_READONLY) {
2225                 class = 3;
2226                 error = 19;     /* read only */
2227         }
2228         else if (code == CM_ERROR_NOSUCHFILE) {
2229                 class = 1;
2230                 error = 2;      /* ENOENT! */
2231         }
2232         else if (code == CM_ERROR_NOSUCHPATH) {
2233                 class = 1;
2234                 error = 3;      /* Bad path */
2235         }
2236         else if (code == CM_ERROR_TOOBIG) {
2237                 class = 1;
2238                 error = 11;     /* bad format */
2239         }
2240         else if (code == CM_ERROR_INVAL) {
2241                 class = 2;      /* server non-specific error code */
2242                 error = 1;
2243         }
2244         else if (code == CM_ERROR_BADFD) {
2245                 class = 1;
2246                 error = 6;      /* invalid file handle */
2247         }
2248         else if (code == CM_ERROR_BADFDOP) {
2249                 class = 1;      /* invalid op on FD */
2250                 error = 5;
2251         }
2252         else if (code == CM_ERROR_EXISTS) {
2253                 class = 1;
2254                 error = 80;     /* file already exists */
2255         }
2256         else if (code == CM_ERROR_NOTEMPTY) {
2257                 class = 1;
2258                 error = 5;      /* delete directory not empty */
2259         }
2260         else if (code == CM_ERROR_CROSSDEVLINK) {
2261                 class = 1;
2262                 error = 17;     /* EXDEV */
2263         }
2264         else if (code == CM_ERROR_NOTDIR) {
2265                 class = 1;      /* bad path */
2266                 error = 3;
2267         }
2268         else if (code == CM_ERROR_ISDIR) {
2269                 class = 1;      /* access denied; DOS doesn't have a good match */
2270                 error = 5;
2271         }
2272         else if (code == CM_ERROR_BADOP) {
2273                 class = 2;
2274                 error = 65535;
2275         }
2276         else if (code == CM_ERROR_BADSHARENAME) {
2277                 class = 2;
2278                 error = 6;
2279         }
2280         else if (code == CM_ERROR_NOIPC) {
2281                 class = 2;
2282                 error = 4; /* bad access */
2283         }
2284         else if (code == CM_ERROR_CLOCKSKEW) {
2285                 class = 1;      /* invalid function */
2286                 error = 1;
2287         }
2288         else if (code == CM_ERROR_BADTID) {
2289                 class = 2;
2290                 error = 5;
2291         }
2292         else if (code == CM_ERROR_USESTD) {
2293                 class = 2;
2294                 error = 251;
2295         }
2296         else if (code == CM_ERROR_REMOTECONN) {
2297                 class = 2;
2298                 error = 82;
2299         }
2300         else if (code == CM_ERROR_QUOTA) {
2301                 if (vcp->flags & SMB_VCFLAG_USEV3) {
2302                         class = 3;
2303                         error = 39;     /* disk full */
2304                 }
2305                 else {
2306                         class = 1;
2307                         error = 5;      /* access denied */
2308                 }
2309         }
2310         else if (code == CM_ERROR_SPACE) {
2311                 if (vcp->flags & SMB_VCFLAG_USEV3) {
2312                         class = 3;
2313                         error = 39;     /* disk full */
2314                 }
2315                 else {
2316                         class = 1;
2317                         error = 5;      /* access denied */
2318                 }
2319         }
2320         else if (code == CM_ERROR_PARTIALWRITE) {
2321                 class = 3;
2322                 error = 39;     /* disk full */
2323         }
2324         else if (code == CM_ERROR_ATSYS) {
2325                 class = 1;
2326                 error = 2;      /* ENOENT */
2327         }
2328         else if (code == CM_ERROR_WOULDBLOCK) {
2329                 class = 1;
2330                 error = 33;     /* lock conflict */
2331         }
2332         else if (code == CM_ERROR_NOFILES) {
2333                 class = 1;
2334                 error = 18;     /* no files in search */
2335         }
2336         else if (code == CM_ERROR_RENAME_IDENTICAL) {
2337                 class = 1;
2338                 error = 183;     /* Samba uses this */
2339         }
2340         else if (code == CM_ERROR_BADPASSWORD || code == CM_ERROR_BADLOGONTYPE) {
2341                 /* we don't have a good way of reporting CM_ERROR_BADLOGONTYPE */
2342                 class = 2;
2343                 error = 2; /* bad password */
2344         }
2345         else {
2346                 class = 2;
2347                 error = 1;
2348         }
2349
2350         *scodep = error;
2351         *classp = class;
2352         osi_Log3(smb_logp, "SMB SEND code %x as SMB %d: %d", code, class, error);
2353 }
2354
2355 long smb_SendCoreBadOp(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
2356 {
2357         return CM_ERROR_BADOP;
2358 }
2359
2360 long smb_ReceiveCoreEcho(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
2361 {
2362         unsigned short EchoCount, i;
2363         char *data, *outdata;
2364         int dataSize;
2365
2366         EchoCount = (unsigned short) smb_GetSMBParm(inp, 0);
2367
2368         for (i=1; i<=EchoCount; i++) {
2369             data = smb_GetSMBData(inp, &dataSize);
2370             smb_SetSMBParm(outp, 0, i);
2371             smb_SetSMBDataLength(outp, dataSize);
2372             outdata = smb_GetSMBData(outp, NULL);
2373             memcpy(outdata, data, dataSize);
2374             smb_SendPacket(vcp, outp);
2375         }
2376
2377         return 0;
2378 }
2379
2380 long smb_ReceiveCoreReadRaw(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
2381 {
2382         osi_hyper_t offset;
2383         long count, minCount, finalCount;
2384         unsigned short fd;
2385         smb_fid_t *fidp;
2386         long code = 0;
2387         cm_user_t *userp = NULL;
2388     NCB *ncbp;
2389     int rc;
2390 #ifndef DJGPP
2391     char *rawBuf = NULL;
2392 #else
2393     dos_ptr rawBuf = NULL;
2394     dos_ptr dos_ncb;
2395 #endif /* DJGPP */
2396
2397         rawBuf = NULL;
2398         finalCount = 0;
2399
2400         fd = smb_GetSMBParm(inp, 0);
2401         count = smb_GetSMBParm(inp, 3);
2402         minCount = smb_GetSMBParm(inp, 4);
2403         offset.HighPart = 0;    /* too bad */
2404         offset.LowPart = smb_GetSMBParm(inp, 1) | (smb_GetSMBParm(inp, 2) << 16);
2405
2406         osi_Log3(smb_logp, "smb_ReceieveCoreReadRaw fd %d, off 0x%x, size 0x%x",
2407              fd, offset.LowPart, count);
2408
2409         fidp = smb_FindFID(vcp, fd, 0);
2410         if (!fidp)
2411                 goto send1;
2412
2413         lock_ObtainMutex(&smb_RawBufLock);
2414         if (smb_RawBufs) {
2415                 /* Get a raw buf, from head of list */
2416                 rawBuf = smb_RawBufs;
2417 #ifndef DJGPP
2418                 smb_RawBufs = *(char **)smb_RawBufs;
2419 #else /* DJGPP */
2420         smb_RawBufs = _farpeekl(_dos_ds, smb_RawBufs);
2421 #endif /* !DJGPP */
2422         }
2423         lock_ReleaseMutex(&smb_RawBufLock);
2424         if (!rawBuf)
2425                 goto send1a;
2426
2427     if (fidp->flags & SMB_FID_IOCTL)
2428     {
2429 #ifndef DJGPP
2430         rc = smb_IoctlReadRaw(fidp, vcp, inp, outp);
2431 #else
2432         rc = smb_IoctlReadRaw(fidp, vcp, inp, outp, rawBuf);
2433 #endif
2434         if (rawBuf) {
2435             /* Give back raw buffer */
2436             lock_ObtainMutex(&smb_RawBufLock);
2437 #ifndef DJGPP
2438             *((char **) rawBuf) = smb_RawBufs;
2439 #else /* DJGPP */
2440             _farpokel(_dos_ds, rawBuf, smb_RawBufs);
2441 #endif /* !DJGPP */
2442             
2443             smb_RawBufs = rawBuf;
2444             lock_ReleaseMutex(&smb_RawBufLock);
2445         }
2446
2447         smb_ReleaseFID(fidp);
2448         return rc;
2449     }
2450         
2451     userp = smb_GetUser(vcp, inp);
2452
2453 #ifndef DJGPP
2454         code = smb_ReadData(fidp, &offset, count, rawBuf, userp, &finalCount);
2455 #else /* DJGPP */
2456     /* have to give ReadData flag so it will treat buffer as DOS mem. */
2457     code = smb_ReadData(fidp, &offset, count, (unsigned char *)rawBuf,
2458                         userp, &finalCount, TRUE /* rawFlag */);
2459 #endif /* !DJGPP */
2460
2461         if (code != 0)
2462                 goto send;
2463
2464   send:
2465     cm_ReleaseUser(userp);
2466
2467   send1a:
2468         smb_ReleaseFID(fidp);
2469
2470   send1:
2471         ncbp = outp->ncbp;
2472 #ifdef DJGPP
2473     dos_ncb = ((smb_ncb_t *)ncbp)->dos_ncb;
2474 #endif /* DJGPP */
2475         memset((char *)ncbp, 0, sizeof(NCB));
2476
2477         ncbp->ncb_length = (unsigned short) finalCount;
2478         ncbp->ncb_lsn = (unsigned char) vcp->lsn;
2479         ncbp->ncb_lana_num = vcp->lana;
2480         ncbp->ncb_command = NCBSEND;
2481         ncbp->ncb_buffer = rawBuf;
2482
2483 #ifndef DJGPP
2484         code = Netbios(ncbp);
2485 #else /* DJGPP */
2486         code = Netbios(ncbp, dos_ncb);
2487 #endif /* !DJGPP */
2488         if (code != 0)
2489                 osi_Log1(smb_logp, "ReadRaw send failure code %d", code);
2490
2491         if (rawBuf) {
2492                 /* Give back raw buffer */
2493                 lock_ObtainMutex(&smb_RawBufLock);
2494 #ifndef DJGPP
2495                 *((char **) rawBuf) = smb_RawBufs;
2496 #else /* DJGPP */
2497         _farpokel(_dos_ds, rawBuf, smb_RawBufs);
2498 #endif /* !DJGPP */
2499
2500                 smb_RawBufs = rawBuf;
2501                 lock_ReleaseMutex(&smb_RawBufLock);
2502         }
2503
2504         return 0;
2505 }
2506
2507 long smb_ReceiveCoreLockRecord(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
2508 {
2509         return 0;
2510 }
2511
2512 long smb_ReceiveCoreUnlockRecord(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
2513 {
2514         return 0;
2515 }
2516
2517 long smb_ReceiveNegotiate(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
2518 {
2519         char *namep;
2520     char *datap;
2521         int coreProtoIndex;
2522         int v3ProtoIndex;
2523         int NTProtoIndex;
2524         int protoIndex;                         /* index we're using */
2525         int namex;
2526         int dbytes;
2527         int entryLength;
2528         int tcounter;
2529         char protocol_array[10][1024];  /* protocol signature of the client */
2530     int caps;                       /* capabilities */
2531     time_t unixTime;
2532         long dosTime;
2533         TIME_ZONE_INFORMATION tzi;
2534
2535     osi_Log1(smb_logp, "SMB receive negotiate; %d + 1 ongoing ops",
2536                          ongoingOps - 1);
2537         if (!isGateway) {
2538                 if (active_vcp) {
2539                         DWORD now = GetCurrentTime();
2540                         if (now - last_msg_time >= 30000
2541                                 && now - last_msg_time <= 90000) {
2542                                 osi_Log1(smb_logp,
2543                                                  "Setting dead_vcp %x", active_vcp);
2544                 if (dead_vcp) {
2545                     smb_ReleaseVC(dead_vcp);
2546                     osi_Log1(smb_logp,
2547                               "Previous dead_vcp %x", dead_vcp);
2548                 }
2549                 smb_HoldVC(active_vcp);
2550                                 dead_vcp = active_vcp;
2551                                 dead_vcp->flags |= SMB_VCFLAG_ALREADYDEAD;
2552                         }
2553                 }
2554         }
2555
2556         inp->flags |= SMB_PACKETFLAG_PROFILE_UPDATE_OK;
2557
2558         namep = smb_GetSMBData(inp, &dbytes);
2559         namex = 0;
2560         tcounter = 0;
2561         coreProtoIndex = -1;            /* not found */
2562         v3ProtoIndex = -1;
2563         NTProtoIndex = -1;
2564         while(namex < dbytes) {
2565                 osi_Log1(smb_logp, "Protocol %s",
2566                                  osi_LogSaveString(smb_logp, namep+1));
2567                 strcpy(protocol_array[tcounter], namep+1);
2568
2569                 /* namep points at the first protocol, or really, a 0x02
2570                  * byte preceding the null-terminated ASCII name.
2571                  */
2572                 if (strcmp("PC NETWORK PROGRAM 1.0", namep+1) == 0) {
2573                         coreProtoIndex = tcounter;
2574                 }       
2575                 else if (smb_useV3 && strcmp("LM1.2X002", namep+1) == 0) {
2576                         v3ProtoIndex = tcounter;
2577                 }
2578                 else if (smb_useV3 && strcmp("NT LM 0.12", namep+1) == 0) {
2579                         NTProtoIndex = tcounter;
2580                 }
2581
2582                 /* compute size of protocol entry */
2583                 entryLength = strlen(namep+1);
2584         entryLength += 2;       /* 0x02 bytes and null termination */
2585                 
2586         /* advance over this protocol entry */
2587                 namex += entryLength;
2588         namep += entryLength;
2589         tcounter++;             /* which proto entry we're looking at */
2590         }
2591
2592         if (NTProtoIndex != -1) {
2593                 protoIndex = NTProtoIndex;
2594                 vcp->flags |= (SMB_VCFLAG_USENT | SMB_VCFLAG_USEV3);
2595         }
2596         else if (v3ProtoIndex != -1) {
2597                 protoIndex = v3ProtoIndex;
2598                 vcp->flags |= SMB_VCFLAG_USEV3;
2599         }       
2600         else if (coreProtoIndex != -1) {
2601                 protoIndex = coreProtoIndex;
2602                 vcp->flags |= SMB_VCFLAG_USECORE;
2603         }       
2604         else protoIndex = -1;
2605
2606         if (protoIndex == -1)
2607                 return CM_ERROR_INVAL;
2608         else if (NTProtoIndex != -1) {
2609         smb_SetSMBParm(outp, 0, protoIndex);
2610                 if (smb_authType != SMB_AUTH_NONE) {
2611                         smb_SetSMBParmByte(outp, 1,
2612                                 NEGOTIATE_SECURITY_USER_LEVEL |
2613                                 NEGOTIATE_SECURITY_CHALLENGE_RESPONSE); /* user level security, challenge response */
2614                 } else {
2615             smb_SetSMBParmByte(outp, 1, 0); /* share level auth with plaintext password. */
2616                 }
2617         smb_SetSMBParm(outp, 1, smb_maxMpxRequests);    /* max multiplexed requests */
2618         smb_SetSMBParm(outp, 2, smb_maxVCPerServer);    /* max VCs per consumer/server connection */
2619         smb_SetSMBParmLong(outp, 3, SMB_PACKETSIZE);    /* xmit buffer size */
2620                 smb_SetSMBParmLong(outp, 5, SMB_MAXRAWSIZE);    /* raw buffer size */
2621         /* The session key is not a well documented field however most clients
2622          * will echo back the session key to the server.  Currently we are using
2623          * the same value for all sessions.  We should generate a random value
2624          * and store it into the vcp 
2625          */
2626         smb_SetSMBParm(outp, 7, 1);     /* next 2: session key */
2627         smb_SetSMBParm(outp, 8, 1);
2628                 /* 
2629                  * Tried changing the capabilities to support for W2K - defect 117695
2630                  * Maybe something else needs to be changed here?
2631                  */
2632                 /*
2633                   if (isWindows2000) 
2634                   smb_SetSMBParmLong(outp, 9, 0x43fd);
2635                   else 
2636                   smb_SetSMBParmLong(outp, 9, 0x251);
2637                   */
2638                 /* Capabilities: *
2639                  * 32-bit error codes *
2640                  * and NT Find *
2641                  * and NT SMB's *
2642                  * and raw mode */
2643         caps = NTNEGOTIATE_CAPABILITY_NTSTATUS |
2644                            NTNEGOTIATE_CAPABILITY_NTFIND |
2645                NTNEGOTIATE_CAPABILITY_RAWMODE |
2646                            NTNEGOTIATE_CAPABILITY_NTSMB;
2647
2648         if ( smb_authType == SMB_AUTH_EXTENDED )
2649             caps |= NTNEGOTIATE_CAPABILITY_EXTENDED_SECURITY;
2650
2651         smb_SetSMBParmLong(outp, 9, caps);
2652                 time(&unixTime);
2653                 smb_SearchTimeFromUnixTime(&dosTime, unixTime);
2654                 smb_SetSMBParmLong(outp, 11, LOWORD(dosTime));/* server time */
2655                 smb_SetSMBParmLong(outp, 13, HIWORD(dosTime));/* server date */
2656
2657                 GetTimeZoneInformation(&tzi);
2658                 smb_SetSMBParm(outp, 15, (unsigned short) tzi.Bias);    /* server tzone */
2659
2660                 if (smb_authType == SMB_AUTH_NTLM) {
2661                         smb_SetSMBParmByte(outp, 16, MSV1_0_CHALLENGE_LENGTH);/* Encryption key length */
2662                         smb_SetSMBDataLength(outp, MSV1_0_CHALLENGE_LENGTH + smb_ServerDomainNameLength);
2663                         /* paste in encryption key */
2664                         datap = smb_GetSMBData(outp, NULL);
2665                         memcpy(datap,vcp->encKey,MSV1_0_CHALLENGE_LENGTH);
2666                         /* and the faux domain name */
2667                         strcpy(datap + MSV1_0_CHALLENGE_LENGTH,smb_ServerDomainName);
2668                 } else if ( smb_authType == SMB_AUTH_EXTENDED ) {
2669             void * secBlob;
2670                         int secBlobLength;
2671
2672                         smb_SetSMBParmByte(outp, 16, 0); /* Encryption key length */
2673
2674                         smb_NegotiateExtendedSecurity(&secBlob, &secBlobLength);
2675
2676                         smb_SetSMBDataLength(outp, secBlobLength + sizeof(smb_ServerGUID));
2677                         
2678                         datap = smb_GetSMBData(outp, NULL);
2679                         memcpy(datap, &smb_ServerGUID, sizeof(smb_ServerGUID));
2680
2681                         if (secBlob) {
2682                                 datap += sizeof(smb_ServerGUID);
2683                                 memcpy(datap, secBlob, secBlobLength);
2684                                 free(secBlob);
2685                         }
2686         } else {
2687                         smb_SetSMBParmByte(outp, 16, 0); /* Encryption key length */
2688                         smb_SetSMBDataLength(outp, 0);   /* Perhaps we should specify 8 bytes anyway */
2689                 }
2690         }
2691         else if (v3ProtoIndex != -1) {
2692                 smb_SetSMBParm(outp, 0, protoIndex);
2693
2694         /* NOTE: Extended authentication cannot be negotiated with v3
2695          * therefore we fail over to NTLM 
2696          */
2697         if (smb_authType == SMB_AUTH_NTLM || smb_authType == SMB_AUTH_EXTENDED) {
2698                         smb_SetSMBParm(outp, 1,
2699                                 NEGOTIATE_SECURITY_USER_LEVEL |
2700                                 NEGOTIATE_SECURITY_CHALLENGE_RESPONSE); /* user level security, challenge response */
2701                 } else {
2702                         smb_SetSMBParm(outp, 1, 0); /* share level auth with clear password */
2703                 }
2704                 smb_SetSMBParm(outp, 2, SMB_PACKETSIZE);
2705                 smb_SetSMBParm(outp, 3, smb_maxMpxRequests);    /* max multiplexed requests */
2706                 smb_SetSMBParm(outp, 4, smb_maxVCPerServer);    /* max VCs per consumer/server connection */
2707                 smb_SetSMBParm(outp, 5, 0);     /* no support of block mode for read or write */
2708                 smb_SetSMBParm(outp, 6, 1);     /* next 2: session key */
2709                 smb_SetSMBParm(outp, 7, 1);
2710                 time(&unixTime);
2711                 smb_SearchTimeFromUnixTime(&dosTime, unixTime);
2712                 smb_SetSMBParm(outp, 8, LOWORD(dosTime));       /* server time */
2713                 smb_SetSMBParm(outp, 9, HIWORD(dosTime));       /* server date */
2714
2715                 GetTimeZoneInformation(&tzi);
2716                 smb_SetSMBParm(outp, 10, (unsigned short) tzi.Bias);    /* server tzone */
2717
2718         /* NOTE: Extended authentication cannot be negotiated with v3
2719          * therefore we fail over to NTLM 
2720          */
2721                 if (smb_authType == SMB_AUTH_NTLM || smb_authType == SMB_AUTH_EXTENDED) {
2722                         smb_SetSMBParm(outp, 11, MSV1_0_CHALLENGE_LENGTH);      /* encryption key length */
2723             smb_SetSMBParm(outp, 12, 0);        /* resvd */
2724                         smb_SetSMBDataLength(outp, MSV1_0_CHALLENGE_LENGTH + smb_ServerDomainNameLength);       /* perhaps should specify 8 bytes anyway */
2725                         datap = smb_GetSMBData(outp, NULL);
2726                         /* paste in a new encryption key */
2727                         memcpy(datap, vcp->encKey, MSV1_0_CHALLENGE_LENGTH);
2728                         /* and the faux domain name */
2729                         strcpy(datap + MSV1_0_CHALLENGE_LENGTH, smb_ServerDomainName);
2730                 } else {
2731                         smb_SetSMBParm(outp, 11, 0); /* encryption key length */
2732                         smb_SetSMBParm(outp, 12, 0); /* resvd */
2733                         smb_SetSMBDataLength(outp, 0);
2734                 }
2735         }
2736         else if (coreProtoIndex != -1) {     /* not really supported anymore */
2737                 smb_SetSMBParm(outp, 0, protoIndex);
2738                 smb_SetSMBDataLength(outp, 0);
2739         }
2740         return 0;
2741 }
2742
2743 void smb_Daemon(void *parmp)
2744 {
2745         int count = 0;
2746
2747         while(1) {
2748                 count++;
2749                 thrd_Sleep(10000);
2750                 if ((count % 360) == 0) {       /* every hour */
2751             struct tm myTime;
2752                  
2753             /* Initialize smb_localZero */
2754             myTime.tm_isdst = -1;               /* compute whether on DST or not */
2755             myTime.tm_year = 70;
2756             myTime.tm_mon = 0;
2757             myTime.tm_mday = 1;
2758             myTime.tm_hour = 0;
2759             myTime.tm_min = 0;
2760             myTime.tm_sec = 0;
2761             smb_localZero = mktime(&myTime);
2762
2763             smb_CalculateNowTZ();
2764         }
2765                 /* XXX GC dir search entries */
2766         }
2767 }
2768
2769 void smb_WaitingLocksDaemon()
2770 {
2771         smb_waitingLock_t *wL, *nwL;
2772         int first;
2773         smb_vc_t *vcp;
2774         smb_packet_t *inp, *outp;
2775         NCB *ncbp;
2776         long code = 0;
2777
2778         while(1) {
2779                 lock_ObtainWrite(&smb_globalLock);
2780                 nwL = smb_allWaitingLocks;
2781                 if (nwL == NULL) {
2782                         osi_SleepW((long)&smb_allWaitingLocks, &smb_globalLock);
2783                         thrd_Sleep(1000);
2784                         continue;
2785                 }
2786                 else first = 1;
2787                 do {
2788                         if (first)
2789                                 first = 0;
2790                         else
2791                                 lock_ObtainWrite(&smb_globalLock);
2792                         wL = nwL;
2793                         nwL = (smb_waitingLock_t *) osi_QNext(&wL->q);
2794                         lock_ReleaseWrite(&smb_globalLock);
2795                         code = cm_RetryLock((cm_file_lock_t *) wL->lockp,
2796                                                                 wL->vcp->flags & SMB_VCFLAG_ALREADYDEAD);
2797                         if (code == CM_ERROR_WOULDBLOCK) {
2798                                 /* no progress */
2799                                 if (wL->timeRemaining != 0xffffffff
2800                                     && (wL->timeRemaining -= 1000) < 0)
2801                                         goto endWait;
2802                                 continue;
2803                         }
2804                   endWait:
2805                         vcp = wL->vcp;
2806                         inp = wL->inp;
2807                         outp = wL->outp;
2808                         ncbp = GetNCB();
2809                         ncbp->ncb_length = inp->ncb_length;
2810                         inp->spacep = cm_GetSpace();
2811
2812                         /* Remove waitingLock from list */
2813                         lock_ObtainWrite(&smb_globalLock);
2814                         osi_QRemove((osi_queue_t **)&smb_allWaitingLocks,
2815                                     &wL->q);
2816                         lock_ReleaseWrite(&smb_globalLock);
2817
2818                         /* Resume packet processing */
2819                         if (code == 0)
2820                                 smb_SetSMBDataLength(outp, 0);
2821                         outp->flags |= SMB_PACKETFLAG_SUSPENDED;
2822                         outp->resumeCode = code;
2823                         outp->ncbp = ncbp;
2824                         smb_DispatchPacket(vcp, inp, outp, ncbp, NULL);
2825
2826                         /* Clean up */
2827                         cm_FreeSpace(inp->spacep);
2828                         smb_FreePacket(inp);
2829                         smb_FreePacket(outp);
2830                         FreeNCB(ncbp);
2831                         free(wL);
2832                 } while (nwL);
2833                 thrd_Sleep(1000);
2834         }
2835 }
2836
2837 long smb_ReceiveCoreGetDiskAttributes(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
2838 {
2839         osi_Log0(smb_logp, "SMB receive get disk attributes");
2840
2841         smb_SetSMBParm(outp, 0, 32000);
2842         smb_SetSMBParm(outp, 1, 64);
2843         smb_SetSMBParm(outp, 2, 1024);
2844         smb_SetSMBParm(outp, 3, 30000);
2845         smb_SetSMBParm(outp, 4, 0);
2846         smb_SetSMBDataLength(outp, 0);
2847         return 0;
2848 }
2849
2850 long smb_ReceiveCoreTreeConnect(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *rsp)
2851 {
2852         smb_tid_t *tidp;
2853     smb_user_t *uidp;
2854         unsigned short newTid;
2855         char shareName[256];
2856         char *sharePath;
2857         int shareFound;
2858         char *tp;
2859         char *pathp;
2860         char *passwordp;
2861         cm_user_t *userp;
2862
2863         osi_Log0(smb_logp, "SMB receive tree connect");
2864
2865         /* parse input parameters */
2866         tp = smb_GetSMBData(inp, NULL);
2867         pathp = smb_ParseASCIIBlock(tp, &tp);
2868         passwordp = smb_ParseASCIIBlock(tp, &tp);
2869         tp = strrchr(pathp, '\\');
2870         if (!tp)
2871                 return CM_ERROR_BADSMB;
2872         strcpy(shareName, tp+1);
2873
2874         userp = smb_GetUser(vcp, inp);
2875
2876         lock_ObtainMutex(&vcp->mx);
2877         newTid = vcp->tidCounter++;
2878         lock_ReleaseMutex(&vcp->mx);
2879         
2880         tidp = smb_FindTID(vcp, newTid, SMB_FLAG_CREATE);
2881     uidp = smb_FindUID(vcp, ((smb_t *)inp)->uid, 0);
2882         shareFound = smb_FindShare(vcp, uidp, shareName, &sharePath);
2883     if (uidp)
2884         smb_ReleaseUID(uidp);
2885         if (!shareFound) {
2886                 smb_ReleaseTID(tidp);
2887                 return CM_ERROR_BADSHARENAME;
2888         }
2889         lock_ObtainMutex(&tidp->mx);
2890         tidp->userp = userp;
2891         tidp->pathname = sharePath;
2892         lock_ReleaseMutex(&tidp->mx);
2893         smb_ReleaseTID(tidp);
2894
2895         smb_SetSMBParm(rsp, 0, SMB_PACKETSIZE);
2896         smb_SetSMBParm(rsp, 1, newTid);
2897         smb_SetSMBDataLength(rsp, 0);
2898
2899         osi_Log1(smb_logp, "SMB tree connect created ID %d", newTid);
2900         return 0;
2901 }
2902
2903 unsigned char *smb_ParseDataBlock(unsigned char *inp, char **chainpp, int *lengthp)
2904 {
2905         int tlen;
2906
2907         if (*inp++ != 0x1) return NULL;
2908         tlen = inp[0] + (inp[1]<<8);
2909         inp += 2;               /* skip length field */
2910         
2911         if (chainpp) {
2912                 *chainpp = inp + tlen;
2913         }       
2914         
2915         if (lengthp) *lengthp = tlen;
2916         
2917         return inp;
2918 }
2919
2920 /* set maskp to the mask part of the incoming path.
2921  * Mask is 11 bytes long (8.3 with the dot elided).
2922  * Returns true if succeeds with a valid name, otherwise it does
2923  * its best, but returns false.
2924  */
2925 int smb_Get8Dot3MaskFromPath(unsigned char *maskp, unsigned char *pathp)
2926 {
2927         char *tp;
2928         char *up;
2929         int i;
2930         int tc;
2931         int valid8Dot3;
2932
2933         /* starts off valid */
2934         valid8Dot3 = 1;
2935
2936         /* mask starts out all blanks */
2937         memset(maskp, ' ', 11);
2938
2939         /* find last backslash, or use whole thing if there is none */
2940         tp = strrchr(pathp, '\\');
2941         if (!tp) tp = pathp;
2942         else tp++;      /* skip slash */
2943         
2944         up = maskp;
2945
2946         /* names starting with a dot are illegal */
2947         if (*tp == '.') valid8Dot3 = 0;
2948
2949     for(i=0;; i++) {
2950                 tc = *tp++;
2951         if (tc == 0) return valid8Dot3;
2952         if (tc == '.' || tc == '"') break;
2953         if (i < 8) *up++ = tc;
2954         else valid8Dot3 = 0;
2955     }
2956         
2957     /* if we get here, tp point after the dot */
2958     up = maskp+8;       /* ext goes here */
2959     for(i=0;;i++) {
2960         tc = *tp++;
2961         if (tc == 0) 
2962                         return valid8Dot3;
2963
2964         /* too many dots */
2965         if (tc == '.' || tc == '"') 
2966                         valid8Dot3 = 0;
2967
2968         /* copy extension if not too long */
2969         if (i < 3) 
2970                         *up++ = tc;
2971         else 
2972                         valid8Dot3 = 0;
2973     }   
2974
2975     /* unreachable */
2976 }
2977
2978 int smb_Match8Dot3Mask(char *unixNamep, char *maskp)
2979 {
2980         char umask[11];
2981         int valid;
2982         int i;
2983         char tc1;
2984         char tc2;
2985         char *tp1;
2986         char *tp2;
2987
2988         /* XXX redo this, calling smb_V3MatchMask with a converted mask */
2989
2990         valid = smb_Get8Dot3MaskFromPath(umask, unixNamep);
2991         if (!valid) 
2992                 return 0;
2993  
2994         /* otherwise, we have a valid 8.3 name; see if we have a match,
2995          * treating '?' as a wildcard in maskp (but not in the file name).
2996          */
2997         tp1 = umask;    /* real name, in mask format */
2998         tp2 = maskp;    /* mask, in mask format */
2999         for(i=0; i<11; i++) {
3000                 tc1 = *tp1++;   /* char from real name */
3001                 tc2 = *tp2++;   /* char from mask */
3002                 tc1 = (char) cm_foldUpper[(unsigned char)tc1];
3003                 tc2 = (char) cm_foldUpper[(unsigned char)tc2];
3004                 if (tc1 == tc2) 
3005                         continue;
3006                 if (tc2 == '?' && tc1 != ' ') 
3007                         continue;
3008                 if (tc2 == '>') 
3009                         continue;
3010                 return 0;
3011         }
3012
3013         /* we got a match */
3014         return 1;
3015 }
3016
3017 char *smb_FindMask(char *pathp)
3018 {
3019         char *tp;
3020         
3021         tp = strrchr(pathp, '\\');      /* find last slash */
3022
3023         if (tp) 
3024                 return tp+1;    /* skip the slash */
3025         else 
3026                 return pathp;   /* no slash, return the entire path */
3027 }
3028
3029 long smb_ReceiveCoreSearchVolume(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
3030 {
3031         unsigned char *pathp;
3032         unsigned char *tp;
3033         unsigned char mask[11];
3034         unsigned char *statBlockp;
3035         unsigned char initStatBlock[21];
3036         int statLen;
3037         
3038         osi_Log0(smb_logp, "SMB receive search volume");
3039
3040         /* pull pathname and stat block out of request */
3041         tp = smb_GetSMBData(inp, NULL);
3042         pathp = smb_ParseASCIIBlock(tp, (char **) &tp);
3043         osi_assert(pathp != NULL);
3044         statBlockp = smb_ParseVblBlock(tp, (char **) &tp, &statLen);
3045         osi_assert(statBlockp != NULL);
3046         if (statLen == 0) {
3047                 statBlockp = initStatBlock;
3048                 statBlockp[0] = 8;
3049         }
3050         
3051         /* for returning to caller */
3052         smb_Get8Dot3MaskFromPath(mask, pathp);
3053         
3054         smb_SetSMBParm(outp, 0, 1);             /* we're returning one entry */
3055         tp = smb_GetSMBData(outp, NULL);
3056         *tp++ = 5;
3057         *tp++ = 43;     /* bytes in a dir entry */
3058         *tp++ = 0;      /* high byte in counter */
3059
3060         /* now marshall the dir entry, starting with the search status */
3061         *tp++ = statBlockp[0];          /* Reserved */
3062         memcpy(tp, mask, 11); tp += 11; /* FileName */
3063
3064         /* now pass back server use info, with 1st byte non-zero */
3065         *tp++ = 1;
3066         memset(tp, 0, 4); tp += 4;      /* reserved for server use */
3067
3068         memcpy(tp, statBlockp+17, 4); tp += 4;  /* reserved for consumer */
3069
3070         *tp++ = 0x8;            /* attribute: volume */
3071
3072         /* copy out time */
3073         *tp++ = 0;
3074         *tp++ = 0;
3075
3076         /* copy out date */
3077         *tp++ = 18;
3078         *tp++ = 178;
3079
3080         /* 4 byte file size */
3081         *tp++ = 0;
3082         *tp++ = 0;
3083         *tp++ = 0;
3084         *tp++ = 0;
3085
3086         /* finally, null-terminated 8.3 pathname, which we set to AFS */
3087         memset(tp, ' ', 13);
3088         strcpy(tp, "AFS");
3089
3090         /* set the length of the data part of the packet to 43 + 3, for the dir
3091          * entry plus the 5 and the length fields.
3092          */
3093         smb_SetSMBDataLength(outp, 46);
3094         return 0;
3095 }
3096
3097 long smb_ApplyDirListPatches(smb_dirListPatch_t **dirPatchespp,
3098         cm_user_t *userp, cm_req_t *reqp)
3099 {
3100         long code = 0;
3101         cm_scache_t *scp;
3102         char *dptr;
3103         long dosTime;
3104         u_short shortTemp;
3105         char attr;
3106         smb_dirListPatch_t *patchp;
3107         smb_dirListPatch_t *npatchp;
3108
3109         for(patchp = *dirPatchespp; patchp; patchp =
3110                  (smb_dirListPatch_t *) osi_QNext(&patchp->q)) {
3111                 code = cm_GetSCache(&patchp->fid, &scp, userp, reqp);
3112                 if (code) continue;
3113                 lock_ObtainMutex(&scp->mx);
3114                 code = cm_SyncOp(scp, NULL, userp, reqp, 0,
3115                                                   CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
3116                 if (code) {     
3117                         lock_ReleaseMutex(&scp->mx);
3118                         cm_ReleaseSCache(scp);
3119                         continue;
3120                 }
3121                 dptr = patchp->dptr;
3122
3123                 attr = smb_Attributes(scp);
3124         /* check hidden attribute (the flag is only ON when dot file hiding is on ) */
3125         if( patchp->flags & SMB_DIRLISTPATCH_DOTFILE )
3126             attr |= SMB_ATTR_HIDDEN;
3127         *dptr++ = attr;
3128
3129                 /* get dos time */
3130                 smb_SearchTimeFromUnixTime(&dosTime, scp->clientModTime);
3131                 
3132                 /* copy out time */
3133                 shortTemp = dosTime & 0xffff;
3134                 *((u_short *)dptr) = shortTemp;
3135                 dptr += 2;
3136
3137                 /* and copy out date */
3138                 shortTemp = (dosTime>>16) & 0xffff;
3139                 *((u_short *)dptr) = shortTemp;
3140                 dptr += 2;
3141                 
3142                 /* copy out file length */
3143                 *((u_long *)dptr) = scp->length.LowPart;
3144                 dptr += 4;
3145                 lock_ReleaseMutex(&scp->mx);
3146                 cm_ReleaseSCache(scp);
3147         }
3148         
3149         /* now free the patches */
3150         for(patchp = *dirPatchespp; patchp; patchp = npatchp) {
3151                 npatchp = (smb_dirListPatch_t *) osi_QNext(&patchp->q);
3152                 free(patchp);
3153         }       
3154         
3155         /* and mark the list as empty */
3156         *dirPatchespp = NULL;
3157
3158         return code;
3159 }
3160
3161 long smb_ReceiveCoreSearchDir(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
3162 {
3163         int attribute;
3164         long nextCookie;
3165         char *tp;
3166         long code = 0;
3167         char *pathp;
3168         cm_dirEntry_t *dep;
3169         int maxCount;
3170         smb_dirListPatch_t *dirListPatchesp;
3171         smb_dirListPatch_t *curPatchp;
3172         int dataLength;
3173         cm_buf_t *bufferp;
3174         long temp;
3175         osi_hyper_t dirLength;
3176         osi_hyper_t bufferOffset;
3177         osi_hyper_t curOffset;
3178         osi_hyper_t thyper;
3179         unsigned char *inCookiep;
3180         smb_dirSearch_t *dsp;
3181         cm_scache_t *scp;
3182         long entryInDir;
3183         long entryInBuffer;
3184         unsigned long clientCookie;
3185         cm_pageHeader_t *pageHeaderp;
3186         cm_user_t *userp = NULL;
3187         int slotInPage;
3188         char shortName[13];
3189         char *actualName;
3190         char *shortNameEnd;
3191         char mask[11];
3192         int returnedNames;
3193         long nextEntryCookie;
3194         int numDirChunks;               /* # of 32 byte dir chunks in this entry */
3195         char resByte;                   /* reserved byte from the cookie */
3196         char *op;                       /* output data ptr */
3197         char *origOp;                   /* original value of op */
3198         cm_space_t *spacep;             /* for pathname buffer */
3199         int starPattern;
3200         int rootPath = 0;
3201         int caseFold;
3202         char *tidPathp;
3203         cm_req_t req;
3204         cm_fid_t fid;
3205         int fileType;
3206
3207         cm_InitReq(&req);
3208
3209         maxCount = smb_GetSMBParm(inp, 0);
3210
3211         dirListPatchesp = NULL;
3212         
3213         caseFold = CM_FLAG_CASEFOLD;
3214
3215         tp = smb_GetSMBData(inp, NULL);
3216         pathp = smb_ParseASCIIBlock(tp, &tp);
3217         inCookiep = smb_ParseVblBlock(tp, &tp, &dataLength);
3218
3219         /* bail out if request looks bad */
3220         if (!tp || !pathp) {
3221                 return CM_ERROR_BADSMB;
3222         }
3223
3224         /* We can handle long names */
3225         if (vcp->flags & SMB_VCFLAG_USENT)
3226                 ((smb_t *)outp)->flg2 |= 0x40;  /* IS_LONG_NAME */
3227
3228         /* make sure we got a whole search status */
3229         if (dataLength < 21) {
3230                 nextCookie = 0;         /* start at the beginning of the dir */
3231                 resByte = 0;
3232                 clientCookie = 0;
3233                 attribute = smb_GetSMBParm(inp, 1);
3234
3235                 /* handle volume info in another function */
3236                 if (attribute & 0x8)
3237                         return smb_ReceiveCoreSearchVolume(vcp, inp, outp);
3238
3239                 osi_Log2(smb_logp, "SMB receive search dir count %d [%s]",
3240                                  maxCount, osi_LogSaveString(smb_logp, pathp));
3241
3242                 if (*pathp == 0) {      /* null pathp, treat as root dir */
3243                         if (!(attribute & SMB_ATTR_DIRECTORY))  /* exclude dirs */
3244                                 return CM_ERROR_NOFILES;
3245                         rootPath = 1;
3246                 }
3247
3248                 dsp = smb_NewDirSearch(0);
3249                 dsp->attribute = attribute;
3250                 smb_Get8Dot3MaskFromPath(mask, pathp);
3251                 memcpy(dsp->mask, mask, 11);
3252
3253                 /* track if this is likely to match a lot of entries */
3254                 if (smb_IsStarMask(mask)) starPattern = 1;
3255                 else starPattern = 0;
3256         }       
3257         else {
3258                 /* pull the next cookie value out of the search status block */
3259                 nextCookie = inCookiep[13] + (inCookiep[14]<<8) + (inCookiep[15]<<16)
3260                         + (inCookiep[16]<<24);
3261                 dsp = smb_FindDirSearch(inCookiep[12]);
3262                 if (!dsp) {
3263                         /* can't find dir search status; fatal error */
3264                         return CM_ERROR_BADFD;
3265                 }
3266                 attribute = dsp->attribute;
3267                 resByte = inCookiep[0];
3268
3269                 /* copy out client cookie, in host byte order.  Don't bother
3270                  * interpreting it, since we're just passing it through, anyway.
3271                  */
3272                 memcpy(&clientCookie, &inCookiep[17], 4);
3273
3274                 memcpy(mask, dsp->mask, 11);
3275
3276                 /* assume we're doing a star match if it has continued for more
3277                  * than one call.
3278                  */
3279                 starPattern = 1;
3280         }
3281
3282         osi_Log3(smb_logp, "SMB dir search cookie 0x%x, connection %d, attr 0x%x",
3283                          nextCookie, dsp->cookie, attribute);
3284
3285         userp = smb_GetUser(vcp, inp);
3286
3287         /* try to get the vnode for the path name next */
3288         lock_ObtainMutex(&dsp->mx);
3289         if (dsp->scp) {
3290                 scp = dsp->scp;
3291                 cm_HoldSCache(scp);
3292                 code = 0;
3293         }
3294         else {
3295                 spacep = inp->spacep;
3296                 smb_StripLastComponent(spacep->data, NULL, pathp);
3297                 lock_ReleaseMutex(&dsp->mx);
3298                 tidPathp = smb_GetTIDPath(vcp, ((smb_t *)inp)->tid);
3299                 code = cm_NameI(cm_rootSCachep, spacep->data,
3300                                                 caseFold | CM_FLAG_FOLLOW, userp, tidPathp, &req, &scp);
3301                 lock_ObtainMutex(&dsp->mx);
3302                 if (code == 0) {
3303                         if (dsp->scp != 0) cm_ReleaseSCache(dsp->scp);
3304                         dsp->scp = scp;
3305                         /* we need one hold for the entry we just stored into,
3306                          * and one for our own processing.  When we're done with this
3307                          * function, we'll drop the one for our own processing.
3308                          * We held it once from the namei call, and so we do another hold
3309                          * now.
3310                          */
3311                         cm_HoldSCache(scp);
3312                         lock_ObtainMutex(&scp->mx);
3313                         if ((scp->flags & CM_SCACHEFLAG_BULKSTATTING) == 0
3314                             && LargeIntegerGreaterOrEqualToZero(scp->bulkStatProgress)) {
3315                                 scp->flags |= CM_SCACHEFLAG_BULKSTATTING;
3316                                 dsp->flags |= SMB_DIRSEARCH_BULKST;
3317                         }
3318                         lock_ReleaseMutex(&scp->mx);
3319                 }
3320         }
3321         lock_ReleaseMutex(&dsp->mx);
3322         if (code) {
3323                 cm_ReleaseUser(userp);
3324                 smb_DeleteDirSearch(dsp);
3325                 smb_ReleaseDirSearch(dsp);
3326                 return code;
3327         }
3328
3329         /* reserves space for parameter; we'll adjust it again later to the
3330          * real count of the # of entries we returned once we've actually
3331          * assembled the directory listing.
3332          */
3333         smb_SetSMBParm(outp, 0, 0);
3334         
3335         /* get the directory size */
3336         lock_ObtainMutex(&scp->mx);
3337         code = cm_SyncOp(scp, NULL, userp, &req, 0,
3338                                          CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
3339         if (code) {
3340                 lock_ReleaseMutex(&scp->mx);
3341                 cm_ReleaseSCache(scp);
3342                 cm_ReleaseUser(userp);
3343                 smb_DeleteDirSearch(dsp);
3344                 smb_ReleaseDirSearch(dsp);
3345                 return code;
3346         }
3347         
3348         dirLength = scp->length;
3349         bufferp = NULL;
3350         bufferOffset.LowPart = bufferOffset.HighPart = 0;
3351         curOffset.HighPart = 0;
3352         curOffset.LowPart = nextCookie;
3353         origOp = op = smb_GetSMBData(outp, NULL);
3354         /* and write out the basic header */
3355         *op++ = 5;              /* variable block */
3356         op += 2;                /* skip vbl block length; we'll fill it in later */
3357         code = 0;
3358         returnedNames = 0;
3359         while (1) {
3360                 /* make sure that curOffset.LowPart doesn't point to the first
3361                  * 32 bytes in the 2nd through last dir page, and that it doesn't
3362                  * point at the first 13 32-byte chunks in the first dir page,
3363                  * since those are dir and page headers, and don't contain useful
3364                  * information.
3365                  */
3366                 temp = curOffset.LowPart & (2048-1);
3367                 if (curOffset.HighPart == 0 && curOffset.LowPart < 2048) {
3368                         /* we're in the first page */
3369                         if (temp < 13*32) temp = 13*32;
3370                 }
3371                 else {
3372                         /* we're in a later dir page */
3373                         if (temp < 32) temp = 32;
3374                 }
3375                 
3376                 /* make sure the low order 5 bits are zero */
3377                 temp &= ~(32-1);
3378
3379                 /* now put temp bits back ito curOffset.LowPart */
3380                 curOffset.LowPart &= ~(2048-1);
3381                 curOffset.LowPart |= temp;
3382
3383                 /* check if we've returned all the names that will fit in the
3384                  * response packet.
3385                  */
3386                 if (returnedNames >= maxCount) 
3387                         break;
3388                 
3389                 /* check if we've passed the dir's EOF */
3390                 if (LargeIntegerGreaterThanOrEqualTo(curOffset, dirLength)) break;
3391
3392                 /* see if we can use the bufferp we have now; compute in which page
3393                  * the current offset would be, and check whether that's the offset
3394                  * of the buffer we have.  If not, get the buffer.
3395                  */
3396                 thyper.HighPart = curOffset.HighPart;
3397                 thyper.LowPart = curOffset.LowPart & ~(buf_bufferSize-1);
3398                 if (!bufferp || !LargeIntegerEqualTo(thyper, bufferOffset)) {
3399                         /* wrong buffer */
3400                         if (bufferp) {
3401                                 buf_Release(bufferp);
3402                                 bufferp = NULL;
3403                         }       
3404                         lock_ReleaseMutex(&scp->mx);
3405                         lock_ObtainRead(&scp->bufCreateLock);
3406                         code = buf_Get(scp, &thyper, &bufferp);
3407                         lock_ReleaseRead(&scp->bufCreateLock);
3408
3409                         /* now, if we're doing a star match, do bulk fetching of all of 
3410                          * the status info for files in the dir.
3411                          */
3412                         if (starPattern) {
3413                                 smb_ApplyDirListPatches(&dirListPatchesp, userp,
3414                                                                                 &req);
3415                                 if ((dsp->flags & SMB_DIRSEARCH_BULKST)
3416                                     && LargeIntegerGreaterThanOrEqualTo(thyper, 
3417                                                                         scp->bulkStatProgress)) {
3418                                         /* Don't bulk stat if risking timeout */
3419                                         int now = GetCurrentTime();
3420                                         if (now - req.startTime > 5000) {
3421                                                 scp->bulkStatProgress = thyper;
3422                                                 scp->flags &= ~CM_SCACHEFLAG_BULKSTATTING;
3423                                                 dsp->flags &= ~SMB_DIRSEARCH_BULKST;
3424                                         } else
3425                                                 cm_TryBulkStat(scp, &thyper, userp, &req);
3426                                 }
3427                         }
3428
3429                         lock_ObtainMutex(&scp->mx);
3430                         if (code) 
3431                                 break;
3432                         bufferOffset = thyper;
3433
3434                         /* now get the data in the cache */
3435                         while (1) {
3436                                 code = cm_SyncOp(scp, bufferp, userp, &req,
3437                                                                   PRSFS_LOOKUP,
3438                                                                   CM_SCACHESYNC_NEEDCALLBACK
3439                                                                   | CM_SCACHESYNC_READ);
3440                                 if (code) break;
3441                                 
3442                                 if (cm_HaveBuffer(scp, bufferp, 0)) break;
3443
3444                                 /* otherwise, load the buffer and try again */
3445                                 code = cm_GetBuffer(scp, bufferp, NULL, userp,
3446                                                                         &req);
3447                                 if (code) break;
3448                         }
3449                         if (code) {
3450                                 buf_Release(bufferp);
3451                                 bufferp = NULL;
3452        &nb