2 * Copyright 2000, International Business Machines Corporation and others.
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
10 #include <afs/param.h>
15 #pragma warning(disable: 4005)
28 #include <rx/rx_prototypes.h>
29 #include <WINNT\afsreg.h>
32 #include "lanahelper.h"
34 #define STRSAFE_NO_DEPRECATE
37 /* These characters are illegal in Windows filenames */
38 static clientchar_t *illegalChars = _C("\\/:*?\"<>|");
40 static int smbShutdownFlag = 0;
41 static int smb_ListenerState = SMB_LISTENER_UNINITIALIZED;
43 int smb_LogoffTokenTransfer;
44 time_t smb_LogoffTransferTimeout;
46 int smb_StoreAnsiFilenames = 0;
48 DWORD last_msg_time = 0;
52 unsigned int sessionGen = 0;
54 extern void afsi_log(char *pattern, ...);
55 extern HANDLE afsi_file;
56 extern int powerStateSuspended;
58 osi_hyper_t hzero = {0, 0};
59 osi_hyper_t hones = {0xFFFFFFFF, -1};
62 osi_rwlock_t smb_globalLock;
63 osi_rwlock_t smb_rctLock;
64 osi_mutex_t smb_ListenerLock;
65 osi_mutex_t smb_StartedLock;
67 unsigned char smb_LANadapter = LANA_INVALID;
68 unsigned char smb_sharename[NCBNAMSZ+1] = {0};
69 int smb_LanAdapterChangeDetected = 0;
70 afs_uint32 smb_AsyncStore = 1;
71 afs_uint32 smb_AsyncStoreSize = CM_CONFIGDEFAULT_ASYNCSTORESIZE;
73 BOOL isGateway = FALSE;
76 long smb_maxObsConcurrentCalls=0;
77 long smb_concurrentCalls=0;
79 smb_dispatch_t smb_dispatchTable[SMB_NOPCODES];
81 smb_packet_t *smb_packetFreeListp;
82 smb_ncb_t *smb_ncbFreeListp;
84 afs_uint32 smb_NumServerThreads;
86 afs_uint32 numNCBs, numSessions, numVCs;
88 int smb_maxVCPerServer;
89 int smb_maxMpxRequests;
91 int smb_authType = SMB_AUTH_EXTENDED; /* type of SMB auth to use. One of SMB_AUTH_* */
93 ULONG smb_lsaSecPackage;
94 LSA_STRING smb_lsaLogonOrigin;
96 #define NCB_MAX MAXIMUM_WAIT_OBJECTS
97 EVENT_HANDLE NCBavails[NCB_MAX], NCBevents[NCB_MAX];
98 EVENT_HANDLE **NCBreturns;
99 EVENT_HANDLE **NCBShutdown;
100 EVENT_HANDLE *smb_ServerShutdown;
101 EVENT_HANDLE ListenerShutdown[256];
102 DWORD NCBsessions[NCB_MAX];
104 struct smb_packet *bufs[NCB_MAX];
106 #define SESSION_MAX MAXIMUM_WAIT_OBJECTS - 4
107 EVENT_HANDLE SessionEvents[SESSION_MAX];
108 unsigned short LSNs[SESSION_MAX];
109 int lanas[SESSION_MAX];
110 BOOL dead_sessions[SESSION_MAX];
113 osi_mutex_t smb_RawBufLock;
116 #define SMB_MASKFLAG_TILDE 1
117 #define SMB_MASKFLAG_CASEFOLD 2
119 #define RAWTIMEOUT INFINITE
122 typedef struct raw_write_cont {
131 /* dir search stuff */
132 long smb_dirSearchCounter = 1;
133 smb_dirSearch_t *smb_firstDirSearchp;
134 smb_dirSearch_t *smb_lastDirSearchp;
136 /* hide dot files? */
137 int smb_hideDotFiles;
139 /* Negotiate Unicode support? */
142 /* global state about V3 protocols */
143 int smb_useV3; /* try to negotiate V3 */
145 static int showErrors = 0;
146 /* MessageBox or something like it */
147 int (_stdcall *smb_MBfunc)(HWND, LPCTSTR, LPCTSTR, UINT)
151 * Time in Unix format of midnight, 1/1/1970 local time.
152 * When added to dosUTime, gives Unix (AFS) time.
154 time_t smb_localZero = 0;
156 #define USE_NUMERIC_TIME_CONV 1
158 #ifndef USE_NUMERIC_TIME_CONV
159 /* Time difference for converting to kludge-GMT */
160 afs_uint32 smb_NowTZ;
161 #endif /* USE_NUMERIC_TIME_CONV */
163 char *smb_localNamep = NULL;
165 smb_vc_t *smb_allVCsp;
166 smb_vc_t *smb_deadVCsp;
168 smb_username_t *usernamesp = NULL;
170 smb_waitingLockRequest_t *smb_allWaitingLocks;
172 DWORD smb_TlsRequestSlot = -1;
175 void smb_DispatchPacket(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp,
176 NCB *ncbp, raw_write_cont_t *rwcp);
177 int smb_NetbiosInit(int);
180 void smb_LogPacket(smb_packet_t *packet);
181 #endif /* LOG_PACKET */
183 clientchar_t smb_ServerDomainName[MAX_COMPUTERNAME_LENGTH + 1] = _C(""); /* domain name */
184 int smb_ServerDomainNameLength = 0;
185 clientchar_t smb_ServerOS[] = _C("Windows 5.0"); /* Faux OS String */
186 int smb_ServerOSLength = lengthof(smb_ServerOS);
187 clientchar_t smb_ServerLanManager[] = _C("Windows 2000 LAN Manager"); /* Faux LAN Manager string */
188 int smb_ServerLanManagerLength = lengthof(smb_ServerLanManager);
190 /* Faux server GUID. This is never checked. */
191 GUID smb_ServerGUID = { 0x40015cb8, 0x058a, 0x44fc, { 0xae, 0x7e, 0xbb, 0x29, 0x52, 0xee, 0x7e, 0xff }};
193 void smb_InitReq(cm_req_t *reqp)
196 reqp->flags |= CM_REQ_SOURCE_SMB;
199 void smb_ResetServerPriority()
201 void * p = TlsGetValue(smb_TlsRequestSlot);
204 TlsSetValue(smb_TlsRequestSlot, NULL);
205 SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_NORMAL);
209 void smb_SetRequestStartTime()
211 time_t * tp = TlsGetValue(smb_TlsRequestSlot);
213 tp = malloc(sizeof(time_t));
217 if (!TlsSetValue(smb_TlsRequestSlot, tp))
222 void smb_UpdateServerPriority()
224 time_t *tp = TlsGetValue(smb_TlsRequestSlot);
227 time_t now = osi_Time();
229 /* Give one priority boost for each 15 seconds */
230 SetThreadPriority(GetCurrentThread(), (int)((now - *tp) / 15));
235 const char * ncb_error_string(int code)
239 case 0x01: s = "NRC_BUFLEN llegal buffer length"; break;
240 case 0x03: s = "NRC_ILLCMD illegal command"; break;
241 case 0x05: s = "NRC_CMDTMO command timed out"; break;
242 case 0x06: s = "NRC_INCOMP message incomplete, issue another command"; break;
243 case 0x07: s = "NRC_BADDR illegal buffer address"; break;
244 case 0x08: s = "NRC_SNUMOUT session number out of range"; break;
245 case 0x09: s = "NRC_NORES no resource available"; break;
246 case 0x0a: s = "NRC_SCLOSED asession closed"; break;
247 case 0x0b: s = "NRC_CMDCAN command cancelled"; break;
248 case 0x0d: s = "NRC_DUPNAME duplicate name"; break;
249 case 0x0e: s = "NRC_NAMTFUL name table full"; break;
250 case 0x0f: s = "NRC_ACTSES no deletions, name has active sessions"; break;
251 case 0x11: s = "NRC_LOCTFUL local session table full"; break;
252 case 0x12: s = "NRC_REMTFUL remote session table full"; break;
253 case 0x13: s = "NRC_ILLNN illegal name number"; break;
254 case 0x14: s = "NRC_NOCALL no callname"; break;
255 case 0x15: s = "NRC_NOWILD cannot put * in NCB_NAME"; break;
256 case 0x16: s = "NRC_INUSE name in use on remote adapter"; break;
257 case 0x17: s = "NRC_NAMERR name deleted"; break;
258 case 0x18: s = "NRC_SABORT session ended abnormally"; break;
259 case 0x19: s = "NRC_NAMCONF name conflict detected"; break;
260 case 0x21: s = "NRC_IFBUSY interface busy, IRET before retrying"; break;
261 case 0x22: s = "NRC_TOOMANY too many commands outstanding, retry later";break;
262 case 0x23: s = "NRC_BRIDGE ncb_lana_num field invalid"; break;
263 case 0x24: s = "NRC_CANOCCR command completed while cancel occurring "; break;
264 case 0x26: s = "NRC_CANCEL command not valid to cancel"; break;
265 case 0x30: s = "NRC_DUPENV name defined by anther local process"; break;
266 case 0x34: s = "NRC_ENVNOTDEF xenvironment undefined. RESET required"; break;
267 case 0x35: s = "NRC_OSRESNOTAV required OS resources exhausted"; break;
268 case 0x36: s = "NRC_MAXAPPS max number of applications exceeded"; break;
269 case 0x37: s = "NRC_NOSAPS no saps available for netbios"; break;
270 case 0x38: s = "NRC_NORESOURCES requested resources are not available"; break;
271 case 0x39: s = "NRC_INVADDRESS invalid ncb address or length > segment"; break;
272 case 0x3B: s = "NRC_INVDDID invalid NCB DDID"; break;
273 case 0x3C: s = "NRC_LOCKFAILlock of user area failed"; break;
274 case 0x3f: s = "NRC_OPENERR NETBIOS not loaded"; break;
275 case 0x40: s = "NRC_SYSTEM system error"; break;
276 default: s = "unknown error";
282 char * myCrt_Dispatch(int i)
287 return "(00)ReceiveCoreMakeDir";
289 return "(01)ReceiveCoreRemoveDir";
291 return "(02)ReceiveCoreOpen";
293 return "(03)ReceiveCoreCreate";
295 return "(04)ReceiveCoreClose";
297 return "(05)ReceiveCoreFlush";
299 return "(06)ReceiveCoreUnlink";
301 return "(07)ReceiveCoreRename";
303 return "(08)ReceiveCoreGetFileAttributes";
305 return "(09)ReceiveCoreSetFileAttributes";
307 return "(0a)ReceiveCoreRead";
309 return "(0b)ReceiveCoreWrite";
311 return "(0c)ReceiveCoreLockRecord";
313 return "(0d)ReceiveCoreUnlockRecord";
315 return "(0e)SendCoreBadOp";
317 return "(0f)ReceiveCoreCreate";
319 return "(10)ReceiveCoreCheckPath";
321 return "(11)SendCoreBadOp";
323 return "(12)ReceiveCoreSeek";
325 return "(1a)ReceiveCoreReadRaw";
327 return "(1d)ReceiveCoreWriteRawDummy";
329 return "(22)ReceiveV3SetAttributes";
331 return "(23)ReceiveV3GetAttributes";
333 return "(24)ReceiveV3LockingX";
335 return "(25)ReceiveV3Trans";
337 return "(26)ReceiveV3Trans[aux]";
339 return "(29)SendCoreBadOp";
341 return "(2b)ReceiveCoreEcho";
343 return "(2d)ReceiveV3OpenX";
345 return "(2e)ReceiveV3ReadX";
347 return "(2f)ReceiveV3WriteX";
349 return "(32)ReceiveV3Tran2A";
351 return "(33)ReceiveV3Tran2A[aux]";
353 return "(34)ReceiveV3FindClose";
355 return "(35)ReceiveV3FindNotifyClose";
357 return "(70)ReceiveCoreTreeConnect";
359 return "(71)ReceiveCoreTreeDisconnect";
361 return "(72)ReceiveNegotiate";
363 return "(73)ReceiveV3SessionSetupX";
365 return "(74)ReceiveV3UserLogoffX";
367 return "(75)ReceiveV3TreeConnectX";
369 return "(80)ReceiveCoreGetDiskAttributes";
371 return "(81)ReceiveCoreSearchDir";
375 return "(83)FindUnique";
377 return "(84)FindClose";
379 return "(A0)ReceiveNTTransact";
381 return "(A2)ReceiveNTCreateX";
383 return "(A4)ReceiveNTCancel";
385 return "(A5)ReceiveNTRename";
387 return "(C0)OpenPrintFile";
389 return "(C1)WritePrintFile";
391 return "(C2)ClosePrintFile";
393 return "(C3)GetPrintQueue";
395 return "(D8)ReadBulk";
397 return "(D9)WriteBulk";
399 return "(DA)WriteBulkData";
401 return "unknown SMB op";
405 char * myCrt_2Dispatch(int i)
410 return "unknown SMB op-2";
412 return "S(00)CreateFile_ReceiveTran2Open";
414 return "S(01)FindFirst_ReceiveTran2SearchDir";
416 return "S(02)FindNext_ReceiveTran2SearchDir"; /* FindNext */
418 return "S(03)QueryFileSystem_ReceiveTran2QFSInfo";
420 return "S(04)SetFileSystem_ReceiveTran2SetFSInfo";
422 return "S(05)QueryPathInfo_ReceiveTran2QPathInfo";
424 return "S(06)SetPathInfo_ReceiveTran2SetPathInfo";
426 return "S(07)QueryFileInfo_ReceiveTran2QFileInfo";
428 return "S(08)SetFileInfo_ReceiveTran2SetFileInfo";
430 return "S(09)_ReceiveTran2FSCTL";
432 return "S(0a)_ReceiveTran2IOCTL";
434 return "S(0b)_ReceiveTran2FindNotifyFirst";
436 return "S(0c)_ReceiveTran2FindNotifyNext";
438 return "S(0d)_ReceiveTran2CreateDirectory";
440 return "S(0e)_ReceiveTran2SessionSetup";
442 return "S(0f)_QueryFileSystemInformationFid";
444 return "S(10)_ReceiveTran2GetDfsReferral";
446 return "S(11)_ReceiveTran2ReportDfsInconsistency";
450 char * myCrt_RapDispatch(int i)
455 return "unknown RAP OP";
457 return "RAP(0)NetShareEnum";
459 return "RAP(1)NetShareGetInfo";
461 return "RAP(13)NetServerGetInfo";
463 return "RAP(63)NetWkStaGetInfo";
467 /* scache must be locked */
468 unsigned int smb_Attributes(cm_scache_t *scp)
472 if ( scp->fileType == CM_SCACHETYPE_DIRECTORY ||
473 scp->fileType == CM_SCACHETYPE_MOUNTPOINT ||
474 scp->fileType == CM_SCACHETYPE_INVALID)
476 attrs = SMB_ATTR_DIRECTORY;
477 #ifdef SPECIAL_FOLDERS
478 attrs |= SMB_ATTR_SYSTEM; /* FILE_ATTRIBUTE_SYSTEM */
479 #endif /* SPECIAL_FOLDERS */
480 } else if (scp->fileType == CM_SCACHETYPE_DFSLINK) {
481 attrs = SMB_ATTR_DIRECTORY | SMB_ATTR_SPARSE_FILE;
486 * We used to mark a file RO if it was in an RO volume, but that
487 * turns out to be impolitic in NT. See defect 10007.
490 if ((scp->unixModeBits & 0222) == 0 || (scp->flags & CM_SCACHEFLAG_RO))
491 attrs |= SMB_ATTR_READONLY; /* turn on read-only flag */
493 if ((scp->unixModeBits & 0222) == 0)
494 attrs |= SMB_ATTR_READONLY; /* turn on read-only flag */
500 /* Check if the named file/dir is a dotfile/dotdir */
501 /* String pointed to by lastComp can have leading slashes, but otherwise should have
502 no other patch components */
503 unsigned int smb_IsDotFile(clientchar_t *lastComp) {
507 /* skip over slashes */
508 for(s=lastComp;*s && (*s == '\\' || *s == '/'); s++);
513 /* nulls, curdir and parent dir doesn't count */
519 if(*(s+1) == _C('.') && !*(s + 2))
526 static int ExtractBits(WORD bits, short start, short len)
533 num = bits << (16 - end);
534 num = num >> ((16 - end) + start);
539 void ShowUnixTime(char *FuncName, time_t unixTime)
544 smb_LargeSearchTimeFromUnixTime(&ft, unixTime);
546 if (!FileTimeToDosDateTime(&ft, &wDate, &wTime))
547 osi_Log1(smb_logp, "Failed to convert filetime to dos datetime: %d", GetLastError());
549 int day, month, year, sec, min, hour;
552 day = ExtractBits(wDate, 0, 5);
553 month = ExtractBits(wDate, 5, 4);
554 year = ExtractBits(wDate, 9, 7) + 1980;
556 sec = ExtractBits(wTime, 0, 5);
557 min = ExtractBits(wTime, 5, 6);
558 hour = ExtractBits(wTime, 11, 5);
560 sprintf(msg, "%s = %02d-%02d-%04d %02d:%02d:%02d", FuncName, month, day, year, hour, min, sec);
561 osi_Log1(smb_logp, "%s", osi_LogSaveString(smb_logp, msg));
565 /* Determine if we are observing daylight savings time */
566 void GetTimeZoneInfo(BOOL *pDST, LONG *pDstBias, LONG *pBias)
568 TIME_ZONE_INFORMATION timeZoneInformation;
569 SYSTEMTIME utc, local, localDST;
571 /* Get the time zone info. NT uses this to calc if we are in DST. */
572 GetTimeZoneInformation(&timeZoneInformation);
574 /* Return the daylight bias */
575 *pDstBias = timeZoneInformation.DaylightBias;
577 /* Return the bias */
578 *pBias = timeZoneInformation.Bias;
580 /* Now determine if DST is being observed */
582 /* Get the UTC (GMT) time */
585 /* Convert UTC time to local time using the time zone info. If we are
586 observing DST, the calculated local time will include this.
588 SystemTimeToTzSpecificLocalTime(&timeZoneInformation, &utc, &localDST);
590 /* Set the daylight bias to 0. The daylight bias is the amount of change
591 * in time that we use for daylight savings time. By setting this to 0
592 * we cause there to be no change in time during daylight savings time.
594 timeZoneInformation.DaylightBias = 0;
596 /* Convert the utc time to local time again, but this time without any
597 adjustment for daylight savings time.
599 SystemTimeToTzSpecificLocalTime(&timeZoneInformation, &utc, &local);
601 /* If the two times are different, then it means that the localDST that
602 we calculated includes the daylight bias, and therefore we are
603 observing daylight savings time.
605 *pDST = localDST.wHour != local.wHour;
609 void CompensateForSmbClientLastWriteTimeBugs(afs_uint32 *pLastWriteTime)
611 BOOL dst; /* Will be TRUE if observing DST */
612 LONG dstBias; /* Offset from local time if observing DST */
613 LONG bias; /* Offset from GMT for local time */
616 * This function will adjust the last write time to compensate
617 * for two bugs in the smb client:
619 * 1) During Daylight Savings Time, the LastWriteTime is ahead
620 * in time by the DaylightBias (ignoring the sign - the
621 * DaylightBias is always stored as a negative number). If
622 * the DaylightBias is -60, then the LastWriteTime will be
623 * ahead by 60 minutes.
625 * 2) If the local time zone is a positive offset from GMT, then
626 * the LastWriteTime will be the correct local time plus the
627 * Bias (ignoring the sign - a positive offset from GMT is
628 * always stored as a negative Bias). If the Bias is -120,
629 * then the LastWriteTime will be ahead by 120 minutes.
631 * These bugs can occur at the same time.
634 GetTimeZoneInfo(&dst, &dstBias, &bias);
636 /* First adjust for DST */
638 *pLastWriteTime -= (-dstBias * 60); /* Convert dstBias to seconds */
640 /* Now adjust for a positive offset from GMT (a negative bias). */
642 *pLastWriteTime -= (-bias * 60); /* Convert bias to seconds */
645 #ifndef USE_NUMERIC_TIME_CONV
647 * Calculate the difference (in seconds) between local time and GMT.
648 * This enables us to convert file times to kludge-GMT.
654 struct tm gmt_tm, local_tm;
655 int days, hours, minutes, seconds;
658 gmt_tm = *(gmtime(&t));
659 local_tm = *(localtime(&t));
661 days = local_tm.tm_yday - gmt_tm.tm_yday;
662 hours = 24 * days + local_tm.tm_hour - gmt_tm.tm_hour;
663 minutes = 60 * hours + local_tm.tm_min - gmt_tm.tm_min;
664 seconds = 60 * minutes + local_tm.tm_sec - gmt_tm.tm_sec;
668 #endif /* USE_NUMERIC_TIME_CONV */
670 #ifdef USE_NUMERIC_TIME_CONV
671 void smb_LargeSearchTimeFromUnixTime(FILETIME *largeTimep, time_t unixTime)
673 // Note that LONGLONG is a 64-bit value
676 ll = Int32x32To64(unixTime, 10000000) + 116444736000000000;
677 largeTimep->dwLowDateTime = (DWORD)(ll & 0xFFFFFFFF);
678 largeTimep->dwHighDateTime = (DWORD)(ll >> 32);
681 void smb_LargeSearchTimeFromUnixTime(FILETIME *largeTimep, time_t unixTime)
686 time_t ersatz_unixTime;
689 * Must use kludge-GMT instead of real GMT.
690 * kludge-GMT is computed by adding time zone difference to localtime.
693 * ltp = gmtime(&unixTime);
695 ersatz_unixTime = unixTime - smb_NowTZ;
696 ltp = localtime(&ersatz_unixTime);
698 /* if we fail, make up something */
701 localJunk.tm_year = 89 - 20;
702 localJunk.tm_mon = 4;
703 localJunk.tm_mday = 12;
704 localJunk.tm_hour = 0;
705 localJunk.tm_min = 0;
706 localJunk.tm_sec = 0;
709 stm.wYear = ltp->tm_year + 1900;
710 stm.wMonth = ltp->tm_mon + 1;
711 stm.wDayOfWeek = ltp->tm_wday;
712 stm.wDay = ltp->tm_mday;
713 stm.wHour = ltp->tm_hour;
714 stm.wMinute = ltp->tm_min;
715 stm.wSecond = ltp->tm_sec;
716 stm.wMilliseconds = 0;
718 SystemTimeToFileTime(&stm, largeTimep);
720 #endif /* USE_NUMERIC_TIME_CONV */
722 #ifdef USE_NUMERIC_TIME_CONV
723 void smb_UnixTimeFromLargeSearchTime(time_t *unixTimep, FILETIME *largeTimep)
725 // Note that LONGLONG is a 64-bit value
728 ll = largeTimep->dwHighDateTime;
730 ll += largeTimep->dwLowDateTime;
732 ll -= 116444736000000000;
735 *unixTimep = (DWORD)ll;
737 #else /* USE_NUMERIC_TIME_CONV */
738 void smb_UnixTimeFromLargeSearchTime(time_t *unixTimep, FILETIME *largeTimep)
744 FileTimeToSystemTime(largeTimep, &stm);
746 lt.tm_year = stm.wYear - 1900;
747 lt.tm_mon = stm.wMonth - 1;
748 lt.tm_wday = stm.wDayOfWeek;
749 lt.tm_mday = stm.wDay;
750 lt.tm_hour = stm.wHour;
751 lt.tm_min = stm.wMinute;
752 lt.tm_sec = stm.wSecond;
755 save_timezone = _timezone;
756 _timezone += smb_NowTZ;
757 *unixTimep = mktime(<);
758 _timezone = save_timezone;
760 #endif /* USE_NUMERIC_TIME_CONV */
762 void smb_SearchTimeFromUnixTime(afs_uint32 *searchTimep, time_t unixTime)
772 /* if we fail, make up something */
775 localJunk.tm_year = 89 - 20;
776 localJunk.tm_mon = 4;
777 localJunk.tm_mday = 12;
778 localJunk.tm_hour = 0;
779 localJunk.tm_min = 0;
780 localJunk.tm_sec = 0;
783 dosDate = ((ltp->tm_year-80)<<9) | ((ltp->tm_mon+1) << 5) | (ltp->tm_mday);
784 dosTime = (ltp->tm_hour<<11) | (ltp->tm_min << 5) | (ltp->tm_sec / 2);
785 *searchTimep = (dosDate<<16) | dosTime;
788 void smb_UnixTimeFromSearchTime(time_t *unixTimep, afs_uint32 searchTime)
790 unsigned short dosDate;
791 unsigned short dosTime;
794 dosDate = (unsigned short) (searchTime & 0xffff);
795 dosTime = (unsigned short) ((searchTime >> 16) & 0xffff);
797 localTm.tm_year = 80 + ((dosDate>>9) & 0x3f);
798 localTm.tm_mon = ((dosDate >> 5) & 0xf) - 1; /* January is 0 in localTm */
799 localTm.tm_mday = (dosDate) & 0x1f;
800 localTm.tm_hour = (dosTime>>11) & 0x1f;
801 localTm.tm_min = (dosTime >> 5) & 0x3f;
802 localTm.tm_sec = (dosTime & 0x1f) * 2;
803 localTm.tm_isdst = -1; /* compute whether DST in effect */
805 *unixTimep = mktime(&localTm);
808 void smb_DosUTimeFromUnixTime(afs_uint32 *dosUTimep, time_t unixTime)
810 time_t diff_t = unixTime - smb_localZero;
811 #if defined(DEBUG) && !defined(_USE_32BIT_TIME_T)
812 osi_assertx(diff_t < _UI32_MAX, "time_t > _UI32_MAX");
814 *dosUTimep = (afs_uint32)diff_t;
817 void smb_UnixTimeFromDosUTime(time_t *unixTimep, afs_uint32 dosTime)
819 *unixTimep = dosTime + smb_localZero;
822 void smb_MarkAllVCsDead(smb_vc_t * exclude)
825 smb_vc_t **vcp_to_cleanup = NULL;
826 int n_to_cleanup = 0;
829 osi_Log1(smb_logp, "Marking all VCs as dead excluding %p", exclude);
831 lock_ObtainWrite(&smb_globalLock); /* for dead_sessions[] */
832 lock_ObtainWrite(&smb_rctLock);
833 for (vcp = smb_allVCsp; vcp; vcp = vcp->nextp) {
835 if (vcp->magic != SMB_VC_MAGIC)
836 osi_panic("afsd: invalid smb_vc_t detected in smb_allVCsp",
842 lock_ObtainMutex(&vcp->mx);
843 if (!(vcp->flags & SMB_VCFLAG_ALREADYDEAD)) {
844 vcp->flags |= SMB_VCFLAG_ALREADYDEAD;
845 lock_ReleaseMutex(&vcp->mx);
846 dead_sessions[vcp->session] = TRUE;
848 lock_ReleaseMutex(&vcp->mx);
853 vcp_to_cleanup = malloc(sizeof(vcp_to_cleanup[0]) * n_to_cleanup);
855 for (vcp = smb_allVCsp; vcp; vcp = vcp->nextp) {
859 vcp_to_cleanup[i++] = vcp;
860 smb_HoldVCNoLock(vcp);
863 osi_assert(i == n_to_cleanup);
865 lock_ReleaseWrite(&smb_rctLock);
866 lock_ReleaseWrite(&smb_globalLock);
868 for (i=0; i < n_to_cleanup; i++) {
869 smb_CleanupDeadVC(vcp_to_cleanup[i]);
870 smb_ReleaseVC(vcp_to_cleanup[i]);
871 vcp_to_cleanup[i] = 0;
874 free(vcp_to_cleanup);
877 #ifdef DEBUG_SMB_REFCOUNT
878 smb_vc_t *smb_FindVCDbg(unsigned short lsn, int flags, int lana, char *file, long line)
880 smb_vc_t *smb_FindVC(unsigned short lsn, int flags, int lana)
885 lock_ObtainWrite(&smb_globalLock); /* for numVCs */
886 lock_ObtainWrite(&smb_rctLock);
887 for (vcp = smb_allVCsp; vcp; vcp=vcp->nextp) {
888 if (vcp->magic != SMB_VC_MAGIC)
889 osi_panic("afsd: invalid smb_vc_t detected in smb_allVCsp",
892 lock_ObtainMutex(&vcp->mx);
893 if (lsn == vcp->lsn && lana == vcp->lana &&
894 !(vcp->flags & SMB_VCFLAG_ALREADYDEAD)) {
895 lock_ReleaseMutex(&vcp->mx);
896 smb_HoldVCNoLock(vcp);
899 lock_ReleaseMutex(&vcp->mx);
901 if (!vcp && (flags & SMB_FLAG_CREATE)) {
902 vcp = malloc(sizeof(*vcp));
903 memset(vcp, 0, sizeof(*vcp));
904 vcp->vcID = ++numVCs;
905 vcp->magic = SMB_VC_MAGIC;
906 vcp->refCount = 2; /* smb_allVCsp and caller */
909 vcp->uidCounter = 1; /* UID 0 is reserved for blank user */
910 vcp->nextp = smb_allVCsp;
912 lock_InitializeMutex(&vcp->mx, "vc_t mutex", LOCK_HIERARCHY_SMB_VC);
917 if (smb_authType == SMB_AUTH_NTLM || smb_authType == SMB_AUTH_EXTENDED) {
918 /* We must obtain a challenge for extended auth
919 * in case the client negotiates smb v3
921 NTSTATUS nts = STATUS_UNSUCCESSFUL, ntsEx = STATUS_UNSUCCESSFUL;
922 MSV1_0_LM20_CHALLENGE_REQUEST lsaReq;
923 PMSV1_0_LM20_CHALLENGE_RESPONSE lsaResp = NULL;
924 ULONG lsaRespSize = 0;
926 lsaReq.MessageType = MsV1_0Lm20ChallengeRequest;
928 nts = LsaCallAuthenticationPackage( smb_lsaHandle,
935 if (nts != STATUS_SUCCESS || ntsEx != STATUS_SUCCESS) {
936 osi_Log4(smb_logp,"MsV1_0Lm20ChallengeRequest failure: nts 0x%x ntsEx 0x%x respSize is %u needs %u",
937 nts, ntsEx, sizeof(lsaReq), lsaRespSize);
938 afsi_log("MsV1_0Lm20ChallengeRequest failure: nts 0x%x ntsEx 0x%x respSize %u",
939 nts, ntsEx, lsaRespSize);
941 osi_assertx(nts == STATUS_SUCCESS, "LsaCallAuthenticationPackage failed"); /* this had better work! */
943 if (ntsEx == STATUS_SUCCESS) {
944 memcpy(vcp->encKey, lsaResp->ChallengeToClient, MSV1_0_CHALLENGE_LENGTH);
947 * This will cause the subsequent authentication to fail but
948 * that is better than us dereferencing a NULL pointer and
951 memset(vcp->encKey, 0, MSV1_0_CHALLENGE_LENGTH);
954 LsaFreeReturnBuffer(lsaResp);
957 memset(vcp->encKey, 0, MSV1_0_CHALLENGE_LENGTH);
959 if (numVCs >= CM_SESSION_RESERVED) {
961 osi_Log0(smb_logp, "WARNING: numVCs wrapping around");
964 #ifdef DEBUG_SMB_REFCOUNT
966 afsi_log("%s:%d smb_FindVC vcp 0x%p ref %d", file, line, vcp, vcp->refCount);
967 osi_Log4(smb_logp,"%s:%d smb_FindVC vcp 0x%p ref %d", file, line, vcp, vcp->refCount);
970 lock_ReleaseWrite(&smb_rctLock);
971 lock_ReleaseWrite(&smb_globalLock);
975 static int smb_Is8Dot3StarMask(clientchar_t *maskp)
980 for(i=0; i<11; i++) {
982 if (tc == _C('?') || tc == _C('*') || tc == _C('>'))
988 static int smb_IsStarMask(clientchar_t *maskp)
994 if (tc == _C('?') || tc == _C('*') || tc == _C('>'))
1000 #ifdef DEBUG_SMB_REFCOUNT
1001 void smb_ReleaseVCInternalDbg(smb_vc_t *vcp, char * file, long line)
1002 #define smb_ReleaseVCInternal(a) smb_ReleaseVCInternalDbg(a, file, line)
1004 void smb_ReleaseVCInternal(smb_vc_t *vcp)
1010 lock_AssertWrite(&smb_rctLock);
1013 if (vcp->refCount == 0) {
1014 if (vcp->flags & SMB_VCFLAG_ALREADYDEAD) {
1015 #ifdef DEBUG_SMB_REFCOUNT
1016 afsi_log("%s:%d smb_ReleaseVCInternal vcp 0x%p is dead ref %d", file, line, vcp, vcp->refCount);
1017 osi_Log4(smb_logp,"%s:%d smb_ReleaseVCInternal vcp 0x%p is dead ref %d", file, line, vcp, vcp->refCount);
1019 /* remove VCP from smb_deadVCsp */
1020 for (vcpp = &smb_deadVCsp; *vcpp; vcpp = &((*vcpp)->nextp)) {
1026 lock_FinalizeMutex(&vcp->mx);
1027 memset(vcp,0,sizeof(smb_vc_t));
1030 #ifdef DEBUG_SMB_REFCOUNT
1031 afsi_log("%s:%d smb_ReleaseVCInternal vcp 0x%p is alive ref %d", file, line, vcp, vcp->refCount);
1033 for (avcp = smb_allVCsp; avcp; avcp = avcp->nextp) {
1037 osi_Log3(smb_logp,"VCP not dead and %sin smb_allVCsp vcp %x ref %d",
1038 avcp?"":"not ",vcp, vcp->refCount);
1040 /* This is a wrong. However, I suspect that there is an undercount
1041 * and I don't want to release 1.4.1 in a state that will allow
1042 * smb_vc_t objects to be deallocated while still in the
1043 * smb_allVCsp list. The list is supposed to keep a reference
1044 * to the smb_vc_t. Put it back.
1048 #ifdef DEBUG_SMB_REFCOUNT
1049 afsi_log("%s:%d smb_ReleaseVCInternal vcp 0x%p is in smb_allVCsp ref %d", file, line, vcp, vcp->refCount);
1050 osi_Log4(smb_logp,"%s:%d smb_ReleaseVCInternal vcp 0x%p is in smb_allVCsp ref %d", file, line, vcp, vcp->refCount);
1054 } else if (vcp->flags & SMB_VCFLAG_ALREADYDEAD) {
1055 /* The reference count is non-zero but the VC is dead.
1056 * This implies that some FIDs, TIDs, etc on the VC have yet to
1057 * be cleaned up. If we were not called by smb_CleanupDeadVC(),
1058 * add a reference that will be dropped by
1059 * smb_CleanupDeadVC() and try to cleanup the VC again.
1060 * Eventually the refCount will drop to zero when all of the
1061 * active threads working with the VC end their task.
1063 if (!(vcp->flags & SMB_VCFLAG_CLEAN_IN_PROGRESS)) {
1064 vcp->refCount++; /* put the refCount back */
1065 lock_ReleaseWrite(&smb_rctLock);
1066 smb_CleanupDeadVC(vcp);
1067 #ifdef DEBUG_SMB_REFCOUNT
1068 afsi_log("%s:%d smb_ReleaseVCInternal vcp 0x%p after CleanupDeadVC ref %d", file, line, vcp, vcp->refCount);
1069 osi_Log4(smb_logp,"%s:%d smb_ReleaseVCInternal vcp 0x%p after CleanupDeadVC ref %d", file, line, vcp, vcp->refCount);
1071 lock_ObtainWrite(&smb_rctLock);
1074 #ifdef DEBUG_SMB_REFCOUNT
1075 afsi_log("%s:%d smb_ReleaseVCInternal vcp 0x%p ref %d", file, line, vcp, vcp->refCount);
1076 osi_Log4(smb_logp,"%s:%d smb_ReleaseVCInternal vcp 0x%p ref %d", file, line, vcp, vcp->refCount);
1081 #ifdef DEBUG_SMB_REFCOUNT
1082 void smb_ReleaseVCNoLockDbg(smb_vc_t *vcp, char * file, long line)
1084 void smb_ReleaseVCNoLock(smb_vc_t *vcp)
1087 lock_AssertWrite(&smb_rctLock);
1088 osi_Log2(smb_logp,"smb_ReleaseVCNoLock vcp %x ref %d",vcp, vcp->refCount);
1089 smb_ReleaseVCInternal(vcp);
1092 #ifdef DEBUG_SMB_REFCOUNT
1093 void smb_ReleaseVCDbg(smb_vc_t *vcp, char * file, long line)
1095 void smb_ReleaseVC(smb_vc_t *vcp)
1098 lock_ObtainWrite(&smb_rctLock);
1099 osi_Log2(smb_logp,"smb_ReleaseVC vcp %x ref %d",vcp, vcp->refCount);
1100 smb_ReleaseVCInternal(vcp);
1101 lock_ReleaseWrite(&smb_rctLock);
1104 #ifdef DEBUG_SMB_REFCOUNT
1105 void smb_HoldVCNoLockDbg(smb_vc_t *vcp, char * file, long line)
1107 void smb_HoldVCNoLock(smb_vc_t *vcp)
1110 lock_AssertWrite(&smb_rctLock);
1112 #ifdef DEBUG_SMB_REFCOUNT
1113 afsi_log("%s:%d smb_HoldVCNoLock vcp 0x%p ref %d", file, line, vcp, vcp->refCount);
1114 osi_Log4(smb_logp,"%s:%d smb_HoldVCNoLock vcp 0x%p ref %d", file, line, vcp, vcp->refCount);
1116 osi_Log2(smb_logp,"smb_HoldVCNoLock vcp %x ref %d",vcp, vcp->refCount);
1120 #ifdef DEBUG_SMB_REFCOUNT
1121 void smb_HoldVCDbg(smb_vc_t *vcp, char * file, long line)
1123 void smb_HoldVC(smb_vc_t *vcp)
1126 lock_ObtainWrite(&smb_rctLock);
1128 #ifdef DEBUG_SMB_REFCOUNT
1129 afsi_log("%s:%d smb_HoldVC vcp 0x%p ref %d", file, line, vcp, vcp->refCount);
1130 osi_Log4(smb_logp,"%s:%d smb_HoldVC vcp 0x%p ref %d", file, line, vcp, vcp->refCount);
1132 osi_Log2(smb_logp,"smb_HoldVC vcp %x ref %d",vcp, vcp->refCount);
1134 lock_ReleaseWrite(&smb_rctLock);
1137 void smb_CleanupDeadVC(smb_vc_t *vcp)
1139 smb_fid_t *fidpIter;
1140 smb_fid_t *fidpNext;
1142 smb_tid_t *tidpIter;
1143 smb_tid_t *tidpNext;
1145 smb_user_t *uidpIter;
1146 smb_user_t *uidpNext;
1148 afs_uint32 refCount = 0;
1150 lock_ObtainMutex(&vcp->mx);
1151 if (vcp->flags & SMB_VCFLAG_CLEAN_IN_PROGRESS) {
1152 lock_ReleaseMutex(&vcp->mx);
1153 osi_Log1(smb_logp, "Clean of dead vcp 0x%x in progress", vcp);
1156 vcp->flags |= SMB_VCFLAG_CLEAN_IN_PROGRESS;
1157 lock_ReleaseMutex(&vcp->mx);
1158 osi_Log1(smb_logp, "Cleaning up dead vcp 0x%x", vcp);
1160 lock_ObtainWrite(&smb_rctLock);
1161 /* remove VCP from smb_allVCsp */
1162 for (vcpp = &smb_allVCsp; *vcpp; vcpp = &((*vcpp)->nextp)) {
1163 if ((*vcpp)->magic != SMB_VC_MAGIC)
1164 osi_panic("afsd: invalid smb_vc_t detected in smb_allVCsp",
1165 __FILE__, __LINE__);
1168 vcp->nextp = smb_deadVCsp;
1170 /* Hold onto the reference until we are done with this function */
1175 for (fidpIter = vcp->fidsp; fidpIter; fidpIter = fidpNext) {
1176 fidpNext = (smb_fid_t *) osi_QNext(&fidpIter->q);
1178 if (fidpIter->deleteOk)
1181 fid = fidpIter->fid;
1182 osi_Log2(smb_logp, " Cleanup FID %d (fidp=0x%x)", fid, fidpIter);
1184 smb_HoldFIDNoLock(fidpIter);
1185 lock_ReleaseWrite(&smb_rctLock);
1187 smb_CloseFID(vcp, fidpIter, NULL, 0);
1188 smb_ReleaseFID(fidpIter);
1190 lock_ObtainWrite(&smb_rctLock);
1191 fidpNext = vcp->fidsp;
1194 for (tidpIter = vcp->tidsp; tidpIter; tidpIter = tidpNext) {
1195 tidpNext = tidpIter->nextp;
1196 if (tidpIter->deleteOk)
1198 tidpIter->deleteOk = 1;
1200 tid = tidpIter->tid;
1201 osi_Log2(smb_logp, " Cleanup TID %d (tidp=0x%x)", tid, tidpIter);
1203 smb_HoldTIDNoLock(tidpIter);
1204 smb_ReleaseTID(tidpIter, TRUE);
1205 tidpNext = vcp->tidsp;
1208 for (uidpIter = vcp->usersp; uidpIter; uidpIter = uidpNext) {
1209 uidpNext = uidpIter->nextp;
1210 if (uidpIter->deleteOk)
1212 uidpIter->deleteOk = 1;
1214 /* do not add an additional reference count for the smb_user_t
1215 * as the smb_vc_t already is holding a reference */
1216 lock_ReleaseWrite(&smb_rctLock);
1218 smb_ReleaseUID(uidpIter);
1220 lock_ObtainWrite(&smb_rctLock);
1221 uidpNext = vcp->usersp;
1224 /* The vcp is now on the deadVCsp list. We intentionally drop the
1225 * reference so that the refcount can reach 0 and we can delete it
1227 * If the refCount == 1 going into the ReleaseVCNoLock call
1228 * the object will be freed and it won't be safe to clear
1231 refCount = vcp->refCount;
1232 smb_ReleaseVCNoLock(vcp);
1234 lock_ObtainMutex(&vcp->mx);
1235 vcp->flags &= ~SMB_VCFLAG_CLEAN_IN_PROGRESS;
1236 lock_ReleaseMutex(&vcp->mx);
1239 lock_ReleaseWrite(&smb_rctLock);
1240 osi_Log1(smb_logp, "Finished cleaning up dead vcp 0x%x", vcp);
1243 #ifdef DEBUG_SMB_REFCOUNT
1244 smb_tid_t *smb_FindTIDDbg(smb_vc_t *vcp, unsigned short tid, int flags, char * file, long line)
1246 smb_tid_t *smb_FindTID(smb_vc_t *vcp, unsigned short tid, int flags)
1251 lock_ObtainWrite(&smb_rctLock);
1253 for (tidp = vcp->tidsp; tidp; tidp = tidp->nextp) {
1254 if (tidp->refCount == 0 && tidp->deleteOk) {
1256 smb_ReleaseTID(tidp, TRUE);
1260 if (tid == tidp->tid) {
1265 if (!tidp && (flags & SMB_FLAG_CREATE)) {
1266 tidp = malloc(sizeof(*tidp));
1267 memset(tidp, 0, sizeof(*tidp));
1268 tidp->nextp = vcp->tidsp;
1271 smb_HoldVCNoLock(vcp);
1273 lock_InitializeMutex(&tidp->mx, "tid_t mutex", LOCK_HIERARCHY_SMB_TID);
1276 #ifdef DEBUG_SMB_REFCOUNT
1278 afsi_log("%s:%d smb_FindTID tidp 0x%p ref %d", file, line, tidp, tidp->refCount);
1279 osi_Log4(smb_logp,"%s:%d smb_FindTID tidp 0x%p ref %d", file, line, tidp, tidp->refCount);
1282 lock_ReleaseWrite(&smb_rctLock);
1286 #ifdef DEBUG_SMB_REFCOUNT
1287 void smb_HoldTIDNoLockDbg(smb_tid_t *tidp, char * file, long line)
1289 void smb_HoldTIDNoLock(smb_tid_t *tidp)
1292 lock_AssertWrite(&smb_rctLock);
1294 #ifdef DEBUG_SMB_REFCOUNT
1295 afsi_log("%s:%d smb_HoldTIDNoLock tidp 0x%p ref %d", file, line, tidp, tidp->refCount);
1296 osi_Log4(smb_logp,"%s:%d smb_HoldTIDNoLock tidp 0x%p ref %d", file, line, tidp, tidp->refCount);
1300 #ifdef DEBUG_SMB_REFCOUNT
1301 void smb_ReleaseTIDDbg(smb_tid_t *tidp, afs_uint32 locked, char *file, long line)
1303 void smb_ReleaseTID(smb_tid_t *tidp, afs_uint32 locked)
1308 cm_user_t *userp = NULL;
1309 smb_vc_t *vcp = NULL;
1312 lock_ObtainWrite(&smb_rctLock);
1314 lock_AssertWrite(&smb_rctLock);
1316 osi_assertx(tidp->refCount-- > 0, "smb_tid_t refCount 0");
1317 #ifdef DEBUG_SMB_REFCOUNT
1318 afsi_log("%s:%d smb_ReleaseTID tidp 0x%p ref %d deleteOk %d", file, line, tidp, tidp->refCount, tidp->deleteOk);
1319 osi_Log5(smb_logp,"%s:%d smb_ReleaseTID tidp 0x%p ref %d deleteOk %d", file, line, tidp, tidp->refCount, tidp->deleteOk);
1321 if (tidp->refCount == 0) {
1322 if (tidp->deleteOk) {
1323 ltpp = &tidp->vcp->tidsp;
1324 for(tp = *ltpp; tp; ltpp = &tp->nextp, tp = *ltpp) {
1328 osi_assertx(tp != NULL, "null smb_tid_t");
1330 lock_FinalizeMutex(&tidp->mx);
1331 userp = tidp->userp; /* remember to drop ref later */
1339 lock_ReleaseWrite(&smb_rctLock);
1341 cm_ReleaseUser(userp);
1343 smb_ReleaseVCNoLock(vcp);
1346 smb_user_t *smb_FindUID(smb_vc_t *vcp, unsigned short uid, int flags)
1348 smb_user_t *uidp = NULL;
1350 lock_ObtainWrite(&smb_rctLock);
1351 for(uidp = vcp->usersp; uidp; uidp = uidp->nextp) {
1352 if (uid == uidp->userID) {
1354 osi_Log3(smb_logp, "smb_FindUID vcp[0x%p] found-uid[%d] name[%S]",
1356 ((uidp->unp)? osi_LogSaveClientString(smb_logp, uidp->unp->name):_C("")));
1360 if (!uidp && (flags & SMB_FLAG_CREATE)) {
1361 uidp = malloc(sizeof(*uidp));
1362 memset(uidp, 0, sizeof(*uidp));
1363 uidp->nextp = vcp->usersp;
1364 uidp->refCount = 2; /* one for the vcp and one for the caller */
1366 smb_HoldVCNoLock(vcp);
1368 lock_InitializeMutex(&uidp->mx, "user_t mutex", LOCK_HIERARCHY_SMB_UID);
1370 osi_Log3(smb_logp, "smb_FindUID vcp[0x%p] new-uid[%d] name[%S]",
1372 ((uidp->unp)?osi_LogSaveClientString(smb_logp,uidp->unp->name):_C("")));
1374 lock_ReleaseWrite(&smb_rctLock);
1378 smb_username_t *smb_FindUserByName(clientchar_t *usern, clientchar_t *machine,
1381 smb_username_t *unp= NULL;
1383 lock_ObtainWrite(&smb_rctLock);
1384 for(unp = usernamesp; unp; unp = unp->nextp) {
1385 if (cm_ClientStrCmpI(unp->name, usern) == 0 &&
1386 cm_ClientStrCmpI(unp->machine, machine) == 0) {
1391 if (!unp && (flags & SMB_FLAG_CREATE)) {
1392 unp = malloc(sizeof(*unp));
1393 memset(unp, 0, sizeof(*unp));
1395 unp->nextp = usernamesp;
1396 unp->name = cm_ClientStrDup(usern);
1397 unp->machine = cm_ClientStrDup(machine);
1399 lock_InitializeMutex(&unp->mx, "username_t mutex", LOCK_HIERARCHY_SMB_USERNAME);
1400 if (flags & SMB_FLAG_AFSLOGON)
1401 unp->flags = SMB_USERNAMEFLAG_AFSLOGON;
1404 lock_ReleaseWrite(&smb_rctLock);
1408 smb_user_t *smb_FindUserByNameThisSession(smb_vc_t *vcp, clientchar_t *usern)
1410 smb_user_t *uidp= NULL;
1412 lock_ObtainWrite(&smb_rctLock);
1413 for(uidp = vcp->usersp; uidp; uidp = uidp->nextp) {
1416 if (cm_stricmp_utf16(uidp->unp->name, usern) == 0) {
1418 osi_Log3(smb_logp,"smb_FindUserByNameThisSession vcp[0x%p] uid[%d] match-name[%S]",
1419 vcp,uidp->userID,osi_LogSaveClientString(smb_logp,usern));
1424 lock_ReleaseWrite(&smb_rctLock);
1428 void smb_ReleaseUsername(smb_username_t *unp)
1431 smb_username_t **lupp;
1432 cm_user_t *userp = NULL;
1433 time_t now = osi_Time();
1435 lock_ObtainWrite(&smb_rctLock);
1436 osi_assertx(unp->refCount-- > 0, "smb_username_t refCount 0");
1437 if (unp->refCount == 0 && !(unp->flags & SMB_USERNAMEFLAG_AFSLOGON) &&
1438 (unp->flags & SMB_USERNAMEFLAG_LOGOFF)) {
1440 for(up = *lupp; up; lupp = &up->nextp, up = *lupp) {
1444 osi_assertx(up != NULL, "null smb_username_t");
1446 up->nextp = NULL; /* do not remove this */
1447 lock_FinalizeMutex(&unp->mx);
1453 lock_ReleaseWrite(&smb_rctLock);
1455 cm_ReleaseUser(userp);
1458 void smb_HoldUIDNoLock(smb_user_t *uidp)
1460 lock_AssertWrite(&smb_rctLock);
1464 void smb_ReleaseUID(smb_user_t *uidp)
1468 smb_username_t *unp = NULL;
1470 lock_ObtainWrite(&smb_rctLock);
1471 osi_assertx(uidp->refCount-- > 0, "smb_user_t refCount 0");
1472 if (uidp->refCount == 0) {
1473 lupp = &uidp->vcp->usersp;
1474 for(up = *lupp; up; lupp = &up->nextp, up = *lupp) {
1478 osi_assertx(up != NULL, "null smb_user_t");
1480 lock_FinalizeMutex(&uidp->mx);
1482 smb_ReleaseVCNoLock(uidp->vcp);
1486 lock_ReleaseWrite(&smb_rctLock);
1490 cm_ReleaseUserVCRef(unp->userp);
1491 smb_ReleaseUsername(unp);
1495 cm_user_t *smb_GetUserFromUID(smb_user_t *uidp)
1497 cm_user_t *up = NULL;
1502 lock_ObtainMutex(&uidp->mx);
1504 up = uidp->unp->userp;
1507 lock_ReleaseMutex(&uidp->mx);
1513 /* retrieve a held reference to a user structure corresponding to an incoming
1515 * corresponding release function is cm_ReleaseUser.
1517 cm_user_t *smb_GetUserFromVCP(smb_vc_t *vcp, smb_packet_t *inp)
1520 cm_user_t *up = NULL;
1523 smbp = (smb_t *) inp;
1524 uidp = smb_FindUID(vcp, smbp->uid, 0);
1528 up = smb_GetUserFromUID(uidp);
1530 smb_ReleaseUID(uidp);
1535 * Return a pointer to a pathname extracted from a TID structure. The
1536 * TID structure is not held; assume it won't go away.
1538 long smb_LookupTIDPath(smb_vc_t *vcp, unsigned short tid, clientchar_t ** treepath)
1543 tidp = smb_FindTID(vcp, tid, 0);
1547 if (tidp->flags & SMB_TIDFLAG_IPC) {
1548 code = CM_ERROR_TIDIPC;
1549 /* tidp->pathname would be NULL, but that's fine */
1551 *treepath = tidp->pathname;
1552 smb_ReleaseTID(tidp, FALSE);
1557 /* check to see if we have a chained fid, that is, a fid that comes from an
1558 * OpenAndX message that ran earlier in this packet. In this case, the fid
1559 * field in a read, for example, request, isn't set, since the value is
1560 * supposed to be inherited from the openAndX call.
1562 int smb_ChainFID(int fid, smb_packet_t *inp)
1564 if (inp->fid == 0 || inp->inCount == 0)
1570 /* are we a priv'd user? What does this mean on NT? */
1571 int smb_SUser(cm_user_t *userp)
1576 /* find a file ID. If we pass in 0 we select an unused File ID.
1577 * If the SMB_FLAG_CREATE flag is set, we allocate a new
1578 * smb_fid_t data structure if desired File ID cannot be found.
1580 #ifdef DEBUG_SMB_REFCOUNT
1581 smb_fid_t *smb_FindFIDDbg(smb_vc_t *vcp, unsigned short fid, int flags, char *file, long line)
1583 smb_fid_t *smb_FindFID(smb_vc_t *vcp, unsigned short fid, int flags)
1589 if (fid == 0 && !(flags & SMB_FLAG_CREATE))
1592 lock_ObtainWrite(&smb_rctLock);
1593 /* figure out if we need to allocate a new file ID */
1596 fid = vcp->fidCounter;
1600 for(fidp = vcp->fidsp; fidp; fidp = (smb_fid_t *) osi_QNext(&fidp->q)) {
1601 if (fidp->refCount == 0 && fidp->deleteOk) {
1603 lock_ReleaseWrite(&smb_rctLock);
1604 smb_ReleaseFID(fidp);
1605 lock_ObtainWrite(&smb_rctLock);
1608 if (fid == fidp->fid) {
1611 if (fid == 0xFFFF) {
1613 "New FID number wraps on vcp 0x%x", vcp);
1623 if (!fidp && (flags & SMB_FLAG_CREATE)) {
1624 char eventName[MAX_PATH];
1626 sprintf(eventName,"fid_t event vcp=%d fid=%d", vcp->vcID, fid);
1627 event = thrd_CreateEvent(NULL, FALSE, TRUE, eventName);
1628 if ( GetLastError() == ERROR_ALREADY_EXISTS ) {
1629 osi_Log1(smb_logp, "Event Object Already Exists: %s", osi_LogSaveString(smb_logp, eventName));
1630 thrd_CloseHandle(event);
1632 if (fid == 0xFFFF) {
1633 osi_Log1(smb_logp, "New FID wraps around for vcp 0x%x", vcp);
1639 fidp = malloc(sizeof(*fidp));
1640 memset(fidp, 0, sizeof(*fidp));
1641 osi_QAdd((osi_queue_t **)&vcp->fidsp, &fidp->q);
1644 smb_HoldVCNoLock(vcp);
1645 lock_InitializeMutex(&fidp->mx, "fid_t mutex", LOCK_HIERARCHY_SMB_FID);
1647 fidp->curr_chunk = fidp->prev_chunk = -2;
1648 fidp->raw_write_event = event;
1650 vcp->fidCounter = fid+1;
1651 if (vcp->fidCounter == 0xFFFF) {
1652 osi_Log1(smb_logp, "fidCounter wrapped around for vcp 0x%x",
1654 vcp->fidCounter = 1;
1659 #ifdef DEBUG_SMB_REFCOUNT
1661 afsi_log("%s:%d smb_FindFID fidp 0x%p ref %d", file, line, fidp, fidp->refCount);
1662 osi_Log4(smb_logp,"%s:%d smb_FindFID fidp 0x%p ref %d", file, line, fidp, fidp->refCount);
1665 lock_ReleaseWrite(&smb_rctLock);
1670 /* Must not be called with scp->rw held because smb_ReleaseFID might be called */
1671 #ifdef DEBUG_SMB_REFCOUNT
1672 smb_fid_t *smb_FindFIDByScacheDbg(smb_vc_t *vcp, cm_scache_t * scp, char *file, long line)
1674 smb_fid_t *smb_FindFIDByScache(smb_vc_t *vcp, cm_scache_t * scp)
1677 smb_fid_t *fidp = NULL, *nextp = NULL;
1683 * If the fidp->scp changes out from under us then
1684 * we must not grab a refCount. It means the *fidp
1685 * was processed by smb_CloseFID() and the *fidp is
1686 * no longer valid for use.
1688 lock_ObtainWrite(&smb_rctLock);
1689 for(fidp = vcp->fidsp, (fidp ? fidp->refCount++ : 0); fidp; fidp = nextp, nextp = NULL) {
1690 nextp = (smb_fid_t *) osi_QNext(&fidp->q);
1694 if (scp == fidp->scp) {
1695 lock_ReleaseWrite(&smb_rctLock);
1696 lock_ObtainMutex(&fidp->mx);
1697 lock_ObtainWrite(&smb_rctLock);
1698 if (scp == fidp->scp) {
1699 lock_ReleaseMutex(&fidp->mx);
1702 lock_ReleaseMutex(&fidp->mx);
1705 if (fidp->refCount > 1) {
1708 lock_ReleaseWrite(&smb_rctLock);
1709 smb_ReleaseFID(fidp);
1710 lock_ObtainWrite(&smb_rctLock);
1715 if (nextp->refCount > 1) {
1718 lock_ReleaseWrite(&smb_rctLock);
1719 smb_ReleaseFID(nextp);
1720 lock_ObtainWrite(&smb_rctLock);
1724 #ifdef DEBUG_SMB_REFCOUNT
1726 afsi_log("%s:%d smb_FindFIDByScache fidp 0x%p ref %d", file, line, fidp, fidp->refCount);
1727 osi_Log4(smb_logp,"%s:%d smb_FindFIDByScache fidp 0x%p ref %d", file, line, fidp, fidp->refCount);
1730 lock_ReleaseWrite(&smb_rctLock);
1734 #ifdef DEBUG_SMB_REFCOUNT
1735 void smb_HoldFIDNoLockDbg(smb_fid_t *fidp, char *file, long line)
1737 void smb_HoldFIDNoLock(smb_fid_t *fidp)
1740 lock_AssertWrite(&smb_rctLock);
1742 #ifdef DEBUG_SMB_REFCOUNT
1743 afsi_log("%s:%d smb_HoldFIDNoLock fidp 0x%p ref %d", file, line, fidp, fidp->refCount);
1744 osi_Log4(smb_logp,"%s:%d smb_HoldFIDNoLock fidp 0x%p ref %d", file, line, fidp, fidp->refCount);
1749 /* smb_ReleaseFID cannot be called while a cm_scache_t rwlock is held */
1750 /* the smb_fid_t->mx and smb_rctLock must not be held */
1751 #ifdef DEBUG_SMB_REFCOUNT
1752 void smb_ReleaseFIDDbg(smb_fid_t *fidp, char *file, long line)
1754 void smb_ReleaseFID(smb_fid_t *fidp)
1757 cm_scache_t *scp = NULL;
1758 cm_user_t *userp = NULL;
1759 smb_vc_t *vcp = NULL;
1760 smb_ioctl_t *ioctlp;
1762 lock_ObtainMutex(&fidp->mx);
1763 lock_ObtainWrite(&smb_rctLock);
1764 osi_assertx(fidp->refCount-- > 0, "smb_fid_t refCount 0");
1765 #ifdef DEBUG_SMB_REFCOUNT
1766 afsi_log("%s:%d smb_ReleaseFID fidp 0x%p ref %d deleteOk %d", file, line, fidp, fidp->refCount, fidp->deleteOk);
1767 osi_Log5(smb_logp,"%s:%d smb_ReleaseFID fidp 0x%p ref %d deleteOk %d", file, line, fidp, fidp->refCount, fidp->deleteOk);
1769 if (fidp->refCount == 0) {
1770 if (fidp->deleteOk) {
1773 scp = fidp->scp; /* release after lock is released */
1775 lock_ObtainWrite(&scp->rw);
1776 scp->flags &= ~CM_SCACHEFLAG_SMB_FID;
1777 lock_ReleaseWrite(&scp->rw);
1778 osi_Log2(smb_logp,"smb_ReleaseFID fidp 0x%p scp 0x%p", fidp, scp);
1781 userp = fidp->userp;
1785 osi_QRemove((osi_queue_t **) &vcp->fidsp, &fidp->q);
1786 thrd_CloseHandle(fidp->raw_write_event);
1788 /* and see if there is ioctl stuff to free */
1789 ioctlp = fidp->ioctlp;
1792 cm_FreeSpace(ioctlp->prefix);
1793 if (ioctlp->ioctl.inAllocp)
1794 free(ioctlp->ioctl.inAllocp);
1795 if (ioctlp->ioctl.outAllocp)
1796 free(ioctlp->ioctl.outAllocp);
1799 lock_ReleaseMutex(&fidp->mx);
1800 lock_FinalizeMutex(&fidp->mx);
1805 smb_ReleaseVCNoLock(vcp);
1809 lock_ReleaseMutex(&fidp->mx);
1811 lock_ReleaseWrite(&smb_rctLock);
1813 /* now release the scache structure */
1815 cm_ReleaseSCache(scp);
1818 cm_ReleaseUser(userp);
1822 * Case-insensitive search for one string in another;
1823 * used to find variable names in submount pathnames.
1825 static clientchar_t *smb_stristr(clientchar_t *str1, clientchar_t *str2)
1827 clientchar_t *cursor;
1829 for (cursor = str1; *cursor; cursor++)
1830 if (cm_ClientStrCmpI(cursor, str2) == 0)
1837 * Substitute a variable value for its name in a submount pathname. Variable
1838 * name has been identified by smb_stristr() and is in substr. Variable name
1839 * length (plus one) is in substr_size. Variable value is in newstr.
1841 static void smb_subst(clientchar_t *str1, int cchstr1, clientchar_t *substr,
1842 unsigned int substr_size, clientchar_t *newstr)
1844 clientchar_t temp[1024];
1846 cm_ClientStrCpy(temp, lengthof(temp), substr + substr_size - 1);
1847 cm_ClientStrCpy(substr, cchstr1 - (substr - str1), newstr);
1848 cm_ClientStrCat(str1, cchstr1, temp);
1851 clientchar_t VNUserName[] = _C("%USERNAME%");
1852 clientchar_t VNLCUserName[] = _C("%LCUSERNAME%");
1853 clientchar_t VNComputerName[] = _C("%COMPUTERNAME%");
1854 clientchar_t VNLCComputerName[] = _C("%LCCOMPUTERNAME%");
1856 typedef struct smb_findShare_rock {
1857 clientchar_t * shareName;
1858 clientchar_t * match;
1860 } smb_findShare_rock_t;
1862 #define SMB_FINDSHARE_EXACT_MATCH 1
1863 #define SMB_FINDSHARE_PARTIAL_MATCH 2
1865 long smb_FindShareProc(cm_scache_t *scp, cm_dirEntry_t *dep, void *rockp,
1869 smb_findShare_rock_t * vrock = (smb_findShare_rock_t *) rockp;
1870 normchar_t normName[MAX_PATH];
1872 if (cm_FsStringToNormString(dep->name, -1, normName, sizeof(normName)/sizeof(normName[0])) == 0) {
1873 osi_Log1(smb_logp, "Skipping entry [%s]. Can't normalize FS string",
1874 osi_LogSaveString(smb_logp, dep->name));
1878 if (!cm_ClientStrCmpNI(normName, vrock->shareName, 12)) {
1879 if(!cm_ClientStrCmpI(normName, vrock->shareName))
1880 matchType = SMB_FINDSHARE_EXACT_MATCH;
1882 matchType = SMB_FINDSHARE_PARTIAL_MATCH;
1885 vrock->match = cm_FsStringToClientStringAlloc(dep->name, -1, NULL);
1886 vrock->matchType = matchType;
1888 if(matchType == SMB_FINDSHARE_EXACT_MATCH)
1889 return CM_ERROR_STOPNOW;
1895 /* find a shareName in the table of submounts */
1896 int smb_FindShare(smb_vc_t *vcp, smb_user_t *uidp,
1897 clientchar_t *shareName,
1898 clientchar_t **pathNamep)
1902 clientchar_t pathName[1024];
1905 clientchar_t *p, *q;
1906 fschar_t *cellname = NULL;
1909 DWORD allSubmount = 1;
1911 /* if allSubmounts == 0, only return the //mountRoot/all share
1912 * if in fact it has been been created in the subMounts table.
1913 * This is to allow sites that want to restrict access to the
1916 code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSREG_CLT_SVC_PARAM_SUBKEY,
1917 0, KEY_QUERY_VALUE, &parmKey);
1918 if (code == ERROR_SUCCESS) {
1919 cblen = sizeof(allSubmount);
1920 code = RegQueryValueEx(parmKey, "AllSubmount", NULL, NULL,
1921 (BYTE *) &allSubmount, &cblen);
1922 if (code != ERROR_SUCCESS) {
1925 RegCloseKey (parmKey);
1928 if (allSubmount && cm_ClientStrCmpI(shareName, _C("all")) == 0) {
1933 /* In case, the all share is disabled we need to still be able
1934 * to handle ioctl requests
1936 if (cm_ClientStrCmpI(shareName, _C("ioctl$")) == 0) {
1937 *pathNamep = cm_ClientStrDup(_C("/.__ioctl__"));
1941 if (cm_ClientStrCmpIA(shareName, _C("IPC$")) == 0 ||
1942 cm_ClientStrCmpIA(shareName, _C("srvsvc")) == 0 ||
1943 cm_ClientStrCmpIA(shareName, _C("wkssvc")) == 0 ||
1944 cm_ClientStrCmpIA(shareName, _C(SMB_IOCTL_FILENAME_NOSLASH)) == 0 ||
1945 cm_ClientStrCmpIA(shareName, _C("DESKTOP.INI")) == 0
1951 /* Check for volume references
1953 * They look like <cell>{%,#}<volume>
1955 if (cm_ClientStrChr(shareName, '%') != NULL ||
1956 cm_ClientStrChr(shareName, '#') != NULL) {
1957 clientchar_t pathstr[CELL_MAXNAMELEN + VL_MAXNAMELEN + 1 + CM_PREFIX_VOL_CCH];
1958 /* make room for '/@vol:' + mountchar + NULL terminator*/
1960 osi_Log1(smb_logp, "smb_FindShare found volume reference [%S]",
1961 osi_LogSaveClientString(smb_logp, shareName));
1963 cm_ClientStrPrintfN(pathstr, lengthof(pathstr),
1964 _C("/") _C(CM_PREFIX_VOL) _C("%s"), shareName);
1965 cchlen = (DWORD)(cm_ClientStrLen(pathstr) + 1);
1967 *pathNamep = malloc(cchlen * sizeof(clientchar_t));
1969 cm_ClientStrCpy(*pathNamep, cchlen, pathstr);
1970 cm_ClientStrLwr(*pathNamep);
1971 osi_Log1(smb_logp, " returning pathname [%S]",
1972 osi_LogSaveClientString(smb_logp, *pathNamep));
1980 code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSREG_CLT_OPENAFS_SUBKEY "\\Submounts",
1981 0, KEY_QUERY_VALUE, &parmKey);
1982 if (code == ERROR_SUCCESS) {
1983 cblen = sizeof(pathName);
1984 code = RegQueryValueExW(parmKey, shareName, NULL, NULL,
1985 (BYTE *) pathName, &cblen);
1986 if (code != ERROR_SUCCESS)
1988 RegCloseKey (parmKey);
1992 cchlen = cblen / sizeof(clientchar_t);
1993 if (cchlen != 0 && cchlen != lengthof(pathName) - 1) {
1994 /* We can accept either unix or PC style AFS pathnames. Convert
1995 * Unix-style to PC style here for internal use.
1998 cchlen = lengthof(pathName);
2000 /* within this code block, we maintain, cchlen = writeable
2001 buffer length of p */
2003 if (cm_ClientStrCmpN(p, cm_mountRootC, cm_mountRootCLen) == 0) {
2004 p += cm_mountRootCLen; /* skip mount path */
2005 cchlen -= (DWORD)(p - pathName);
2010 if (*q == _C('/')) *q = _C('\\'); /* change to \ */
2016 clientchar_t temp[1024];
2018 if (var = smb_stristr(p, VNUserName)) {
2019 if (uidp && uidp->unp)
2020 smb_subst(p, cchlen, var, lengthof(VNUserName),uidp->unp->name);
2022 smb_subst(p, cchlen, var, lengthof(VNUserName), _C(" "));
2024 else if (var = smb_stristr(p, VNLCUserName))
2026 if (uidp && uidp->unp)
2027 cm_ClientStrCpy(temp, lengthof(temp), uidp->unp->name);
2029 cm_ClientStrCpy(temp, lengthof(temp), _C(" "));
2030 cm_ClientStrLwr(temp);
2031 smb_subst(p, cchlen, var, lengthof(VNLCUserName), temp);
2033 else if (var = smb_stristr(p, VNComputerName))
2035 sizeTemp = lengthof(temp);
2036 GetComputerNameW(temp, &sizeTemp);
2037 smb_subst(p, cchlen, var, lengthof(VNComputerName), temp);
2039 else if (var = smb_stristr(p, VNLCComputerName))
2041 sizeTemp = lengthof(temp);
2042 GetComputerName((LPTSTR)temp, &sizeTemp);
2043 cm_ClientStrLwr(temp);
2044 smb_subst(p, cchlen, var, lengthof(VNLCComputerName), temp);
2049 *pathNamep = cm_ClientStrDup(p);
2054 /* First lookup shareName in root.afs */
2056 smb_findShare_rock_t vrock;
2058 fschar_t ftemp[1024];
2059 clientchar_t * p = shareName;
2062 /* attempt to locate a partial match in root.afs. This is because
2063 when using the ANSI RAP calls, the share name is limited to 13 chars
2064 and hence is truncated. Of course we prefer exact matches. */
2066 thyper.HighPart = 0;
2069 vrock.shareName = cm_ClientStringToNormStringAlloc(shareName, -1, NULL);
2070 if (vrock.shareName == NULL)
2073 vrock.matchType = 0;
2075 cm_HoldSCache(cm_data.rootSCachep);
2076 code = cm_ApplyDir(cm_data.rootSCachep, smb_FindShareProc, &vrock, &thyper,
2077 (uidp? (uidp->unp ? uidp->unp->userp : NULL) : NULL), &req, NULL);
2078 cm_ReleaseSCache(cm_data.rootSCachep);
2080 free(vrock.shareName);
2081 vrock.shareName = NULL;
2083 if (vrock.matchType) {
2084 cm_ClientStrPrintfN(pathName, lengthof(pathName), _C("/%s/"), vrock.match);
2085 *pathNamep = cm_ClientStrDup(cm_ClientStrLwr(pathName));
2090 /* if we get here, there was no match for the share in root.afs */
2091 /* so try to create \\<netbiosName>\<cellname> */
2096 /* Get the full name for this cell */
2097 cellname = cm_ClientStringToFsStringAlloc(p, -1, NULL);
2098 code = cm_SearchCellFile(cellname, ftemp, 0, 0);
2099 #ifdef AFS_AFSDB_ENV
2100 if (code && cm_dnsEnabled) {
2102 code = cm_SearchCellByDNS(cellname, ftemp, &ttl, 0, 0);
2108 /* construct the path */
2110 clientchar_t temp[1024];
2112 if (cm_FsStringToClientString(ftemp, -1, temp, 1024) != 0) {
2113 cm_ClientStrPrintfN(pathName, (int)lengthof(pathName),
2114 rw ? _C("/.%S/") : _C("/%S/"), temp);
2115 *pathNamep = cm_ClientStrDup(cm_ClientStrLwr(pathName));
2125 /* Client-side offline caching policy types */
2126 #define CSC_POLICY_MANUAL 0
2127 #define CSC_POLICY_DOCUMENTS 1
2128 #define CSC_POLICY_PROGRAMS 2
2129 #define CSC_POLICY_DISABLE 3
2131 int smb_FindShareCSCPolicy(clientchar_t *shareName)
2134 clientchar_t policy[1024];
2137 int retval = CSC_POLICY_MANUAL;
2139 RegCreateKeyEx( HKEY_LOCAL_MACHINE,
2140 AFSREG_CLT_OPENAFS_SUBKEY "\\CSCPolicy",
2143 REG_OPTION_NON_VOLATILE,
2149 len = sizeof(policy);
2150 if ( RegQueryValueExW( hkCSCPolicy, shareName, 0, &dwType, (LPBYTE) policy, &len ) ||
2152 retval = cm_ClientStrCmpIA(_C("all"),shareName) ? CSC_POLICY_MANUAL : CSC_POLICY_DISABLE;
2154 else if (cm_ClientStrCmpIA(policy, _C("documents")) == 0)
2156 retval = CSC_POLICY_DOCUMENTS;
2158 else if (cm_ClientStrCmpIA(policy, _C("programs")) == 0)
2160 retval = CSC_POLICY_PROGRAMS;
2162 else if (cm_ClientStrCmpIA(policy, _C("disable")) == 0)
2164 retval = CSC_POLICY_DISABLE;
2167 RegCloseKey(hkCSCPolicy);
2171 /* find a dir search structure by cookie value, and return it held.
2172 * Must be called with smb_globalLock held.
2174 smb_dirSearch_t *smb_FindDirSearchNoLock(long cookie)
2176 smb_dirSearch_t *dsp;
2178 for (dsp = smb_firstDirSearchp; dsp; dsp = (smb_dirSearch_t *) osi_QNext(&dsp->q)) {
2179 if (dsp->cookie == cookie) {
2180 if (dsp != smb_firstDirSearchp) {
2181 /* move to head of LRU queue, too, if we're not already there */
2182 if (smb_lastDirSearchp == (smb_dirSearch_t *) &dsp->q)
2183 smb_lastDirSearchp = (smb_dirSearch_t *) osi_QPrev(&dsp->q);
2184 osi_QRemove((osi_queue_t **) &smb_firstDirSearchp, &dsp->q);
2185 osi_QAdd((osi_queue_t **) &smb_firstDirSearchp, &dsp->q);
2186 if (!smb_lastDirSearchp)
2187 smb_lastDirSearchp = (smb_dirSearch_t *) &dsp->q;
2195 osi_Log1(smb_logp,"smb_FindDirSearch(%d) == NULL",cookie);
2196 for (dsp = smb_firstDirSearchp; dsp; dsp = (smb_dirSearch_t *) osi_QNext(&dsp->q)) {
2197 osi_Log1(smb_logp,"... valid id: %d", dsp->cookie);
2203 void smb_DeleteDirSearch(smb_dirSearch_t *dsp)
2205 lock_ObtainMutex(&dsp->mx);
2206 osi_Log3(smb_logp,"smb_DeleteDirSearch cookie %d dsp 0x%p scp 0x%p",
2207 dsp->cookie, dsp, dsp->scp);
2208 dsp->flags |= SMB_DIRSEARCH_DELETE;
2209 if (dsp->scp != NULL) {
2210 lock_ObtainWrite(&dsp->scp->rw);
2211 if (dsp->flags & SMB_DIRSEARCH_BULKST) {
2212 dsp->flags &= ~SMB_DIRSEARCH_BULKST;
2213 dsp->scp->flags &= ~CM_SCACHEFLAG_BULKSTATTING;
2214 dsp->scp->bulkStatProgress = hzero;
2216 lock_ReleaseWrite(&dsp->scp->rw);
2218 lock_ReleaseMutex(&dsp->mx);
2221 /* Must be called with the smb_globalLock held */
2222 void smb_ReleaseDirSearchNoLock(smb_dirSearch_t *dsp)
2224 cm_scache_t *scp = NULL;
2226 osi_assertx(dsp->refCount-- > 0, "cm_scache_t refCount 0");
2227 if (dsp->refCount == 0) {
2228 lock_ObtainMutex(&dsp->mx);
2229 if (dsp->flags & SMB_DIRSEARCH_DELETE) {
2230 if (&dsp->q == (osi_queue_t *) smb_lastDirSearchp)
2231 smb_lastDirSearchp = (smb_dirSearch_t *) osi_QPrev(&smb_lastDirSearchp->q);
2232 osi_QRemove((osi_queue_t **) &smb_firstDirSearchp, &dsp->q);
2233 lock_ReleaseMutex(&dsp->mx);
2234 lock_FinalizeMutex(&dsp->mx);
2236 osi_Log3(smb_logp,"smb_ReleaseDirSearch cookie %d dsp 0x%p scp 0x%p",
2237 dsp->cookie, dsp, scp);
2240 lock_ReleaseMutex(&dsp->mx);
2243 /* do this now to avoid spurious locking hierarchy creation */
2245 cm_ReleaseSCache(scp);
2248 void smb_ReleaseDirSearch(smb_dirSearch_t *dsp)
2250 lock_ObtainWrite(&smb_globalLock);
2251 smb_ReleaseDirSearchNoLock(dsp);
2252 lock_ReleaseWrite(&smb_globalLock);
2255 /* find a dir search structure by cookie value, and return it held */
2256 smb_dirSearch_t *smb_FindDirSearch(long cookie)
2258 smb_dirSearch_t *dsp;
2260 lock_ObtainWrite(&smb_globalLock);
2261 dsp = smb_FindDirSearchNoLock(cookie);
2262 lock_ReleaseWrite(&smb_globalLock);
2266 /* GC some dir search entries, in the address space expected by the specific protocol.
2267 * Must be called with smb_globalLock held; release the lock temporarily.
2269 #define SMB_DIRSEARCH_GCMAX 10 /* how many at once */
2270 void smb_GCDirSearches(int isV3)
2272 smb_dirSearch_t *prevp;
2273 smb_dirSearch_t *dsp;
2274 smb_dirSearch_t *victimsp[SMB_DIRSEARCH_GCMAX];
2278 victimCount = 0; /* how many have we got so far */
2279 for (dsp = smb_lastDirSearchp; dsp; dsp=prevp) {
2280 /* we'll move tp from queue, so
2283 prevp = (smb_dirSearch_t *) osi_QPrev(&dsp->q);
2284 /* if no one is using this guy, and we're either in the new protocol,
2285 * or we're in the old one and this is a small enough ID to be useful
2286 * to the old protocol, GC this guy.
2288 if (dsp->refCount == 0 && (isV3 || dsp->cookie <= 255)) {
2289 /* hold and delete */
2290 lock_ObtainMutex(&dsp->mx);
2291 dsp->flags |= SMB_DIRSEARCH_DELETE;
2292 lock_ReleaseMutex(&dsp->mx);
2293 victimsp[victimCount++] = dsp;
2297 /* don't do more than this */
2298 if (victimCount >= SMB_DIRSEARCH_GCMAX)
2302 /* now release them */
2303 for (i = 0; i < victimCount; i++) {
2304 smb_ReleaseDirSearchNoLock(victimsp[i]);
2308 /* function for allocating a dir search entry. We need these to remember enough context
2309 * since we don't get passed the path from call to call during a directory search.
2311 * Returns a held dir search structure, and bumps the reference count on the vnode,
2312 * since it saves a pointer to the vnode.
2314 smb_dirSearch_t *smb_NewDirSearch(int isV3)
2316 smb_dirSearch_t *dsp;
2322 lock_ObtainWrite(&smb_globalLock);
2325 /* what's the biggest ID allowed in this version of the protocol */
2326 /* TODO: do we really want a non v3 dir search request to wrap
2327 smb_dirSearchCounter? */
2328 maxAllowed = isV3 ? 65535 : 255;
2329 if (smb_dirSearchCounter > maxAllowed)
2330 smb_dirSearchCounter = 1;
2332 start = smb_dirSearchCounter;
2335 /* twice so we have enough tries to find guys we GC after one pass;
2336 * 10 extra is just in case I mis-counted.
2338 if (++counter > 2*maxAllowed+10)
2339 osi_panic("afsd: dir search cookie leak", __FILE__, __LINE__);
2341 if (smb_dirSearchCounter > maxAllowed) {
2342 smb_dirSearchCounter = 1;
2344 if (smb_dirSearchCounter == start) {
2346 smb_GCDirSearches(isV3);
2349 dsp = smb_FindDirSearchNoLock(smb_dirSearchCounter);
2351 /* don't need to watch for refcount zero and deleted, since
2352 * we haven't dropped the global lock.
2355 ++smb_dirSearchCounter;
2359 dsp = malloc(sizeof(*dsp));
2360 memset(dsp, 0, sizeof(*dsp));
2361 dsp->cookie = smb_dirSearchCounter;
2362 ++smb_dirSearchCounter;
2364 lock_InitializeMutex(&dsp->mx, "cm_dirSearch_t", LOCK_HIERARCHY_SMB_DIRSEARCH);
2365 dsp->lastTime = osi_Time();
2366 osi_QAdd((osi_queue_t **) &smb_firstDirSearchp, &dsp->q);
2367 if (!smb_lastDirSearchp)
2368 smb_lastDirSearchp = (smb_dirSearch_t *) &dsp->q;
2370 osi_Log2(smb_logp,"smb_NewDirSearch cookie %d dsp 0x%p",
2374 lock_ReleaseWrite(&smb_globalLock);
2378 static smb_packet_t *smb_GetPacket(void)
2382 lock_ObtainWrite(&smb_globalLock);
2383 tbp = smb_packetFreeListp;
2385 smb_packetFreeListp = tbp->nextp;
2386 lock_ReleaseWrite(&smb_globalLock);
2388 tbp = calloc(sizeof(*tbp),1);
2389 tbp->magic = SMB_PACKETMAGIC;
2392 tbp->resumeCode = 0;
2398 tbp->ncb_length = 0;
2401 tbp->stringsp = NULL;
2403 osi_assertx(tbp->magic == SMB_PACKETMAGIC, "invalid smb_packet_t magic");
2408 smb_packet_t *smb_CopyPacket(smb_packet_t *pkt)
2411 tbp = smb_GetPacket();
2412 memcpy(tbp, pkt, sizeof(smb_packet_t));
2413 tbp->wctp = tbp->data + (unsigned int)(pkt->wctp - pkt->data);
2414 tbp->stringsp = NULL;
2416 smb_HoldVC(tbp->vcp);
2420 static NCB *smb_GetNCB(void)
2425 lock_ObtainWrite(&smb_globalLock);
2426 tbp = smb_ncbFreeListp;
2428 smb_ncbFreeListp = tbp->nextp;
2429 lock_ReleaseWrite(&smb_globalLock);
2431 tbp = calloc(sizeof(*tbp),1);
2432 tbp->magic = SMB_NCBMAGIC;
2435 osi_assertx(tbp->magic == SMB_NCBMAGIC, "invalid smb_packet_t magic");
2437 memset(&tbp->ncb, 0, sizeof(NCB));
2442 static void FreeSMBStrings(smb_packet_t * pkt)
2447 for (s = pkt->stringsp; s; s = ns) {
2451 pkt->stringsp = NULL;
2454 void smb_FreePacket(smb_packet_t *tbp)
2456 smb_vc_t * vcp = NULL;
2457 osi_assertx(tbp->magic == SMB_PACKETMAGIC, "invalid smb_packet_t magic");
2459 lock_ObtainWrite(&smb_globalLock);
2460 tbp->nextp = smb_packetFreeListp;
2461 smb_packetFreeListp = tbp;
2462 tbp->magic = SMB_PACKETMAGIC;
2466 tbp->resumeCode = 0;
2472 tbp->ncb_length = 0;
2474 FreeSMBStrings(tbp);
2475 lock_ReleaseWrite(&smb_globalLock);
2481 static void smb_FreeNCB(NCB *bufferp)
2485 tbp = (smb_ncb_t *) bufferp;
2486 osi_assertx(tbp->magic == SMB_NCBMAGIC, "invalid smb_packet_t magic");
2488 lock_ObtainWrite(&smb_globalLock);
2489 tbp->nextp = smb_ncbFreeListp;
2490 smb_ncbFreeListp = tbp;
2491 lock_ReleaseWrite(&smb_globalLock);
2494 /* get a ptr to the data part of a packet, and its count */
2495 unsigned char *smb_GetSMBData(smb_packet_t *smbp, int *nbytesp)
2499 unsigned char *afterParmsp;
2501 parmBytes = *smbp->wctp << 1;
2502 afterParmsp = smbp->wctp + parmBytes + 1;
2504 dataBytes = afterParmsp[0] + (afterParmsp[1]<<8);
2505 if (nbytesp) *nbytesp = dataBytes;
2507 /* don't forget to skip the data byte count, since it follows
2508 * the parameters; that's where the "2" comes from below.
2510 return (unsigned char *) (afterParmsp + 2);
2513 /* must set all the returned parameters before playing around with the
2514 * data region, since the data region is located past the end of the
2515 * variable number of parameters.
2517 void smb_SetSMBDataLength(smb_packet_t *smbp, unsigned int dsize)
2519 unsigned char *afterParmsp;
2521 afterParmsp = smbp->wctp + ((*smbp->wctp)<<1) + 1;
2523 *afterParmsp++ = dsize & 0xff;
2524 *afterParmsp = (dsize>>8) & 0xff;
2527 /* return the parm'th parameter in the smbp packet */
2528 unsigned short smb_GetSMBParm(smb_packet_t *smbp, int parm)
2531 unsigned char *parmDatap;
2533 parmCount = *smbp->wctp;
2535 if (parm >= parmCount) {
2538 sprintf(s, "Bad SMB param %d out of %d, ncb len %d",
2539 parm, parmCount, smbp->ncb_length);
2540 osi_Log3(smb_logp,"Bad SMB param %d out of %d, ncb len %d",
2541 parm, parmCount, smbp->ncb_length);
2542 LogEvent(EVENTLOG_ERROR_TYPE, MSG_BAD_SMB_PARAM,
2543 __FILE__, __LINE__, parm, parmCount, smbp->ncb_length);
2544 osi_panic(s, __FILE__, __LINE__);
2546 parmDatap = smbp->wctp + (2*parm) + 1;
2548 return parmDatap[0] + (parmDatap[1] << 8);
2551 /* return the parm'th parameter in the smbp packet */
2552 unsigned char smb_GetSMBParmByte(smb_packet_t *smbp, int parm)
2555 unsigned char *parmDatap;
2557 parmCount = *smbp->wctp;
2559 if (parm >= parmCount) {
2562 sprintf(s, "Bad SMB param %d out of %d, ncb len %d",
2563 parm, parmCount, smbp->ncb_length);
2564 osi_Log3(smb_logp,"Bad SMB param %d out of %d, ncb len %d",
2565 parm, parmCount, smbp->ncb_length);
2566 LogEvent(EVENTLOG_ERROR_TYPE, MSG_BAD_SMB_PARAM,
2567 __FILE__, __LINE__, parm, parmCount, smbp->ncb_length);
2568 osi_panic(s, __FILE__, __LINE__);
2570 parmDatap = smbp->wctp + (2*parm) + 1;
2572 return parmDatap[0];
2575 /* return the parm'th parameter in the smbp packet */
2576 unsigned int smb_GetSMBParmLong(smb_packet_t *smbp, int parm)
2579 unsigned char *parmDatap;
2581 parmCount = *smbp->wctp;
2583 if (parm + 1 >= parmCount) {
2586 sprintf(s, "Bad SMB param %d out of %d, ncb len %d",
2587 parm, parmCount, smbp->ncb_length);
2588 osi_Log3(smb_logp,"Bad SMB param %d out of %d, ncb len %d",
2589 parm, parmCount, smbp->ncb_length);
2590 LogEvent(EVENTLOG_ERROR_TYPE, MSG_BAD_SMB_PARAM,
2591 __FILE__, __LINE__, parm, parmCount, smbp->ncb_length);
2592 osi_panic(s, __FILE__, __LINE__);
2594 parmDatap = smbp->wctp + (2*parm) + 1;
2596 return parmDatap[0] + (parmDatap[1] << 8) + (parmDatap[2] << 16) + (parmDatap[3] << 24);
2599 /* return the parm'th parameter in the smbp packet */
2600 unsigned int smb_GetSMBOffsetParm(smb_packet_t *smbp, int parm, int offset)
2603 unsigned char *parmDatap;
2605 parmCount = *smbp->wctp;
2607 if (parm * 2 + offset >= parmCount * 2) {
2610 sprintf(s, "Bad SMB param %d offset %d out of %d, ncb len %d",
2611 parm, offset, parmCount, smbp->ncb_length);
2612 LogEvent(EVENTLOG_ERROR_TYPE, MSG_BAD_SMB_PARAM_WITH_OFFSET,
2613 __FILE__, __LINE__, parm, offset, parmCount, smbp->ncb_length);
2614 osi_Log4(smb_logp, "Bad SMB param %d offset %d out of %d, ncb len %d",
2615 parm, offset, parmCount, smbp->ncb_length);
2616 osi_panic(s, __FILE__, __LINE__);
2618 parmDatap = smbp->wctp + (2*parm) + 1 + offset;
2620 return parmDatap[0] + (parmDatap[1] << 8);
2623 void smb_SetSMBParm(smb_packet_t *smbp, int slot, unsigned int parmValue)
2625 unsigned char *parmDatap;
2627 /* make sure we have enough slots */
2628 if (*smbp->wctp <= slot)
2629 *smbp->wctp = slot+1;
2631 parmDatap = smbp->wctp + 2*slot + 1 + smbp->oddByte;
2632 *parmDatap++ = parmValue & 0xff;
2633 *parmDatap = (parmValue>>8) & 0xff;
2636 void smb_SetSMBParmLong(smb_packet_t *smbp, int slot, unsigned int parmValue)
2638 unsigned char *parmDatap;
2640 /* make sure we have enough slots */
2641 if (*smbp->wctp <= slot)
2642 *smbp->wctp = slot+2;
2644 parmDatap = smbp->wctp + 2*slot + 1 + smbp->oddByte;
2645 *parmDatap++ = parmValue & 0xff;
2646 *parmDatap++ = (parmValue>>8) & 0xff;
2647 *parmDatap++ = (parmValue>>16) & 0xff;
2648 *parmDatap = (parmValue>>24) & 0xff;
2651 void smb_SetSMBParmDouble(smb_packet_t *smbp, int slot, char *parmValuep)
2653 unsigned char *parmDatap;
2656 /* make sure we have enough slots */
2657 if (*smbp->wctp <= slot)
2658 *smbp->wctp = slot+4;
2660 parmDatap = smbp->wctp + 2*slot + 1 + smbp->oddByte;
2662 *parmDatap++ = *parmValuep++;
2665 void smb_SetSMBParmByte(smb_packet_t *smbp, int slot, unsigned int parmValue)
2667 unsigned char *parmDatap;
2669 /* make sure we have enough slots */
2670 if (*smbp->wctp <= slot) {
2671 if (smbp->oddByte) {
2673 *smbp->wctp = slot+1;
2678 parmDatap = smbp->wctp + 2*slot + 1 + (1 - smbp->oddByte);
2679 *parmDatap++ = parmValue & 0xff;
2684 void smb_StripLastComponent(clientchar_t *outPathp, clientchar_t **lastComponentp,
2685 clientchar_t *inPathp)
2687 clientchar_t *lastSlashp;
2689 lastSlashp = cm_ClientStrRChr(inPathp, '\\');
2691 *lastComponentp = lastSlashp;
2694 if (inPathp == lastSlashp)
2696 *outPathp++ = *inPathp++;
2705 clientchar_t *smb_ParseASCIIBlock(smb_packet_t * pktp, unsigned char *inp,
2706 char **chainpp, int flags)
2709 afs_uint32 type = *inp++;
2712 * The first byte specifies the type of the input string.
2713 * CIFS TR 1.0 3.2.10. This function only parses null terminated
2717 /* Length Counted */
2718 case 0x1: /* Data Block */
2719 case 0x5: /* Variable Block */
2720 cb = *inp++ << 16 | *inp++;
2723 /* Null-terminated string */
2724 case 0x4: /* ASCII */
2725 case 0x3: /* Pathname */
2726 case 0x2: /* Dialect */
2727 cb = sizeof(pktp->data) - (inp - pktp->data);
2728 if (inp < pktp->data || inp >= pktp->data + sizeof(pktp->data)) {
2729 #ifdef DEBUG_UNICODE
2732 cb = sizeof(pktp->data);
2737 return NULL; /* invalid input */
2741 if (type == 0x2 /* Dialect */ || !WANTS_UNICODE(pktp))
2742 flags |= SMB_STRF_FORCEASCII;
2745 return smb_ParseStringBuf(pktp->data, &pktp->stringsp, inp, &cb, chainpp, flags);
2748 clientchar_t *smb_ParseString(smb_packet_t * pktp, unsigned char * inp,
2749 char ** chainpp, int flags)
2754 if (!WANTS_UNICODE(pktp))
2755 flags |= SMB_STRF_FORCEASCII;
2758 cb = sizeof(pktp->data) - (inp - pktp->data);
2759 if (inp < pktp->data || inp >= pktp->data + sizeof(pktp->data)) {
2760 #ifdef DEBUG_UNICODE
2763 cb = sizeof(pktp->data);
2765 return smb_ParseStringBuf(pktp->data, &pktp->stringsp, inp, &cb, chainpp,
2766 flags | SMB_STRF_SRCNULTERM);
2769 clientchar_t *smb_ParseStringCb(smb_packet_t * pktp, unsigned char * inp,
2770 size_t cb, char ** chainpp, int flags)
2773 if (!WANTS_UNICODE(pktp))
2774 flags |= SMB_STRF_FORCEASCII;
2777 return smb_ParseStringBuf(pktp->data, &pktp->stringsp, inp, &cb, chainpp, flags);
2780 clientchar_t *smb_ParseStringCch(smb_packet_t * pktp, unsigned char * inp,
2781 size_t cch, char ** chainpp, int flags)
2786 if (!WANTS_UNICODE(pktp))
2787 flags |= SMB_STRF_FORCEASCII;
2789 cb = cch * sizeof(wchar_t);
2792 return smb_ParseStringBuf(pktp->data, &pktp->stringsp, inp, &cb, chainpp, flags);
2796 smb_ParseStringBuf(const unsigned char * bufbase,
2797 cm_space_t ** stringspp,
2798 unsigned char *inp, size_t *pcb_max,
2799 char **chainpp, int flags)
2802 if (!(flags & SMB_STRF_FORCEASCII)) {
2804 cm_space_t * spacep;
2807 if (bufbase && ((inp - bufbase) % 2) != 0) {
2808 inp++; /* unicode strings are always word aligned */
2812 if (FAILED(StringCchLengthW((const wchar_t *) inp, *pcb_max / sizeof(wchar_t),
2814 cch_src = *pcb_max / sizeof(wchar_t);
2818 *pcb_max -= (cch_src + 1) * sizeof(wchar_t);
2825 spacep = cm_GetSpace();
2826 spacep->nextp = *stringspp;
2827 *stringspp = spacep;
2831 *chainpp = inp + sizeof(wchar_t);
2834 *(spacep->wdata) = 0;
2835 return spacep->wdata;
2838 StringCchCopyNW(spacep->wdata,
2839 lengthof(spacep->wdata),
2840 (const clientchar_t *) inp, cch_src);
2843 *chainpp = inp + (cch_src + null_terms)*sizeof(wchar_t);
2845 return spacep->wdata;
2849 cm_space_t * spacep;
2852 /* Not using Unicode */
2854 *chainpp = inp + strlen(inp) + 1;
2857 spacep = cm_GetSpace();
2858 spacep->nextp = *stringspp;
2859 *stringspp = spacep;
2861 cchdest = lengthof(spacep->wdata);
2862 cm_Utf8ToUtf16(inp, (int)((flags & SMB_STRF_SRCNULTERM)? -1 : *pcb_max),
2863 spacep->wdata, cchdest);
2865 return spacep->wdata;
2871 unsigned char * smb_UnparseString(smb_packet_t * pktp, unsigned char * outp,
2873 size_t * plen, int flags)
2879 /* we are only calculating the required size */
2886 if (WANTS_UNICODE(pktp) && !(flags & SMB_STRF_FORCEASCII)) {
2888 StringCbLengthW(str, SMB_STRINGBUFSIZE * sizeof(wchar_t), plen);
2889 if (!(flags & SMB_STRF_IGNORENUL))
2890 *plen += sizeof(wchar_t);
2892 return (unsigned char *) 1; /* return TRUE if we are using unicode */
2902 cch_str = cm_ClientStrLen(str);
2903 cch_dest = cm_ClientStringToUtf8(str, (int)cch_str, NULL, 0);
2906 *plen = ((flags & SMB_STRF_IGNORENUL)? cch_dest: cch_dest+1);
2914 /* if outp != NULL ... */
2916 /* Number of bytes left in the buffer.
2918 If outp lies inside the packet data buffer, we assume that the
2919 buffer is the packet data buffer. Otherwise we assume that the
2920 buffer is sizeof(packet->data).
2923 if (outp >= pktp->data && outp < pktp->data + sizeof(pktp->data)) {
2924 align = (int)((outp - pktp->data) % 2);
2925 buffersize = (pktp->data + sizeof(pktp->data)) - ((char *) outp);
2927 align = (int)(((size_t) outp) % 2);
2928 buffersize = (int)sizeof(pktp->data);
2933 if (WANTS_UNICODE(pktp) && !(flags & SMB_STRF_FORCEASCII)) {
2939 if (*str == _C('\0')) {
2941 if (buffersize < sizeof(wchar_t))
2944 *((wchar_t *) outp) = L'\0';
2945 if (plen && !(flags & SMB_STRF_IGNORENUL))
2946 *plen += sizeof(wchar_t);
2947 return outp + sizeof(wchar_t);
2950 nchars = cm_ClientStringToUtf16(str, -1, (wchar_t *) outp, (int)(buffersize / sizeof(wchar_t)));
2952 osi_Log2(smb_logp, "UnparseString: Can't convert string to Unicode [%S], GLE=%d",
2953 osi_LogSaveClientString(smb_logp, str),
2959 *plen += sizeof(wchar_t) * ((flags & SMB_STRF_IGNORENUL)? nchars - 1: nchars);
2961 return outp + sizeof(wchar_t) * nchars;
2969 cch_dest = cm_ClientStringToUtf8(str, -1, outp, (int)buffersize);
2972 *plen += ((flags & SMB_STRF_IGNORENUL)? cch_dest - 1: cch_dest);
2974 return outp + cch_dest;
2978 unsigned char *smb_ParseVblBlock(unsigned char *inp, char **chainpp, int *lengthp)
2984 tlen = inp[0] + (inp[1]<<8);
2985 inp += 2; /* skip length field */
2988 *chainpp = inp + tlen;
2997 unsigned char *smb_ParseDataBlock(unsigned char *inp, char **chainpp, int *lengthp)
3001 if (*inp++ != 0x1) return NULL;
3002 tlen = inp[0] + (inp[1]<<8);
3003 inp += 2; /* skip length field */
3006 *chainpp = inp + tlen;
3009 if (lengthp) *lengthp = tlen;
3014 /* format a packet as a response */
3015 void smb_FormatResponsePacket(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *op)
3020 outp = (smb_t *) op;
3022 /* zero the basic structure through the smb_wct field, and zero the data
3023 * size field, assuming that wct stays zero; otherwise, you have to
3024 * explicitly set the data size field, too.
3026 inSmbp = (smb_t *) inp;
3027 memset(outp, 0, sizeof(smb_t)+2);
3033 outp->com = inSmbp->com;
3034 outp->tid = inSmbp->tid;
3035 outp->pid = inSmbp->pid;
3036 outp->uid = inSmbp->uid;
3037 outp->mid = inSmbp->mid;
3038 outp->res[0] = inSmbp->res[0];
3039 outp->res[1] = inSmbp->res[1];
3040 op->inCom = inSmbp->com;
3042 outp->reb = SMB_FLAGS_SERVER_TO_CLIENT;
3043 #ifdef SEND_CANONICAL_PATHNAMES
3044 outp->reb |= SMB_FLAGS_CANONICAL_PATHNAMES;
3046 outp->flg2 = SMB_FLAGS2_KNOWS_LONG_NAMES;
3048 if ((vcp->flags & SMB_VCFLAG_USEUNICODE) == SMB_VCFLAG_USEUNICODE)
3049 outp->flg2 |= SMB_FLAGS2_UNICODE;
3052 /* copy fields in generic packet area */
3053 op->wctp = &outp->wct;
3056 /* send a (probably response) packet; vcp tells us to whom to send it.
3057 * we compute the length by looking at wct and bcc fields.
3059 void smb_SendPacket(smb_vc_t *vcp, smb_packet_t *inp)
3069 ncbp = smb_GetNCB();
3073 memset((char *)ncbp, 0, sizeof(NCB));
3075 extra = 2 * (*inp->wctp); /* space used by parms, in bytes */
3076 tp = inp->wctp + 1+ extra; /* points to count of data bytes */
3077 extra += tp[0] + (tp[1]<<8);
3078 extra += (unsigned int)(inp->wctp - inp->data); /* distance to last wct field */
3079 extra += 3; /* wct and length fields */
3081 ncbp->ncb_length = extra; /* bytes to send */
3082 ncbp->ncb_lsn = (unsigned char) vcp->lsn; /* vc to use */
3083 ncbp->ncb_lana_num = vcp->lana;
3084 ncbp->ncb_command = NCBSEND; /* op means send data */
3085 ncbp->ncb_buffer = (char *) inp;/* packet */
3086 code = Netbios(ncbp);
3089 const char * s = ncb_error_string(code);
3090 osi_Log2(smb_logp, "SendPacket failure code %d \"%s\"", code, s);
3091 LogEvent(EVENTLOG_WARNING_TYPE, MSG_SMB_SEND_PACKET_FAILURE, s);
3093 lock_ObtainMutex(&vcp->mx);
3094 if (!(vcp->flags & SMB_VCFLAG_ALREADYDEAD)) {
3095 osi_Log2(smb_logp, "marking dead vcp 0x%x, user struct 0x%x",
3097 vcp->flags |= SMB_VCFLAG_ALREADYDEAD;
3098 lock_ReleaseMutex(&vcp->mx);
3099 lock_ObtainWrite(&smb_globalLock);
3100 dead_sessions[vcp->session] = TRUE;
3101 lock_ReleaseWrite(&smb_globalLock);
3102 smb_CleanupDeadVC(vcp);
3104 lock_ReleaseMutex(&vcp->mx);
3112 void smb_MapNTError(long code, unsigned long *NTStatusp)
3114 unsigned long NTStatus;
3116 /* map CM_ERROR_* errors to NT 32-bit status codes */
3117 /* NT Status codes are listed in ntstatus.h not winerror.h */
3121 else if (code == CM_ERROR_NOSUCHCELL) {
3122 NTStatus = 0xC000000FL; /* No such file */
3124 else if (code == CM_ERROR_NOSUCHVOLUME) {
3125 NTStatus = 0xC000000FL; /* No such file */
3127 else if (code == CM_ERROR_TIMEDOUT) {
3129 NTStatus = 0xC00000CFL; /* Sharing Paused */
3131 NTStatus = 0x00000102L; /* Timeout */
3134 else if (code == CM_ERROR_RETRY) {
3135 NTStatus = 0xC000022DL; /* Retry */
3137 else if (code == CM_ERROR_NOACCESS) {
3138 NTStatus = 0xC0000022L; /* Access denied */
3140 else if (code == CM_ERROR_READONLY) {
3141 NTStatus = 0xC00000A2L; /* Write protected */
3143 else if (code == CM_ERROR_NOSUCHFILE ||
3144 code == CM_ERROR_BPLUS_NOMATCH) {
3145 NTStatus = 0xC000000FL; /* No such file */
3147 else if (code == CM_ERROR_NOSUCHPATH) {
3148 NTStatus = 0xC000003AL; /* Object path not found */
3150 else if (code == CM_ERROR_TOOBIG) {
3151 NTStatus = 0xC000007BL; /* Invalid image format */
3153 else if (code == CM_ERROR_INVAL) {
3154 NTStatus = 0xC000000DL; /* Invalid parameter */
3156 else if (code == CM_ERROR_BADFD) {
3157 NTStatus = 0xC0000008L; /* Invalid handle */
3159 else if (code == CM_ERROR_BADFDOP) {
3160 NTStatus = 0xC0000022L; /* Access denied */
3162 else if (code == CM_ERROR_EXISTS) {
3163 NTStatus = 0xC0000035L; /* Object name collision */
3165 else if (code == CM_ERROR_NOTEMPTY) {
3166 NTStatus = 0xC0000101L; /* Directory not empty */
3168 else if (code == CM_ERROR_CROSSDEVLINK) {
3169 NTStatus = 0xC00000D4L; /* Not same device */
3171 else if (code == CM_ERROR_NOTDIR) {
3172 NTStatus = 0xC0000103L; /* Not a directory */
3174 else if (code == CM_ERROR_ISDIR) {
3175 NTStatus = 0xC00000BAL; /* File is a directory */
3177 else if (code == CM_ERROR_BADOP) {
3179 /* I have no idea where this comes from */
3180 NTStatus = 0xC09820FFL; /* SMB no support */
3182 NTStatus = 0xC00000BBL; /* Not supported */
3183 #endif /* COMMENT */
3185 else if (code == CM_ERROR_BADSHARENAME) {
3186 NTStatus = 0xC00000BEL; /* Bad network path (server valid, share bad) */
3188 else if (code == CM_ERROR_NOIPC) {
3190 NTStatus = 0xC0000022L; /* Access Denied */
3192 NTStatus = 0xC000013DL; /* Remote Resources */
3195 else if (code == CM_ERROR_CLOCKSKEW) {
3196 NTStatus = 0xC0000133L; /* Time difference at DC */
3198 else if (code == CM_ERROR_BADTID) {
3199 NTStatus = 0xC0982005L; /* SMB bad TID */
3201 else if (code == CM_ERROR_USESTD) {
3202 NTStatus = 0xC09820FBL; /* SMB use standard */
3204 else if (code == CM_ERROR_QUOTA) {
3205 NTStatus = 0xC0000044L; /* Quota exceeded */
3207 else if (code == CM_ERROR_SPACE) {
3208 NTStatus = 0xC000007FL; /* Disk full */
3210 else if (code == CM_ERROR_ATSYS) {
3211 NTStatus = 0xC0000033L; /* Object name invalid */
3213 else if (code == CM_ERROR_BADNTFILENAME) {
3214 NTStatus = 0xC0000033L; /* Object name invalid */
3216 else if (code == CM_ERROR_WOULDBLOCK) {
3217 NTStatus = 0xC00000D8L; /* Can't wait */
3219 else if (code == CM_ERROR_SHARING_VIOLATION) {
3220 NTStatus = 0xC0000043L; /* Sharing violation */
3222 else if (code == CM_ERROR_LOCK_CONFLICT) {
3223 NTStatus = 0xC0000054L; /* Lock conflict */
3225 else if (code == CM_ERROR_PARTIALWRITE) {
3226 NTStatus = 0xC000007FL; /* Disk full */
3228 else if (code == CM_ERROR_BUFFERTOOSMALL) {
3229 NTStatus = 0xC0000023L; /* Buffer too small */
3231 else if (code == CM_ERROR_AMBIGUOUS_FILENAME) {
3232 NTStatus = 0xC0000035L; /* Object name collision */
3234 else if (code == CM_ERROR_BADPASSWORD) {
3235 NTStatus = 0xC000006DL; /* unknown username or bad password */
3237 else if (code == CM_ERROR_BADLOGONTYPE) {
3238 NTStatus = 0xC000015BL; /* logon type not granted */
3240 else if (code == CM_ERROR_GSSCONTINUE) {
3241 NTStatus = 0xC0000016L; /* more processing required */
3243 else if (code == CM_ERROR_TOO_MANY_SYMLINKS) {
3245 NTStatus = 0xC0000280L; /* reparse point not resolved */
3247 NTStatus = 0xC0000022L; /* Access Denied */
3250 else if (code == CM_ERROR_PATH_NOT_COVERED) {
3251 NTStatus = 0xC0000257L; /* Path Not Covered */
3253 else if (code == CM_ERROR_ALLBUSY) {
3254 NTStatus = 0xC000022DL; /* Retry */
3256 else if (code == CM_ERROR_ALLOFFLINE || code == CM_ERROR_ALLDOWN) {
3257 NTStatus = 0xC000003AL; /* Path not found */
3259 else if (code >= ERROR_TABLE_BASE_RXK && code < ERROR_TABLE_BASE_RXK + 256) {
3260 NTStatus = 0xC0000322L; /* No Kerberos key */
3262 else if (code == CM_ERROR_BAD_LEVEL) {
3263 NTStatus = 0xC0000148L; /* Invalid Level */
3265 else if (code == CM_ERROR_RANGE_NOT_LOCKED) {
3266 NTStatus = 0xC000007EL; /* Range Not Locked */
3268 else if (code == CM_ERROR_NOSUCHDEVICE) {
3269 NTStatus = 0xC000000EL; /* No Such Device */
3271 else if (code == CM_ERROR_LOCK_NOT_GRANTED) {
3272 NTStatus = 0xC0000055L; /* Lock Not Granted */
3273 } else if (code == ENOMEM) {
3274 NTStatus = 0xC0000017L; /* Out of Memory */
3276 NTStatus = 0xC0982001L; /* SMB non-specific error */
3279 *NTStatusp = NTStatus;
3280 osi_Log2(smb_logp, "SMB SEND code %lX as NT %lX", code, NTStatus);
3283 void smb_MapCoreError(long code, smb_vc_t *vcp, unsigned short *scodep,
3284 unsigned char *classp)
3286 unsigned char class;
3287 unsigned short error;
3289 /* map CM_ERROR_* errors to SMB errors */
3290 if (code == CM_ERROR_NOSUCHCELL) {
3292 error = 3; /* bad path */
3294 else if (code == CM_ERROR_NOSUCHVOLUME) {
3296 error = 3; /* bad path */
3298 else if (code == CM_ERROR_TIMEDOUT) {
3300 error = 81; /* server is paused */
3302 else if (code == CM_ERROR_RETRY) {
3303 class = 2; /* shouldn't happen */
3306 else if (code == CM_ERROR_NOACCESS) {
3308 error = 4; /* bad access */
3310 else if (code == CM_ERROR_READONLY) {
3312 error = 19; /* read only */
3314 else if (code == CM_ERROR_NOSUCHFILE ||
3315 code == CM_ERROR_BPLUS_NOMATCH) {
3317 error = 2; /* ENOENT! */
3319 else if (code == CM_ERROR_NOSUCHPATH) {
3321 error = 3; /* Bad path */
3323 else if (code == CM_ERROR_TOOBIG) {
3325 error = 11; /* bad format */
3327 else if (code == CM_ERROR_INVAL) {
3328 class = 2; /* server non-specific error code */
3331 else if (code == CM_ERROR_BADFD) {
3333 error = 6; /* invalid file handle */
3335 else if (code == CM_ERROR_BADFDOP) {
3336 class = 1; /* invalid op on FD */
3339 else if (code == CM_ERROR_EXISTS) {
3341 error = 80; /* file already exists */
3343 else if (code == CM_ERROR_NOTEMPTY) {
3345 error = 5; /* delete directory not empty */
3347 else if (code == CM_ERROR_CROSSDEVLINK) {
3349 error = 17; /* EXDEV */
3351 else if (code == CM_ERROR_NOTDIR) {
3352 class = 1; /* bad path */
3355 else if (code == CM_ERROR_ISDIR) {
3356 class = 1; /* access denied; DOS doesn't have a good match */
3359 else if (code == CM_ERROR_BADOP) {
3363 else if (code == CM_ERROR_BADSHARENAME) {
3367 else if (code == CM_ERROR_NOIPC) {
3369 error = 4; /* bad access */
3371 else if (code == CM_ERROR_CLOCKSKEW) {
3372 class = 1; /* invalid function */
3375 else if (code == CM_ERROR_BADTID) {
3379 else if (code == CM_ERROR_USESTD) {
3383 else if (code == CM_ERROR_REMOTECONN) {
3387 else if (code == CM_ERROR_QUOTA) {
3388 if (vcp->flags & SMB_VCFLAG_USEV3) {
3390 error = 39; /* disk full */
3394 error = 5; /* access denied */
3397 else if (code == CM_ERROR_SPACE) {
3398 if (vcp->flags & SMB_VCFLAG_USEV3) {
3400 error = 39; /* disk full */
3404 error = 5; /* access denied */
3407 else if (code == CM_ERROR_PARTIALWRITE) {
3409 error = 39; /* disk full */
3411 else if (code == CM_ERROR_ATSYS) {
3413 error = 2; /* ENOENT */
3415 else if (code == CM_ERROR_WOULDBLOCK) {
3417 error = 33; /* lock conflict */
3419 else if (code == CM_ERROR_LOCK_CONFLICT) {
3421 error = 33; /* lock conflict */
3423 else if (code == CM_ERROR_SHARING_VIOLATION) {
3425 error = 33; /* lock conflict */
3427 else if (code == CM_ERROR_NOFILES) {
3429 error = 18; /* no files in search */
3431 else if (code == CM_ERROR_RENAME_IDENTICAL) {
3433 error = 183; /* Samba uses this */
3435 else if (code == CM_ERROR_BADPASSWORD || code == CM_ERROR_BADLOGONTYPE) {
3436 /* we don't have a good way of reporting CM_ERROR_BADLOGONTYPE */
3438 error = 2; /* bad password */
3440 else if (code == CM_ERROR_PATH_NOT_COVERED) {
3442 error = 3; /* bad path */
3451 osi_Log3(smb_logp, "SMB SEND code %lX as SMB %d: %d", code, class, error);
3454 long smb_SendCoreBadOp(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
3456 osi_Log0(smb_logp,"SendCoreBadOp - NOT_SUPPORTED");
3457 return CM_ERROR_BADOP;
3461 long smb_ReceiveCoreEcho(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
3463 unsigned short EchoCount, i;
3464 char *data, *outdata;
3467 EchoCount = (unsigned short) smb_GetSMBParm(inp, 0);
3469 for (i=1; i<=EchoCount; i++) {
3470 data = smb_GetSMBData(inp, &dataSize);
3471 smb_SetSMBParm(outp, 0, i);
3472 smb_SetSMBDataLength(outp, dataSize);
3473 outdata = smb_GetSMBData(outp, NULL);
3474 memcpy(outdata, data, dataSize);
3475 smb_SendPacket(vcp, outp);
3481 /* SMB_COM_READ_RAW */
3482 long smb_ReceiveCoreReadRaw(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
3485 long count, minCount, finalCount;
3489 smb_t *smbp = (smb_t*) inp;
3491 cm_user_t *userp = NULL;
3494 char *rawBuf = NULL;
3499 fd = smb_GetSMBParm(inp, 0);
3500 count = smb_GetSMBParm(inp, 3);
3501 minCount = smb_GetSMBParm(inp, 4);
3502 offset.LowPart = smb_GetSMBParm(inp, 1) | (smb_GetSMBParm(inp, 2) << 16);
3504 if (*inp->wctp == 10) {
3505 /* we were sent a request with 64-bit file offsets */
3506 #ifdef AFS_LARGEFILES
3507 offset.HighPart = smb_GetSMBParm(inp, 8) | (smb_GetSMBParm(inp, 9) << 16);
3509 if (LargeIntegerLessThanZero(offset)) {
3510 osi_Log0(smb_logp, "smb_ReceiveCoreReadRaw received negative 64-bit offset");
3514 if ((smb_GetSMBParm(inp, 8) | (smb_GetSMBParm(inp, 9) << 16)) != 0) {
3515 osi_Log0(smb_logp, "smb_ReceiveCoreReadRaw received 64-bit file offset. Dropping request.");
3518 offset.HighPart = 0;
3522 /* we were sent a request with 32-bit file offsets */
3523 offset.HighPart = 0;
3526 osi_Log4(smb_logp, "smb_ReceieveCoreReadRaw fd %d, off 0x%x:%08x, size 0x%x",
3527 fd, offset.HighPart, offset.LowPart, count);
3529 fidp = smb_FindFID(vcp, fd, 0);
3533 lock_ObtainMutex(&fidp->mx);
3535 lock_ReleaseMutex(&fidp->mx);
3536 smb_ReleaseFID(fidp);
3537 return CM_ERROR_BADFD;
3540 if (fidp->scp->flags & CM_SCACHEFLAG_DELETED) {
3541 lock_ReleaseMutex(&fidp->mx);
3542 smb_CloseFID(vcp, fidp, NULL, 0);
3543 code = CM_ERROR_NOSUCHFILE;
3549 LARGE_INTEGER LOffset, LLength;
3552 key = cm_GenerateKey(vcp->vcID, pid, fd);
3554 LOffset.HighPart = offset.HighPart;
3555 LOffset.LowPart = offset.LowPart;
3556 LLength.HighPart = 0;
3557 LLength.LowPart = count;
3559 lock_ObtainWrite(&fidp->scp->rw);
3560 code = cm_LockCheckRead(fidp->scp, LOffset, LLength, key);
3561 lock_ReleaseWrite(&fidp->scp->rw);
3564 lock_ReleaseMutex(&fidp->mx);
3568 lock_ObtainMutex(&smb_RawBufLock);
3570 /* Get a raw buf, from head of list */
3571 rawBuf = smb_RawBufs;
3572 smb_RawBufs = *(char **)smb_RawBufs;
3574 lock_ReleaseMutex(&smb_RawBufLock);
3576 lock_ReleaseMutex(&fidp->mx);
3580 if (fidp->flags & SMB_FID_IOCTL)
3582 rc = smb_IoctlReadRaw(fidp, vcp, inp, outp);
3584 /* Give back raw buffer */
3585 lock_ObtainMutex(&smb_RawBufLock);
3586 *((char **) rawBuf) = smb_RawBufs;
3588 smb_RawBufs = rawBuf;
3589 lock_ReleaseMutex(&smb_RawBufLock);
3592 lock_ReleaseMutex(&fidp->mx);
3593 smb_ReleaseFID(fidp);
3596 lock_ReleaseMutex(&fidp->mx);
3598 userp = smb_GetUserFromVCP(vcp, inp);
3600 code = smb_ReadData(fidp, &offset, count, rawBuf, userp, &finalCount);
3606 cm_ReleaseUser(userp);
3609 smb_ReleaseFID(fidp);
3613 memset((char *)ncbp, 0, sizeof(NCB));
3615 ncbp->ncb_length = (unsigned short) finalCount;
3616 ncbp->ncb_lsn = (unsigned char) vcp->lsn;
3617 ncbp->ncb_lana_num = vcp->lana;
3618 ncbp->ncb_command = NCBSEND;
3619 ncbp->ncb_buffer = rawBuf;
3621 code = Netbios(ncbp);
3623 osi_Log1(smb_logp, "ReadRaw send failure code %d", code);
3626 /* Give back raw buffer */
3627 lock_ObtainMutex(&smb_RawBufLock);
3628 *((char **) rawBuf) = smb_RawBufs;
3630 smb_RawBufs = rawBuf;
3631 lock_ReleaseMutex(&smb_RawBufLock);
3637 long smb_ReceiveCoreLockRecord(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
3639 osi_Log1(smb_logp, "SMB receive core lock record (not implemented); %d + 1 ongoing ops",
3644 long smb_ReceiveCoreUnlockRecord(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
3646 osi_Log1(smb_logp, "SMB receive core unlock record (not implemented); %d + 1 ongoing ops",
3651 /* SMB_COM_NEGOTIATE */
3652 long smb_ReceiveNegotiate(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
3659 int VistaProtoIndex;
3660 int protoIndex; /* index we're using */
3665 char protocol_array[10][1024]; /* protocol signature of the client */
3666 int caps; /* capabilities */
3669 TIME_ZONE_INFORMATION tzi;
3671 osi_Log1(smb_logp, "SMB receive negotiate; %d + 1 ongoing ops",
3674 namep = smb_GetSMBData(inp, &dbytes);
3677 coreProtoIndex = -1; /* not found */
3680 VistaProtoIndex = -1;
3681 while(namex < dbytes) {
3682 osi_Log1(smb_logp, "Protocol %s",
3683 osi_LogSaveString(smb_logp, namep+1));
3684 strcpy(protocol_array[tcounter], namep+1);
3686 /* namep points at the first protocol, or really, a 0x02
3687 * byte preceding the null-terminated ASCII name.
3689 if (strcmp("PC NETWORK PROGRAM 1.0", namep+1) == 0) {
3690 coreProtoIndex = tcounter;
3692 else if (smb_useV3 && strcmp("LM1.2X002", namep+1) == 0) {
3693 v3ProtoIndex = tcounter;
3695 else if (smb_useV3 && strcmp("NT LM 0.12", namep+1) == 0) {
3696 NTProtoIndex = tcounter;
3698 else if (smb_useV3 && strcmp("SMB 2.001", namep+1) == 0) {
3699 VistaProtoIndex = tcounter;
3702 /* compute size of protocol entry */
3703 entryLength = (int)strlen(namep+1);
3704 entryLength += 2; /* 0x02 bytes and null termination */
3706 /* advance over this protocol entry */
3707 namex += entryLength;
3708 namep += entryLength;
3709 tcounter++; /* which proto entry we're looking at */
3712 lock_ObtainMutex(&vcp->mx);
3714 if (VistaProtoIndex != -1) {
3715 protoIndex = VistaProtoIndex;
3716 vcp->flags |= (SMB_VCFLAG_USENT | SMB_VCFLAG_USEV3);
3719 if (NTProtoIndex != -1) {
3720 protoIndex = NTProtoIndex;
3721 vcp->flags |= (SMB_VCFLAG_USENT | SMB_VCFLAG_USEV3);
3723 else if (v3ProtoIndex != -1) {
3724 protoIndex = v3ProtoIndex;
3725 vcp->flags |= SMB_VCFLAG_USEV3;
3727 else if (coreProtoIndex != -1) {
3728 protoIndex = coreProtoIndex;
3729 vcp->flags |= SMB_VCFLAG_USECORE;
3731 else protoIndex = -1;
3732 lock_ReleaseMutex(&vcp->mx);
3734 if (protoIndex == -1)
3735 return CM_ERROR_INVAL;
3736 else if (VistaProtoIndex != 1 || NTProtoIndex != -1) {
3737 smb_SetSMBParm(outp, 0, protoIndex);
3738 if (smb_authType != SMB_AUTH_NONE) {
3739 smb_SetSMBParmByte(outp, 1,
3740 NEGOTIATE_SECURITY_USER_LEVEL |
3741 NEGOTIATE_SECURITY_CHALLENGE_RESPONSE); /* user level security, challenge response */