Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

3573 lines
92 KiB

  1. /*++
  2. Copyright (c) 1995 Microsoft Corporation
  3. Module Name:
  4. inetdbg.cxx
  5. Abstract:
  6. Debugging functions for internet DLL
  7. Contents:
  8. InternetDebugInitialize
  9. InternetDebugTerminate
  10. InternetGetDebugInfo
  11. InternetSetDebugInfo
  12. InternetOpenDebugFile
  13. InternetReopenDebugFile
  14. InternetCloseDebugFile
  15. InternetFlushDebugFile
  16. InternetDebugSetControlFlags
  17. InternetDebugResetControlFlags
  18. InternetDebugEnter
  19. InternetDebugLeave
  20. InternetDebugError
  21. InternetDebugPrint
  22. (InternetDebugPrintString)
  23. InternetDebugPrintf
  24. InternetDebugOut
  25. InternetDebugDump
  26. InternetDebugDumpFormat
  27. InternetAssert
  28. InternetGetDebugVariable
  29. (InternetGetDebugVariableString)
  30. InternetMapError
  31. InternetMapStatus
  32. InternetMapOption
  33. InternetMapHttpOption
  34. InternetMapHttpState
  35. InternetMapHttpStateFlag
  36. InternetMapAsyncRequest
  37. InternetMapHandleType
  38. InternetMapScheme
  39. InternetMapOpenType
  40. InternetMapService
  41. (ExtractFileName)
  42. (SetDebugPrefix)
  43. SourceFilename
  44. InitSymLib
  45. TermSymLib
  46. GetDebugSymbol
  47. x86SleazeCallStack
  48. x86SleazeCallersAddress
  49. Author:
  50. Richard L Firth (rfirth) 13-Feb-1995
  51. Environment:
  52. Win32(s) user-mode DLL
  53. Revision History:
  54. 13-Feb-1995 rfirth
  55. Created
  56. --*/
  57. #include <wininetp.h>
  58. #include <ieverp.h>
  59. #include "rprintf.h"
  60. #include <imagehlp.h>
  61. #include "autodial.h"
  62. #ifdef ENABLE_DEBUG
  63. //
  64. // private manifests
  65. //
  66. #define SWITCH_VARIABLE_NAME "WininetDebugging"
  67. #define CONTROL_VARIABLE_NAME "WininetControl"
  68. #define CATEGORY_VARIABLE_NAME "WininetCategory"
  69. #define ERROR_VARIABLE_NAME "WininetError"
  70. #define BREAK_VARIABLE_NAME "WininetBreak"
  71. #define DEFAULT_LOG_VARIABLE_NAME "WininetLog"
  72. #define CHECK_LIST_VARIABLE_NAME "WininetCheckSerializedList"
  73. #define LOG_FILE_VARIABLE_NAME "WininetLogFile"
  74. #define INDENT_VARIABLE_NAME "WininetLogIndent"
  75. #define NO_PID_IN_LOG_FILENAME "WininetNoPidInLogFilename"
  76. #define DEFAULT_LOG_FILE_NAME "WININET.LOG"
  77. #define ENVIRONMENT_VARIABLE_BUFFER_LENGTH 80
  78. #define PRINTF_STACK_BUFFER_LENGTH (4 K)
  79. //
  80. // private macros
  81. //
  82. #define CASE_OF(constant) case constant: return # constant
  83. //
  84. // private prototypes
  85. //
  86. PRIVATE
  87. VOID
  88. InternetDebugPrintString(
  89. IN LPSTR String
  90. );
  91. PRIVATE
  92. VOID
  93. InternetGetDebugVariableString(
  94. IN LPSTR lpszVariableName,
  95. OUT LPSTR lpszVariable,
  96. IN DWORD dwVariableLen
  97. );
  98. PRIVATE
  99. LPSTR
  100. ExtractFileName(
  101. IN LPSTR Module,
  102. OUT LPSTR Buf
  103. );
  104. PRIVATE
  105. LPSTR
  106. SetDebugPrefix(
  107. IN LPSTR Buffer
  108. );
  109. //
  110. //
  111. // these variables are employed in macros, so must be public
  112. //
  113. PUBLIC DWORD InternetDebugErrorLevel = DBG_ERROR;
  114. PUBLIC DWORD InternetDebugControlFlags = DBG_NO_DEBUG;
  115. PUBLIC DWORD InternetDebugCategoryFlags = 0;
  116. PUBLIC DWORD InternetDebugBreakFlags = 0;
  117. //
  118. // these variables are only accessed in this module, so can be private
  119. //
  120. PRIVATE int InternetDebugIndentIncrement = 2;
  121. PRIVATE HANDLE InternetDebugFileHandle = INVALID_HANDLE_VALUE;
  122. PRIVATE char InternetDebugFilename[MAX_PATH + 1] = DEFAULT_LOG_FILE_NAME;
  123. PRIVATE BOOL InternetDebugEnabled = TRUE;
  124. PRIVATE DWORD InternetDebugStartTime = 0;
  125. extern "C" {
  126. BOOL UrlcacheDebugEnabled = FALSE;
  127. #if defined(UNIX) && defined(ux10)
  128. /* Temporary fix for Apogee Compiler bug on HP only */
  129. extern BOOL fCheckEntryOnList;
  130. #else
  131. BOOL fCheckEntryOnList;
  132. #endif /* UNIX */
  133. }
  134. //
  135. // high frequency performance counter globals
  136. //
  137. PRIVATE LONGLONG ftInit; // initial local time
  138. PRIVATE LONGLONG pcInit; // initial perf counter
  139. PRIVATE LONGLONG pcFreq; // perf counter frequency
  140. //
  141. // functions
  142. //
  143. VOID
  144. InternetDebugInitialize(
  145. VOID
  146. )
  147. /*++
  148. Routine Description:
  149. reads environment INETDBG flags and opens debug log file if required
  150. Arguments:
  151. None.
  152. Return Value:
  153. None.
  154. --*/
  155. {
  156. //
  157. // ensure registry key open (normally done in GlobalDataInitialize() later)
  158. //
  159. EnsureInternetSettingsKeyCached();
  160. //
  161. // record the starting tick count for cumulative deltas
  162. //
  163. InternetDebugStartTime = GetTickCountWrap();
  164. if (QueryPerformanceFrequency ((LARGE_INTEGER *) &pcFreq) && pcFreq) {
  165. QueryPerformanceCounter ((LARGE_INTEGER *) &pcInit);
  166. SYSTEMTIME st;
  167. GetLocalTime (&st);
  168. SystemTimeToFileTime (&st, (FILETIME *) &ftInit);
  169. }
  170. //
  171. // check see if there are any debug variable overrides in the environment
  172. // or the registry. If "WininetLog=<!0>" is set then we use the flags that
  173. // are most commonly used to generate WININET.LOG, with no console or
  174. // debugger output. We allow the other variables to be overridden
  175. //
  176. BOOL defaultDebugVariables = FALSE;
  177. InternetGetDebugVariable(DEFAULT_LOG_VARIABLE_NAME, (LPDWORD)&defaultDebugVariables);
  178. if (defaultDebugVariables) {
  179. InternetDebugEnabled = TRUE;
  180. InternetDebugControlFlags = INTERNET_DEBUG_CONTROL_DEFAULT;
  181. InternetDebugCategoryFlags = INTERNET_DEBUG_CATEGORY_DEFAULT;
  182. InternetDebugErrorLevel = INTERNET_DEBUG_ERROR_LEVEL_DEFAULT;
  183. InternetDebugBreakFlags = 0;
  184. }
  185. InternetGetDebugVariable(SWITCH_VARIABLE_NAME, (LPDWORD)&InternetDebugEnabled);
  186. InternetGetDebugVariable(CONTROL_VARIABLE_NAME, &InternetDebugControlFlags);
  187. InternetGetDebugVariable(CATEGORY_VARIABLE_NAME, &InternetDebugCategoryFlags);
  188. InternetGetDebugVariable(ERROR_VARIABLE_NAME, &InternetDebugErrorLevel);
  189. InternetGetDebugVariable(BREAK_VARIABLE_NAME, &InternetDebugBreakFlags);
  190. InternetGetDebugVariable(CHECK_LIST_VARIABLE_NAME, (LPDWORD)&fCheckEntryOnList);
  191. InternetGetDebugVariable(INDENT_VARIABLE_NAME, (LPDWORD)&InternetDebugIndentIncrement);
  192. InternetGetDebugVariableString(LOG_FILE_VARIABLE_NAME,
  193. InternetDebugFilename,
  194. sizeof(InternetDebugFilename)
  195. );
  196. DWORD InternetNoPidInLogFilename=0;
  197. InternetGetDebugVariable(NO_PID_IN_LOG_FILENAME, &InternetNoPidInLogFilename);
  198. if (!InternetNoPidInLogFilename)
  199. {
  200. char szFullPathName[MAX_PATH + 1];
  201. LPSTR szExecutableName;
  202. if (GetModuleFileName(NULL, szFullPathName, sizeof(szFullPathName)))
  203. {
  204. szExecutableName = StrRChr(szFullPathName, NULL, '\\');
  205. if (szExecutableName != NULL)
  206. ++szExecutableName;
  207. else
  208. szExecutableName = szFullPathName;
  209. }
  210. else
  211. szExecutableName = "";
  212. DWORD cbFilenameLen = strlen(InternetDebugFilename);
  213. // ".xxxxx.yyy.#########.LOG"
  214. DWORD cbProcessInfoLenMax = 1 + strlen(szExecutableName) + 1 + 9 + 1 + 3;
  215. if (cbProcessInfoLenMax < sizeof(InternetDebugFilename))
  216. wsprintf(InternetDebugFilename+cbFilenameLen, ".%s.%u.LOG",
  217. szExecutableName,
  218. GetCurrentProcessId());
  219. };
  220. UrlcacheDebugEnabled = InternetDebugEnabled &&
  221. (InternetDebugCategoryFlags & DBG_CACHE);
  222. if ((InternetDebugIndentIncrement < 0) || (InternetDebugIndentIncrement > 32)) {
  223. InternetDebugIndentIncrement = 2;
  224. }
  225. //
  226. // quit now if debugging is disabled
  227. //
  228. if (!InternetDebugEnabled) {
  229. InternetDebugControlFlags |= (DBG_NO_DEBUG | DBG_NO_DATA_DUMP);
  230. return;
  231. }
  232. //
  233. // if we want to write debug output to file, open WININET.LOG in the current
  234. // directory. Open it in text mode, for write-only (by this process)
  235. //
  236. if (InternetDebugControlFlags & DBG_TO_FILE) {
  237. if (!InternetReopenDebugFile(InternetDebugFilename)) {
  238. InternetDebugControlFlags &= ~DBG_TO_FILE;
  239. }
  240. }
  241. }
  242. VOID
  243. InternetDebugTerminate(
  244. VOID
  245. )
  246. /*++
  247. Routine Description:
  248. Performs any required debug termination
  249. Arguments:
  250. None.
  251. Return Value:
  252. None.
  253. --*/
  254. {
  255. if (InternetDebugControlFlags & DBG_TO_FILE) {
  256. InternetCloseDebugFile();
  257. }
  258. InternetDebugControlFlags = DBG_NO_DEBUG;
  259. }
  260. DWORD
  261. InternetGetDebugInfo(
  262. OUT LPINTERNET_DEBUG_INFO lpBuffer,
  263. IN OUT LPDWORD lpdwBufferLength
  264. )
  265. /*++
  266. Routine Description:
  267. Returns the internal debug variables
  268. Arguments:
  269. lpBuffer - pointer to structure that receives the variables
  270. lpdwBufferLength - IN: Length of buffer
  271. OUT: length of returned data if successful, else
  272. required length of buffer
  273. Return Value:
  274. DWORD
  275. Success - ERROR_SUCCESS;
  276. Failure - ERROR_INSUFFICIENT_BUFFER
  277. --*/
  278. {
  279. DWORD requiredLength;
  280. DWORD error;
  281. int filenameLength;
  282. filenameLength = ((InternetDebugFileHandle != INVALID_HANDLE_VALUE)
  283. ? strlen(InternetDebugFilename) : 0) + 1;
  284. requiredLength = sizeof(*lpBuffer) + filenameLength;
  285. if ((lpBuffer != NULL) && (*lpdwBufferLength >= requiredLength)) {
  286. lpBuffer->ErrorLevel = InternetDebugErrorLevel;
  287. lpBuffer->ControlFlags = InternetDebugControlFlags;
  288. lpBuffer->CategoryFlags = InternetDebugCategoryFlags;
  289. lpBuffer->BreakFlags = InternetDebugBreakFlags;
  290. lpBuffer->IndentIncrement = InternetDebugIndentIncrement;
  291. if (InternetDebugFileHandle != INVALID_HANDLE_VALUE) {
  292. memcpy(lpBuffer->Filename, InternetDebugFilename, filenameLength);
  293. } else {
  294. lpBuffer->Filename[0] = '\0';
  295. }
  296. error = ERROR_SUCCESS;
  297. } else {
  298. error = ERROR_INSUFFICIENT_BUFFER;
  299. }
  300. *lpdwBufferLength = requiredLength;
  301. return error;
  302. }
  303. DWORD
  304. InternetSetDebugInfo(
  305. IN LPINTERNET_DEBUG_INFO lpBuffer,
  306. IN DWORD dwBufferLength
  307. )
  308. /*++
  309. Routine Description:
  310. Sets the internal debugging variables to the values in the buffer. To make
  311. incrmental changes, the caller must first read the variables, change the
  312. bits they're interested in, then change the whole lot at one go
  313. Arguments:
  314. lpBuffer - pointer to structure that contains the variables
  315. dwBufferLength - size of lpBuffer. Ignored
  316. Return Value:
  317. DWORD
  318. Success - ERROR_SUCCESS
  319. Failure -
  320. --*/
  321. {
  322. InternetDebugErrorLevel = lpBuffer->ErrorLevel;
  323. InternetDebugCategoryFlags = lpBuffer->CategoryFlags;
  324. InternetDebugControlFlags = lpBuffer->ControlFlags;
  325. InternetDebugBreakFlags = lpBuffer->BreakFlags;
  326. InternetDebugIndentIncrement = lpBuffer->IndentIncrement;
  327. //
  328. // handle the debug file. If we get an empty string, then (if we are logging
  329. // to a file), close the file.
  330. //
  331. // If the filename is exactly the same as we're already using, then the
  332. // caller doesn't want to change the log file
  333. //
  334. // If the filename is different, then we are being asked to create a new log
  335. // file: close the old and open the new. If we cannot open the new file then
  336. // set the filename to the NUL string in the debug buffer
  337. //
  338. if (lpBuffer->Filename[0]) {
  339. if (strcmp(InternetDebugFilename, lpBuffer->Filename) != 0) {
  340. InternetCloseDebugFile();
  341. InternetReopenDebugFile(lpBuffer->Filename);
  342. if (InternetDebugFileHandle != INVALID_HANDLE_VALUE) {
  343. strcpy(InternetDebugFilename, lpBuffer->Filename);
  344. } else {
  345. lpBuffer->Filename[0] = '\0';
  346. }
  347. }
  348. } else {
  349. InternetCloseDebugFile();
  350. }
  351. return ERROR_SUCCESS;
  352. }
  353. BOOL
  354. InternetOpenDebugFile(
  355. VOID
  356. )
  357. /*++
  358. Routine Description:
  359. Opens debug filename if not already open. Use InternetDebugFilename
  360. Arguments:
  361. None.
  362. Return Value:
  363. BOOL
  364. TRUE - file was opened
  365. FALSE - file not opened (already open or error)
  366. --*/
  367. {
  368. if (InternetDebugFileHandle == INVALID_HANDLE_VALUE) {
  369. InternetDebugFileHandle = CreateFile(
  370. InternetDebugFilename,
  371. GENERIC_WRITE,
  372. FILE_SHARE_READ,
  373. NULL, // lpSecurityAttributes
  374. (InternetDebugControlFlags & DBG_APPEND_FILE)
  375. ? OPEN_ALWAYS
  376. : CREATE_ALWAYS,
  377. FILE_ATTRIBUTE_NORMAL
  378. | FILE_FLAG_SEQUENTIAL_SCAN
  379. | ((InternetDebugControlFlags & DBG_FLUSH_OUTPUT)
  380. ? FILE_FLAG_WRITE_THROUGH
  381. : 0),
  382. NULL
  383. );
  384. return InternetDebugFileHandle != INVALID_HANDLE_VALUE;
  385. }
  386. return FALSE;
  387. }
  388. BOOL
  389. InternetReopenDebugFile(
  390. IN LPSTR Filename
  391. )
  392. /*++
  393. Routine Description:
  394. (Re)opens a debug log file. Closes the current one if it is open
  395. Arguments:
  396. Filename - new file to open
  397. Return Value:
  398. None.
  399. --*/
  400. {
  401. if (InternetDebugFileHandle != INVALID_HANDLE_VALUE) {
  402. InternetCloseDebugFile();
  403. }
  404. if (Filename && *Filename) {
  405. InternetDebugFileHandle = CreateFile(
  406. Filename,
  407. GENERIC_WRITE,
  408. FILE_SHARE_READ,
  409. NULL, // lpSecurityAttributes
  410. (InternetDebugControlFlags & DBG_APPEND_FILE)
  411. ? OPEN_ALWAYS
  412. : CREATE_ALWAYS,
  413. FILE_ATTRIBUTE_NORMAL
  414. | FILE_FLAG_SEQUENTIAL_SCAN
  415. | ((InternetDebugControlFlags & DBG_FLUSH_OUTPUT)
  416. ? FILE_FLAG_WRITE_THROUGH
  417. : 0),
  418. NULL
  419. );
  420. //
  421. // put our start info in the log file. Mainly useful when we're
  422. // appending to the file
  423. //
  424. if (InternetDebugFileHandle != INVALID_HANDLE_VALUE) {
  425. SYSTEMTIME currentTime;
  426. char filespec[MAX_PATH + 1];
  427. LPSTR filename;
  428. if (GetModuleFileName(NULL, filespec, sizeof(filespec))) {
  429. filename = strrchr(filespec, '\\');
  430. if (filename != NULL) {
  431. ++filename;
  432. } else {
  433. filename = filespec;
  434. }
  435. } else {
  436. filename = "";
  437. }
  438. InternetDebugGetLocalTime(&currentTime, NULL);
  439. InternetDebugPrintf("\n"
  440. ">>>> WinInet Version %d.%d Build %s.%d " __DATE__ " " __TIME__ "\n"
  441. ">>>> Process %s [%d (%#x)] started at %02d:%02d:%02d.%03d %02d/%02d/%d\n",
  442. InternetVersionInfo.dwMajorVersion,
  443. InternetVersionInfo.dwMinorVersion,
  444. VER_PRODUCTVERSION_STRING,
  445. InternetBuildNumber,
  446. filename,
  447. GetCurrentProcessId(),
  448. GetCurrentProcessId(),
  449. currentTime.wHour,
  450. currentTime.wMinute,
  451. currentTime.wSecond,
  452. currentTime.wMilliseconds,
  453. currentTime.wMonth,
  454. currentTime.wDay,
  455. currentTime.wYear
  456. );
  457. InternetDebugPrintf(">>>> Command line = %q\n", GetCommandLine());
  458. InternetDebugPrintf("\n"
  459. " InternetDebugErrorLevel = %s [%d]\n"
  460. " InternetDebugControlFlags = %#08x\n"
  461. " InternetDebugCategoryFlags = %#08x\n"
  462. " InternetDebugBreakFlags = %#08x\n"
  463. " InternetDebugIndentIncrement = %d\n"
  464. "\n",
  465. (InternetDebugErrorLevel == DBG_INFO) ? "Info"
  466. : (InternetDebugErrorLevel == DBG_WARNING) ? "Warning"
  467. : (InternetDebugErrorLevel == DBG_ERROR) ? "Error"
  468. : (InternetDebugErrorLevel == DBG_FATAL) ? "Fatal"
  469. : (InternetDebugErrorLevel == DBG_ALWAYS) ? "Always"
  470. : "?",
  471. InternetDebugErrorLevel,
  472. InternetDebugControlFlags,
  473. InternetDebugCategoryFlags,
  474. InternetDebugBreakFlags,
  475. InternetDebugIndentIncrement
  476. );
  477. return TRUE;
  478. }
  479. }
  480. return FALSE;
  481. }
  482. VOID
  483. InternetCloseDebugFile(
  484. VOID
  485. )
  486. /*++
  487. Routine Description:
  488. Closes the current debug log file
  489. Arguments:
  490. None.
  491. Return Value:
  492. None.
  493. --*/
  494. {
  495. if (InternetDebugFileHandle != INVALID_HANDLE_VALUE) {
  496. if (InternetDebugControlFlags & DBG_FLUSH_OUTPUT) {
  497. InternetFlushDebugFile();
  498. }
  499. CloseHandle(InternetDebugFileHandle);
  500. InternetDebugFileHandle = INVALID_HANDLE_VALUE;
  501. }
  502. }
  503. VOID
  504. InternetFlushDebugFile(
  505. VOID
  506. )
  507. /*++
  508. Routine Description:
  509. description-of-function.
  510. Arguments:
  511. None.
  512. Return Value:
  513. None.
  514. --*/
  515. {
  516. if (InternetDebugFileHandle != INVALID_HANDLE_VALUE) {
  517. FlushFileBuffers(InternetDebugFileHandle);
  518. }
  519. }
  520. VOID
  521. InternetDebugSetControlFlags(
  522. IN DWORD dwFlags
  523. )
  524. /*++
  525. Routine Description:
  526. Sets debug control flags
  527. Arguments:
  528. dwFlags - flags to set
  529. Return Value:
  530. None.
  531. --*/
  532. {
  533. InternetDebugControlFlags |= dwFlags;
  534. }
  535. VOID
  536. InternetDebugResetControlFlags(
  537. IN DWORD dwFlags
  538. )
  539. /*++
  540. Routine Description:
  541. Resets debug control flags
  542. Arguments:
  543. dwFlags - flags to reset
  544. Return Value:
  545. None.
  546. --*/
  547. {
  548. InternetDebugControlFlags &= ~dwFlags;
  549. }
  550. VOID
  551. InternetDebugEnter(
  552. IN DWORD Category,
  553. IN DEBUG_FUNCTION_RETURN_TYPE ReturnType,
  554. IN LPCSTR Function,
  555. IN LPCSTR ParameterList OPTIONAL,
  556. IN ...
  557. )
  558. /*++
  559. Routine Description:
  560. Creates an INTERNET_DEBUG_RECORD for the current function and adds it to
  561. the per-thread (debug) call-tree
  562. Arguments:
  563. Category - category flags, e.g. DBG_FTP
  564. ReturnType - type of data it returns
  565. Function - name of the function. Must be global, static string
  566. ParameterList - string describing parameters to function, or NULL if none
  567. ... - parameters to function
  568. Return Value:
  569. None.
  570. --*/
  571. {
  572. LPINTERNET_THREAD_INFO pThreadInfo;
  573. LPINTERNET_DEBUG_RECORD pRecord;
  574. if (InternetDebugControlFlags & DBG_NO_DEBUG) {
  575. return;
  576. }
  577. pThreadInfo = InternetGetThreadInfo();
  578. //INET_ASSERT(pThreadInfo != NULL);
  579. if (!pThreadInfo) {
  580. return;
  581. }
  582. pRecord = NEW(INTERNET_DEBUG_RECORD);
  583. //INET_ASSERT(pRecord != NULL);
  584. if (!pRecord) {
  585. return;
  586. }
  587. pRecord->Stack = pThreadInfo->Stack;
  588. pRecord->Category = Category;
  589. pRecord->ReturnType = ReturnType;
  590. pRecord->Function = Function;
  591. pRecord->LastTime = GetTickCountWrap();
  592. pThreadInfo->Stack = pRecord;
  593. ++pThreadInfo->CallDepth;
  594. //
  595. // if the function's category (FTP, GOPHER, HTTP) is selected in the
  596. // category flags, then we dump the function entry information
  597. //
  598. if (InternetDebugCategoryFlags & Category) {
  599. char buf[4096];
  600. LPSTR bufptr;
  601. bufptr = buf;
  602. bufptr += rsprintf(bufptr, "%s(", Function);
  603. if (ARGUMENT_PRESENT(ParameterList)) {
  604. va_list parms;
  605. va_start(parms, ParameterList);
  606. bufptr += _sprintf(bufptr, (char*)ParameterList, parms);
  607. va_end(parms);
  608. }
  609. rsprintf(bufptr, ")\n");
  610. InternetDebugPrintString(buf);
  611. //
  612. // only increase the indentation if we will display debug information
  613. // for this category
  614. //
  615. pThreadInfo->IndentIncrement += InternetDebugIndentIncrement;
  616. }
  617. }
  618. VOID
  619. InternetDebugLeave(
  620. IN DWORD_PTR Variable,
  621. IN LPCSTR Filename,
  622. IN DWORD LineNumber
  623. )
  624. /*++
  625. Routine Description:
  626. Destroys the INTERNET_DEBUG_RECORD for the current function and dumps info
  627. about what the function is returning, if requested to do so
  628. Arguments:
  629. Variable - variable containing value being returned by function
  630. Filename - name of file where DEBUG_LEAVE() invoked
  631. LineNumber - and line number in Filename
  632. Return Value:
  633. None.
  634. --*/
  635. {
  636. LPINTERNET_THREAD_INFO pThreadInfo;
  637. LPINTERNET_DEBUG_RECORD pRecord;
  638. LPSTR format;
  639. LPSTR errstr;
  640. BOOL noVar;
  641. char formatBuf[128];
  642. DWORD lastError;
  643. char hexnumBuf[15];
  644. if (InternetDebugControlFlags & DBG_NO_DEBUG) {
  645. return;
  646. }
  647. //
  648. // seems that something in this path can nuke the last error, so we must
  649. // refresh it
  650. //
  651. lastError = GetLastError();
  652. pThreadInfo = InternetGetThreadInfo();
  653. //INET_ASSERT(pThreadInfo != NULL);
  654. if (!pThreadInfo) {
  655. return;
  656. }
  657. pRecord = pThreadInfo->Stack;
  658. //INET_ASSERT(pRecord != NULL);
  659. if (!pRecord) {
  660. return;
  661. }
  662. //
  663. // we are about to output a diagnostic message to the debug log, debugger,
  664. // or console. First check that we are required to display messages at
  665. // this level. The level for function ENTER and LEAVE is INFO
  666. //
  667. // if (InternetDebugErrorLevel >= DBG_INFO)
  668. {
  669. //
  670. // only display the string and reduce the indent if we are requested
  671. // for information about this category
  672. //
  673. errstr = NULL;
  674. noVar = FALSE;
  675. if (InternetDebugCategoryFlags & pRecord->Category) {
  676. switch (pRecord->ReturnType) {
  677. case None:
  678. format = "%s() returning VOID";
  679. noVar = TRUE;
  680. break;
  681. case Bool:
  682. Variable = (DWORD_PTR)(Variable ? "TRUE" : "FALSE");
  683. //
  684. // *** FALL THROUGH ***
  685. //
  686. case String:
  687. format = "%s() returning %s";
  688. break;
  689. case Int:
  690. format = "%s() returning %d";
  691. break;
  692. case Dword:
  693. format = "%s() returning %u";
  694. errstr = InternetMapError((DWORD)Variable);
  695. if (errstr != NULL) {
  696. if (*errstr == '?') {
  697. rsprintf(hexnumBuf, "%#x", Variable);
  698. errstr = hexnumBuf;
  699. format = "%s() returning %u [?] (%s)";
  700. } else {
  701. format = "%s() returning %u [%s]";
  702. }
  703. }
  704. break;
  705. case Handle:
  706. case Pointer:
  707. if (Variable == 0) {
  708. format = "%s() returning NULL";
  709. noVar = TRUE;
  710. } else {
  711. if (pRecord->ReturnType == Handle) {
  712. format = "%s() returning handle %#x";
  713. } else {
  714. format = "%s() returning %#x";
  715. }
  716. }
  717. break;
  718. default:
  719. INET_ASSERT(FALSE);
  720. break;
  721. }
  722. pThreadInfo->IndentIncrement -= InternetDebugIndentIncrement;
  723. if (pThreadInfo->IndentIncrement < 0) {
  724. pThreadInfo->IndentIncrement = 0;
  725. }
  726. //
  727. // add line number info, if requested
  728. //
  729. strcpy(formatBuf, format);
  730. if (!(InternetDebugControlFlags & DBG_NO_LINE_NUMBER)) {
  731. strcat(formatBuf, " (line %d)");
  732. }
  733. strcat(formatBuf, "\n");
  734. //
  735. // output an empty line if we are required to separate API calls in
  736. // the log. Only do this if this is an API level function, and it
  737. // is the top-level function
  738. //
  739. if ((InternetDebugControlFlags & DBG_SEPARATE_APIS)
  740. && (pRecord->Stack == NULL)) {
  741. strcat(formatBuf, "\n");
  742. }
  743. //
  744. // dump the line, depending on requirements and number of arguments
  745. //
  746. if (noVar) {
  747. InternetDebugPrint(formatBuf,
  748. pRecord->Function,
  749. LineNumber
  750. );
  751. } else if (errstr != NULL) {
  752. InternetDebugPrint(formatBuf,
  753. pRecord->Function,
  754. Variable,
  755. errstr,
  756. LineNumber
  757. );
  758. } else {
  759. InternetDebugPrint(formatBuf,
  760. pRecord->Function,
  761. Variable,
  762. LineNumber
  763. );
  764. }
  765. /*
  766. //
  767. // output an empty line if we are required to separate API calls in
  768. // the log. Only do this if this is an API level function, and it
  769. // is the top-level function
  770. //
  771. if ((InternetDebugControlFlags & DBG_SEPARATE_APIS)
  772. && (pRecord->Stack == NULL)) {
  773. //
  774. // don't call InternetDebugPrint - we don't need timing, thread,
  775. // level etc. information just for the separator
  776. //
  777. InternetDebugOut("\n", FALSE);
  778. }
  779. */
  780. }
  781. }
  782. //
  783. // regardless of whether we are outputting debug info for this category,
  784. // remove the debug record and reduce the call-depth
  785. //
  786. --pThreadInfo->CallDepth;
  787. pThreadInfo->Stack = pRecord->Stack;
  788. DEL(pRecord);
  789. //
  790. // refresh the last error, in case it was nuked
  791. //
  792. SetLastError(lastError);
  793. }
  794. VOID
  795. InternetDebugError(
  796. IN DWORD Error
  797. )
  798. /*++
  799. Routine Description:
  800. Used to display that a function is returning an error. We try to display a
  801. symbolic name for the error too (as when we are returning a DWORD from a
  802. function, using DEBUG_LEAVE)
  803. Displays a string of the form:
  804. Foo() returning error 87 [ERROR_INVALID_PARAMETER]
  805. Arguments:
  806. Error - the error code
  807. Return Value:
  808. None.
  809. --*/
  810. {
  811. LPINTERNET_THREAD_INFO pThreadInfo;
  812. LPINTERNET_DEBUG_RECORD pRecord;
  813. LPSTR errstr;
  814. DWORD lastError;
  815. char hexnumBuf[15];
  816. if (InternetDebugControlFlags & DBG_NO_DEBUG) {
  817. return;
  818. }
  819. //
  820. // seems that something in this path can nuke the last error, so we must
  821. // refresh it
  822. //
  823. lastError = GetLastError();
  824. pThreadInfo = InternetGetThreadInfo();
  825. //INET_ASSERT(pThreadInfo != NULL);
  826. INET_ASSERT(GetLastError() == lastError);
  827. if (pThreadInfo == NULL) {
  828. return;
  829. }
  830. pRecord = pThreadInfo->Stack;
  831. //INET_ASSERT(pRecord != NULL);
  832. if (pRecord == NULL) {
  833. return;
  834. }
  835. errstr = InternetMapError(Error);
  836. if ((errstr == NULL) || (*errstr == '?')) {
  837. rsprintf(hexnumBuf, "%#x", Error);
  838. errstr = hexnumBuf;
  839. }
  840. InternetDebugPrint("%s() returning %d [%s]\n",
  841. pRecord->Function,
  842. Error,
  843. errstr
  844. );
  845. //
  846. // refresh the last error, in case it was nuked
  847. //
  848. SetLastError(lastError);
  849. }
  850. VOID
  851. InternetDebugPrint(
  852. IN LPSTR Format,
  853. ...
  854. )
  855. /*++
  856. Routine Description:
  857. Internet equivalent of printf()
  858. Arguments:
  859. Format - printf format string
  860. ... - any extra args
  861. Return Value:
  862. None.
  863. --*/
  864. {
  865. if (InternetDebugControlFlags & DBG_NO_DEBUG) {
  866. return;
  867. }
  868. char buf[PRINTF_STACK_BUFFER_LENGTH];
  869. LPSTR bufptr;
  870. bufptr = SetDebugPrefix(buf);
  871. if (bufptr == NULL) {
  872. return;
  873. }
  874. //
  875. // now append the string that the DEBUG_PRINT originally gave us
  876. //
  877. va_list list;
  878. va_start(list, Format);
  879. _sprintf(bufptr, Format, list);
  880. va_end(list);
  881. InternetDebugOut(buf, FALSE);
  882. }
  883. VOID
  884. InternetDebugPrintValist(
  885. IN LPSTR Format,
  886. va_list list
  887. )
  888. /*++
  889. Routine Description:
  890. Internet equivalent of printf(), but takes valist as the args
  891. Arguments:
  892. Format - printf format string
  893. list - stack frame of variable arguments
  894. Return Value:
  895. None.
  896. --*/
  897. {
  898. if (InternetDebugControlFlags & DBG_NO_DEBUG) {
  899. return;
  900. }
  901. char buf[PRINTF_STACK_BUFFER_LENGTH];
  902. LPSTR bufptr;
  903. bufptr = SetDebugPrefix(buf);
  904. if (bufptr == NULL) {
  905. return;
  906. }
  907. _sprintf(bufptr, Format, list);
  908. InternetDebugOut(buf, FALSE);
  909. }
  910. PRIVATE
  911. VOID
  912. InternetDebugPrintString(
  913. IN LPSTR String
  914. )
  915. /*++
  916. Routine Description:
  917. Same as InternetDebugPrint(), except we perform no expansion on the string
  918. Arguments:
  919. String - already formatted string (may contain %s)
  920. Return Value:
  921. None.
  922. --*/
  923. {
  924. if (InternetDebugControlFlags & DBG_NO_DEBUG) {
  925. return;
  926. }
  927. char buf[PRINTF_STACK_BUFFER_LENGTH];
  928. LPSTR bufptr;
  929. bufptr = SetDebugPrefix(buf);
  930. if (bufptr == NULL) {
  931. return;
  932. }
  933. //
  934. // now append the string that the DEBUG_PRINT originally gave us
  935. //
  936. strcpy(bufptr, String);
  937. InternetDebugOut(buf, FALSE);
  938. }
  939. VOID
  940. InternetDebugPrintf(
  941. IN LPSTR Format,
  942. IN ...
  943. )
  944. /*++
  945. Routine Description:
  946. Same as InternetDebugPrint(), but we don't access the per-thread info
  947. (because we may not have any)
  948. Arguments:
  949. Format - printf format string
  950. ... - any extra args
  951. Return Value:
  952. None.
  953. --*/
  954. {
  955. if (InternetDebugControlFlags & DBG_NO_DEBUG) {
  956. return;
  957. }
  958. va_list list;
  959. char buf[PRINTF_STACK_BUFFER_LENGTH];
  960. va_start(list, Format);
  961. _sprintf(buf, Format, list);
  962. va_end(list);
  963. InternetDebugOut(buf, FALSE);
  964. }
  965. VOID
  966. InternetDebugOut(
  967. IN LPSTR Buffer,
  968. IN BOOL Assert
  969. )
  970. /*++
  971. Routine Description:
  972. Writes a string somewhere - to the debug log file, to the console, or via
  973. the debugger, or any combination
  974. Arguments:
  975. Buffer - pointer to formatted buffer to write
  976. Assert - TRUE if this function is being called from InternetAssert(), in
  977. which case we *always* write to the debugger. Of course, there
  978. may be no debugger attached, in which case no action is taken
  979. Return Value:
  980. None.
  981. --*/
  982. {
  983. int buflen;
  984. DWORD written;
  985. buflen = strlen(Buffer);
  986. if ((InternetDebugControlFlags & DBG_TO_FILE)
  987. && (InternetDebugFileHandle != INVALID_HANDLE_VALUE)) {
  988. WriteFile(InternetDebugFileHandle, Buffer, buflen, &written, NULL);
  989. if (InternetDebugControlFlags & DBG_FLUSH_OUTPUT) {
  990. InternetFlushDebugFile();
  991. }
  992. }
  993. if (InternetDebugControlFlags & DBG_TO_CONSOLE) {
  994. WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE),
  995. Buffer,
  996. buflen,
  997. &written,
  998. 0
  999. );
  1000. }
  1001. if (Assert || (InternetDebugControlFlags & DBG_TO_DEBUGGER)) {
  1002. OutputDebugString(Buffer);
  1003. }
  1004. }
  1005. VOID
  1006. InternetDebugDump(
  1007. IN LPSTR Text,
  1008. IN LPBYTE Address,
  1009. IN DWORD Size
  1010. )
  1011. /*++
  1012. Routine Description:
  1013. Dumps Size bytes at Address, in the time-honoured debug tradition
  1014. Arguments:
  1015. Text - to display before dumping data
  1016. Address - start of buffer
  1017. Size - number of bytes
  1018. Return Value:
  1019. None.
  1020. --*/
  1021. {
  1022. //
  1023. // if flags say no data dumps then quit
  1024. //
  1025. if (InternetDebugControlFlags & (DBG_NO_DEBUG | DBG_NO_DATA_DUMP)) {
  1026. return;
  1027. }
  1028. //
  1029. // display the introduction text, if any
  1030. //
  1031. if (Text) {
  1032. if (InternetDebugControlFlags & DBG_INDENT_DUMP) {
  1033. InternetDebugPrint(Text);
  1034. } else {
  1035. InternetDebugOut(Text, FALSE);
  1036. }
  1037. }
  1038. char buf[128];
  1039. //
  1040. // display a line telling us how much data there is, if requested to
  1041. //
  1042. if (InternetDebugControlFlags & DBG_DUMP_LENGTH) {
  1043. rsprintf(buf, "%d (%#x) bytes @ %#x\n", Size, Size, Address);
  1044. if (InternetDebugControlFlags & DBG_INDENT_DUMP) {
  1045. InternetDebugPrintString(buf);
  1046. } else {
  1047. InternetDebugOut(buf, FALSE);
  1048. }
  1049. }
  1050. //
  1051. // dump out the data, debug style
  1052. //
  1053. while (Size) {
  1054. int len = InternetDebugDumpFormat(Address, Size, sizeof(BYTE), buf);
  1055. //
  1056. // if we are to indent the data to the current level, then display the
  1057. // buffer via InternetDebugPrint() which will apply all the thread id,
  1058. // indentation, and other options selected, else just display the data
  1059. // via InternetDebugOut(), which will simply send it to the output media
  1060. //
  1061. if (InternetDebugControlFlags & DBG_INDENT_DUMP) {
  1062. InternetDebugPrintString(buf);
  1063. } else {
  1064. InternetDebugOut(buf, FALSE);
  1065. }
  1066. Address += len;
  1067. Size -= len;
  1068. }
  1069. }
  1070. DWORD
  1071. InternetDebugDumpFormat(
  1072. IN LPBYTE Address,
  1073. IN DWORD Size,
  1074. IN DWORD ElementSize,
  1075. OUT LPSTR Buffer
  1076. )
  1077. /*++
  1078. Routine Description:
  1079. Formats Size bytes at Address, in the time-honoured debug tradition, for
  1080. data dump purposes
  1081. Arguments:
  1082. Address - start of buffer
  1083. Size - number of bytes
  1084. ElementSize - size of each word element in bytes
  1085. Buffer - pointer to output buffer, assumed to be large enough
  1086. Return Value:
  1087. DWORD - number of bytes formatted
  1088. --*/
  1089. {
  1090. //
  1091. // we (currently) only understand DWORD, WORD and BYTE dumps
  1092. //
  1093. if ((ElementSize != sizeof(DWORD)) && (ElementSize != sizeof(WORD))) {
  1094. ElementSize = sizeof(BYTE);
  1095. }
  1096. static char spaces[] = " "; // 15 * 3 + 2
  1097. int i, len;
  1098. len = min(Size, 16);
  1099. rsprintf(Buffer, "%08x ", Address);
  1100. //
  1101. // dump the hex representation of each character or word - up to 16 per line
  1102. //
  1103. DWORD offset = 10;
  1104. for (i = 0; i < len; i += ElementSize) {
  1105. DWORD value;
  1106. LPSTR formatString;
  1107. switch (ElementSize) {
  1108. case 4:
  1109. formatString = "%08x ";
  1110. value = *(LPDWORD)&Address[i];
  1111. break;
  1112. case 2:
  1113. formatString = "%04x ";
  1114. value = *(LPWORD)&Address[i] & 0xffff;
  1115. break;
  1116. default:
  1117. formatString = ((i & 15) == 7) ? "%02.2x-" : "%02.2x ";
  1118. value = Address[i] & 0xff;
  1119. break;
  1120. }
  1121. rsprintf(&Buffer[offset], formatString, value);
  1122. offset += ElementSize * 2 + 1;
  1123. }
  1124. //
  1125. // write as many spaces as required to tab to ASCII field
  1126. //
  1127. memcpy(&Buffer[offset], spaces, (16 - len) * 3 + 2);
  1128. offset += (16 - len) * 3 + 2;
  1129. //
  1130. // dump ASCII representation of each character
  1131. //
  1132. for (i = 0; i < len; ++i) {
  1133. char ch;
  1134. ch = Address[i];
  1135. Buffer[offset + i] = ((ch < 32) || (ch > 127)) ? '.' : ch;
  1136. }
  1137. Buffer[offset + i++] = '\r';
  1138. Buffer[offset + i++] = '\n';
  1139. Buffer[offset + i] = '\0';
  1140. return len;
  1141. }
  1142. VOID
  1143. InternetAssert(
  1144. IN LPSTR Assertion,
  1145. IN LPSTR FileName,
  1146. IN DWORD LineNumber
  1147. )
  1148. /*++
  1149. Routine Description:
  1150. displays assertion message at debugger and raised breakpoint exception
  1151. Arguments:
  1152. Assertion - string describing assertion which failed
  1153. FileName - module where assertion failure occurred
  1154. LineNumber - at this line number
  1155. Return Value:
  1156. None.
  1157. --*/
  1158. {
  1159. char buffer[512];
  1160. rsprintf(buffer,
  1161. "\n"
  1162. "*** Wininet Assertion failed: %s\n"
  1163. "*** Source file: %s\n"
  1164. "*** Source line: %d\n"
  1165. "*** Thread %08x\n"
  1166. "\n",
  1167. Assertion,
  1168. FileName,
  1169. LineNumber,
  1170. GetCurrentThreadId()
  1171. );
  1172. InternetDebugOut(buffer, TRUE);
  1173. //
  1174. // break to the debugger, unless it is requested that we don't
  1175. //
  1176. if (!(InternetDebugControlFlags & DBG_NO_ASSERT_BREAK)) {
  1177. DebugBreak();
  1178. }
  1179. }
  1180. VOID
  1181. InternetGetDebugVariable(
  1182. IN LPSTR lpszVariableName,
  1183. OUT LPDWORD lpdwVariable
  1184. )
  1185. /*++
  1186. Routine Description:
  1187. Get debug variable. First examine environment, then registry
  1188. Arguments:
  1189. lpszVariableName - variable name
  1190. lpdwVariable - returned variable
  1191. Return Value:
  1192. None.
  1193. --*/
  1194. {
  1195. DWORD len;
  1196. char varbuf[ENVIRONMENT_VARIABLE_BUFFER_LENGTH];
  1197. //
  1198. // get the debug variables first from the environment, then - if not there -
  1199. // from the registry
  1200. //
  1201. len = GetEnvironmentVariable(lpszVariableName, varbuf, sizeof(varbuf));
  1202. if (len && len < sizeof(varbuf)) {
  1203. *lpdwVariable = (DWORD)strtoul(varbuf, NULL, 0);
  1204. } else {
  1205. InternetReadRegistryDword(lpszVariableName, lpdwVariable);
  1206. }
  1207. }
  1208. PRIVATE
  1209. VOID
  1210. InternetGetDebugVariableString(
  1211. IN LPSTR lpszVariableName,
  1212. OUT LPSTR lpszVariable,
  1213. IN DWORD dwVariableLen
  1214. )
  1215. /*++
  1216. Routine Description:
  1217. Get debug variable string. First examine environment, then registry
  1218. Arguments:
  1219. lpszVariableName - variable name
  1220. lpszVariable - returned string variable
  1221. dwVariableLen - size of buffer
  1222. Return Value:
  1223. None.
  1224. --*/
  1225. {
  1226. if (GetEnvironmentVariable(lpszVariableName, lpszVariable, dwVariableLen) == 0) {
  1227. char buf[MAX_PATH + 1];
  1228. DWORD len = min(sizeof(buf), dwVariableLen);
  1229. if (InternetReadRegistryString(lpszVariableName, buf, &len) == ERROR_SUCCESS) {
  1230. memcpy(lpszVariable, buf, len + 1);
  1231. }
  1232. }
  1233. }
  1234. LPSTR
  1235. InternetMapChunkToken(
  1236. IN CHUNK_TOKEN ctToken
  1237. )
  1238. {
  1239. switch(ctToken)
  1240. {
  1241. CASE_OF(CHUNK_TOKEN_DIGIT);
  1242. CASE_OF(CHUNK_TOKEN_DATA);
  1243. CASE_OF(CHUNK_TOKEN_COLON);
  1244. CASE_OF(CHUNK_TOKEN_CR);
  1245. CASE_OF(CHUNK_TOKEN_LF);
  1246. CASE_OF(CHUNK_TOKEN_INVALID);
  1247. default:
  1248. return "?";
  1249. }
  1250. }
  1251. LPSTR
  1252. InternetMapChunkState(
  1253. IN CHUNK_STATE csState
  1254. )
  1255. {
  1256. switch(csState)
  1257. {
  1258. CASE_OF(CHUNK_STATE_START);
  1259. CASE_OF(CHUNK_STATE_SIZE_PARSE);
  1260. CASE_OF(CHUNK_STATE_SIZE_CRLF);
  1261. CASE_OF(CHUNK_STATE_DATA_PARSE);
  1262. CASE_OF(CHUNK_STATE_DATA_CRLF);
  1263. CASE_OF(CHUNK_STATE_ZERO_FOOTER);
  1264. CASE_OF(CHUNK_STATE_ZERO_FOOTER_NAME);
  1265. CASE_OF(CHUNK_STATE_ZERO_FOOTER_VALUE);
  1266. CASE_OF(CHUNK_STATE_ZERO_FOOTER_CRLF);
  1267. CASE_OF(CHUNK_STATE_ZERO_FOOTER_FINAL_CRLF);
  1268. CASE_OF(CHUNK_STATE_FINISHED);
  1269. default:
  1270. return "?";
  1271. }
  1272. }
  1273. LPSTR
  1274. InternetMapError(
  1275. IN DWORD Error
  1276. )
  1277. /*++
  1278. Routine Description:
  1279. Map error code to string. Try to get all errors that might ever be returned
  1280. by an Internet function
  1281. Arguments:
  1282. Error - code to map
  1283. Return Value:
  1284. LPSTR - pointer to symbolic error name
  1285. --*/
  1286. {
  1287. switch (Error) {
  1288. //
  1289. // WINERROR errors
  1290. //
  1291. CASE_OF(ERROR_SUCCESS);
  1292. CASE_OF(ERROR_INVALID_FUNCTION);
  1293. CASE_OF(ERROR_FILE_NOT_FOUND);
  1294. CASE_OF(ERROR_PATH_NOT_FOUND);
  1295. CASE_OF(ERROR_TOO_MANY_OPEN_FILES);
  1296. CASE_OF(ERROR_ACCESS_DENIED);
  1297. CASE_OF(ERROR_INVALID_HANDLE);
  1298. CASE_OF(ERROR_ARENA_TRASHED);
  1299. CASE_OF(ERROR_NOT_ENOUGH_MEMORY);
  1300. CASE_OF(ERROR_INVALID_BLOCK);
  1301. CASE_OF(ERROR_BAD_ENVIRONMENT);
  1302. CASE_OF(ERROR_BAD_FORMAT);
  1303. CASE_OF(ERROR_INVALID_ACCESS);
  1304. CASE_OF(ERROR_INVALID_DATA);
  1305. CASE_OF(ERROR_OUTOFMEMORY);
  1306. CASE_OF(ERROR_INVALID_DRIVE);
  1307. CASE_OF(ERROR_CURRENT_DIRECTORY);
  1308. CASE_OF(ERROR_NOT_SAME_DEVICE);
  1309. CASE_OF(ERROR_NO_MORE_FILES);
  1310. CASE_OF(ERROR_WRITE_PROTECT);
  1311. CASE_OF(ERROR_BAD_UNIT);
  1312. CASE_OF(ERROR_NOT_READY);
  1313. CASE_OF(ERROR_BAD_COMMAND);
  1314. CASE_OF(ERROR_CRC);
  1315. CASE_OF(ERROR_BAD_LENGTH);
  1316. CASE_OF(ERROR_SEEK);
  1317. CASE_OF(ERROR_NOT_DOS_DISK);
  1318. CASE_OF(ERROR_SECTOR_NOT_FOUND);
  1319. CASE_OF(ERROR_OUT_OF_PAPER);
  1320. CASE_OF(ERROR_WRITE_FAULT);
  1321. CASE_OF(ERROR_READ_FAULT);
  1322. CASE_OF(ERROR_GEN_FAILURE);
  1323. CASE_OF(ERROR_SHARING_VIOLATION);
  1324. CASE_OF(ERROR_LOCK_VIOLATION);
  1325. CASE_OF(ERROR_WRONG_DISK);
  1326. CASE_OF(ERROR_SHARING_BUFFER_EXCEEDED);
  1327. CASE_OF(ERROR_HANDLE_EOF);
  1328. CASE_OF(ERROR_HANDLE_DISK_FULL);
  1329. CASE_OF(ERROR_NOT_SUPPORTED);
  1330. CASE_OF(ERROR_REM_NOT_LIST);
  1331. CASE_OF(ERROR_DUP_NAME);
  1332. CASE_OF(ERROR_BAD_NETPATH);
  1333. CASE_OF(ERROR_NETWORK_BUSY);
  1334. CASE_OF(ERROR_DEV_NOT_EXIST);
  1335. CASE_OF(ERROR_TOO_MANY_CMDS);
  1336. CASE_OF(ERROR_ADAP_HDW_ERR);
  1337. CASE_OF(ERROR_BAD_NET_RESP);
  1338. CASE_OF(ERROR_UNEXP_NET_ERR);
  1339. CASE_OF(ERROR_BAD_REM_ADAP);
  1340. CASE_OF(ERROR_PRINTQ_FULL);
  1341. CASE_OF(ERROR_NO_SPOOL_SPACE);
  1342. CASE_OF(ERROR_PRINT_CANCELLED);
  1343. CASE_OF(ERROR_NETNAME_DELETED);
  1344. CASE_OF(ERROR_NETWORK_ACCESS_DENIED);
  1345. CASE_OF(ERROR_BAD_DEV_TYPE);
  1346. CASE_OF(ERROR_BAD_NET_NAME);
  1347. CASE_OF(ERROR_TOO_MANY_NAMES);
  1348. CASE_OF(ERROR_TOO_MANY_SESS);
  1349. CASE_OF(ERROR_SHARING_PAUSED);
  1350. CASE_OF(ERROR_REQ_NOT_ACCEP);
  1351. CASE_OF(ERROR_REDIR_PAUSED);
  1352. CASE_OF(ERROR_FILE_EXISTS);
  1353. CASE_OF(ERROR_CANNOT_MAKE);
  1354. CASE_OF(ERROR_FAIL_I24);
  1355. CASE_OF(ERROR_OUT_OF_STRUCTURES);
  1356. CASE_OF(ERROR_ALREADY_ASSIGNED);
  1357. CASE_OF(ERROR_INVALID_PASSWORD);
  1358. CASE_OF(ERROR_INVALID_PARAMETER);
  1359. CASE_OF(ERROR_NET_WRITE_FAULT);
  1360. CASE_OF(ERROR_NO_PROC_SLOTS);
  1361. CASE_OF(ERROR_TOO_MANY_SEMAPHORES);
  1362. CASE_OF(ERROR_EXCL_SEM_ALREADY_OWNED);
  1363. CASE_OF(ERROR_SEM_IS_SET);
  1364. CASE_OF(ERROR_TOO_MANY_SEM_REQUESTS);
  1365. CASE_OF(ERROR_INVALID_AT_INTERRUPT_TIME);
  1366. CASE_OF(ERROR_SEM_OWNER_DIED);
  1367. CASE_OF(ERROR_SEM_USER_LIMIT);
  1368. CASE_OF(ERROR_DISK_CHANGE);
  1369. CASE_OF(ERROR_DRIVE_LOCKED);
  1370. CASE_OF(ERROR_BROKEN_PIPE);
  1371. CASE_OF(ERROR_OPEN_FAILED);
  1372. CASE_OF(ERROR_BUFFER_OVERFLOW);
  1373. CASE_OF(ERROR_DISK_FULL);
  1374. CASE_OF(ERROR_NO_MORE_SEARCH_HANDLES);
  1375. CASE_OF(ERROR_INVALID_TARGET_HANDLE);
  1376. CASE_OF(ERROR_INVALID_CATEGORY);
  1377. CASE_OF(ERROR_INVALID_VERIFY_SWITCH);
  1378. CASE_OF(ERROR_BAD_DRIVER_LEVEL);
  1379. CASE_OF(ERROR_CALL_NOT_IMPLEMENTED);
  1380. CASE_OF(ERROR_SEM_TIMEOUT);
  1381. CASE_OF(ERROR_INSUFFICIENT_BUFFER);
  1382. CASE_OF(ERROR_INVALID_NAME);
  1383. CASE_OF(ERROR_INVALID_LEVEL);
  1384. CASE_OF(ERROR_NO_VOLUME_LABEL);
  1385. CASE_OF(ERROR_MOD_NOT_FOUND);
  1386. CASE_OF(ERROR_PROC_NOT_FOUND);
  1387. CASE_OF(ERROR_WAIT_NO_CHILDREN);
  1388. CASE_OF(ERROR_CHILD_NOT_COMPLETE);
  1389. CASE_OF(ERROR_DIRECT_ACCESS_HANDLE);
  1390. CASE_OF(ERROR_NEGATIVE_SEEK);
  1391. CASE_OF(ERROR_SEEK_ON_DEVICE);
  1392. CASE_OF(ERROR_DIR_NOT_ROOT);
  1393. CASE_OF(ERROR_DIR_NOT_EMPTY);
  1394. CASE_OF(ERROR_PATH_BUSY);
  1395. CASE_OF(ERROR_SYSTEM_TRACE);
  1396. CASE_OF(ERROR_INVALID_EVENT_COUNT);
  1397. CASE_OF(ERROR_TOO_MANY_MUXWAITERS);
  1398. CASE_OF(ERROR_INVALID_LIST_FORMAT);
  1399. CASE_OF(ERROR_BAD_ARGUMENTS);
  1400. CASE_OF(ERROR_BAD_PATHNAME);
  1401. CASE_OF(ERROR_BUSY);
  1402. CASE_OF(ERROR_CANCEL_VIOLATION);
  1403. CASE_OF(ERROR_ALREADY_EXISTS);
  1404. CASE_OF(ERROR_FILENAME_EXCED_RANGE);
  1405. CASE_OF(ERROR_LOCKED);
  1406. CASE_OF(ERROR_NESTING_NOT_ALLOWED);
  1407. CASE_OF(ERROR_BAD_PIPE);
  1408. CASE_OF(ERROR_PIPE_BUSY);
  1409. CASE_OF(ERROR_NO_DATA);
  1410. CASE_OF(ERROR_PIPE_NOT_CONNECTED);
  1411. CASE_OF(ERROR_MORE_DATA);
  1412. CASE_OF(ERROR_NO_MORE_ITEMS);
  1413. CASE_OF(ERROR_NOT_OWNER);
  1414. CASE_OF(ERROR_PARTIAL_COPY);
  1415. CASE_OF(ERROR_MR_MID_NOT_FOUND);
  1416. CASE_OF(ERROR_INVALID_ADDRESS);
  1417. CASE_OF(ERROR_PIPE_CONNECTED);
  1418. CASE_OF(ERROR_PIPE_LISTENING);
  1419. CASE_OF(ERROR_OPERATION_ABORTED);
  1420. CASE_OF(ERROR_IO_INCOMPLETE);
  1421. CASE_OF(ERROR_IO_PENDING);
  1422. CASE_OF(ERROR_NOACCESS);
  1423. CASE_OF(ERROR_STACK_OVERFLOW);
  1424. CASE_OF(ERROR_INVALID_FLAGS);
  1425. CASE_OF(ERROR_NO_TOKEN);
  1426. CASE_OF(ERROR_BADDB);
  1427. CASE_OF(ERROR_BADKEY);
  1428. CASE_OF(ERROR_CANTOPEN);
  1429. CASE_OF(ERROR_CANTREAD);
  1430. CASE_OF(ERROR_CANTWRITE);
  1431. CASE_OF(ERROR_REGISTRY_RECOVERED);
  1432. CASE_OF(ERROR_REGISTRY_CORRUPT);
  1433. CASE_OF(ERROR_REGISTRY_IO_FAILED);
  1434. CASE_OF(ERROR_NOT_REGISTRY_FILE);
  1435. CASE_OF(ERROR_KEY_DELETED);
  1436. CASE_OF(ERROR_CIRCULAR_DEPENDENCY);
  1437. CASE_OF(ERROR_SERVICE_NOT_ACTIVE);
  1438. CASE_OF(ERROR_DLL_INIT_FAILED);
  1439. CASE_OF(ERROR_CANCELLED);
  1440. CASE_OF(ERROR_BAD_USERNAME);
  1441. CASE_OF(ERROR_LOGON_FAILURE);
  1442. CASE_OF(WAIT_FAILED);
  1443. //CASE_OF(WAIT_ABANDONED_0);
  1444. CASE_OF(WAIT_TIMEOUT);
  1445. CASE_OF(WAIT_IO_COMPLETION);
  1446. //CASE_OF(STILL_ACTIVE);
  1447. CASE_OF(RPC_S_INVALID_STRING_BINDING);
  1448. CASE_OF(RPC_S_WRONG_KIND_OF_BINDING);
  1449. CASE_OF(RPC_S_INVALID_BINDING);
  1450. CASE_OF(RPC_S_PROTSEQ_NOT_SUPPORTED);
  1451. CASE_OF(RPC_S_INVALID_RPC_PROTSEQ);
  1452. CASE_OF(RPC_S_INVALID_STRING_UUID);
  1453. CASE_OF(RPC_S_INVALID_ENDPOINT_FORMAT);
  1454. CASE_OF(RPC_S_INVALID_NET_ADDR);
  1455. CASE_OF(RPC_S_NO_ENDPOINT_FOUND);
  1456. CASE_OF(RPC_S_INVALID_TIMEOUT);
  1457. CASE_OF(RPC_S_OBJECT_NOT_FOUND);
  1458. CASE_OF(RPC_S_ALREADY_REGISTERED);
  1459. CASE_OF(RPC_S_TYPE_ALREADY_REGISTERED);
  1460. CASE_OF(RPC_S_ALREADY_LISTENING);
  1461. CASE_OF(RPC_S_NO_PROTSEQS_REGISTERED);
  1462. CASE_OF(RPC_S_NOT_LISTENING);
  1463. CASE_OF(RPC_S_UNKNOWN_MGR_TYPE);
  1464. CASE_OF(RPC_S_UNKNOWN_IF);
  1465. CASE_OF(RPC_S_NO_BINDINGS);
  1466. CASE_OF(RPC_S_NO_PROTSEQS);
  1467. CASE_OF(RPC_S_CANT_CREATE_ENDPOINT);
  1468. CASE_OF(RPC_S_OUT_OF_RESOURCES);
  1469. CASE_OF(RPC_S_SERVER_UNAVAILABLE);
  1470. CASE_OF(RPC_S_SERVER_TOO_BUSY);
  1471. CASE_OF(RPC_S_INVALID_NETWORK_OPTIONS);
  1472. CASE_OF(RPC_S_NO_CALL_ACTIVE);
  1473. CASE_OF(RPC_S_CALL_FAILED);
  1474. CASE_OF(RPC_S_CALL_FAILED_DNE);
  1475. CASE_OF(RPC_S_PROTOCOL_ERROR);
  1476. CASE_OF(RPC_S_UNSUPPORTED_TRANS_SYN);
  1477. CASE_OF(RPC_S_UNSUPPORTED_TYPE);
  1478. CASE_OF(RPC_S_INVALID_TAG);
  1479. CASE_OF(RPC_S_INVALID_BOUND);
  1480. CASE_OF(RPC_S_NO_ENTRY_NAME);
  1481. CASE_OF(RPC_S_INVALID_NAME_SYNTAX);
  1482. CASE_OF(RPC_S_UNSUPPORTED_NAME_SYNTAX);
  1483. CASE_OF(RPC_S_UUID_NO_ADDRESS);
  1484. CASE_OF(RPC_S_DUPLICATE_ENDPOINT);
  1485. CASE_OF(RPC_S_UNKNOWN_AUTHN_TYPE);
  1486. CASE_OF(RPC_S_MAX_CALLS_TOO_SMALL);
  1487. CASE_OF(RPC_S_STRING_TOO_LONG);
  1488. CASE_OF(RPC_S_PROTSEQ_NOT_FOUND);
  1489. CASE_OF(RPC_S_PROCNUM_OUT_OF_RANGE);
  1490. CASE_OF(RPC_S_BINDING_HAS_NO_AUTH);
  1491. CASE_OF(RPC_S_UNKNOWN_AUTHN_SERVICE);
  1492. CASE_OF(RPC_S_UNKNOWN_AUTHN_LEVEL);
  1493. CASE_OF(RPC_S_INVALID_AUTH_IDENTITY);
  1494. CASE_OF(RPC_S_UNKNOWN_AUTHZ_SERVICE);
  1495. CASE_OF(EPT_S_INVALID_ENTRY);
  1496. CASE_OF(EPT_S_CANT_PERFORM_OP);
  1497. CASE_OF(EPT_S_NOT_REGISTERED);
  1498. CASE_OF(RPC_S_NOTHING_TO_EXPORT);
  1499. CASE_OF(RPC_S_INCOMPLETE_NAME);
  1500. CASE_OF(RPC_S_INVALID_VERS_OPTION);
  1501. CASE_OF(RPC_S_NO_MORE_MEMBERS);
  1502. CASE_OF(RPC_S_NOT_ALL_OBJS_UNEXPORTED);
  1503. CASE_OF(RPC_S_INTERFACE_NOT_FOUND);
  1504. CASE_OF(RPC_S_ENTRY_ALREADY_EXISTS);
  1505. CASE_OF(RPC_S_ENTRY_NOT_FOUND);
  1506. CASE_OF(RPC_S_NAME_SERVICE_UNAVAILABLE);
  1507. CASE_OF(RPC_S_INVALID_NAF_ID);
  1508. CASE_OF(RPC_S_CANNOT_SUPPORT);
  1509. CASE_OF(RPC_S_NO_CONTEXT_AVAILABLE);
  1510. CASE_OF(RPC_S_INTERNAL_ERROR);
  1511. CASE_OF(RPC_S_ZERO_DIVIDE);
  1512. CASE_OF(RPC_S_ADDRESS_ERROR);
  1513. CASE_OF(RPC_S_FP_DIV_ZERO);
  1514. CASE_OF(RPC_S_FP_UNDERFLOW);
  1515. CASE_OF(RPC_S_FP_OVERFLOW);
  1516. CASE_OF(RPC_X_NO_MORE_ENTRIES);
  1517. CASE_OF(RPC_X_SS_CHAR_TRANS_OPEN_FAIL);
  1518. CASE_OF(RPC_X_SS_CHAR_TRANS_SHORT_FILE);
  1519. CASE_OF(RPC_X_SS_IN_NULL_CONTEXT);
  1520. CASE_OF(RPC_X_SS_CONTEXT_DAMAGED);
  1521. CASE_OF(RPC_X_SS_HANDLES_MISMATCH);
  1522. CASE_OF(RPC_X_SS_CANNOT_GET_CALL_HANDLE);
  1523. CASE_OF(RPC_X_NULL_REF_POINTER);
  1524. CASE_OF(RPC_X_ENUM_VALUE_OUT_OF_RANGE);
  1525. CASE_OF(RPC_X_BYTE_COUNT_TOO_SMALL);
  1526. CASE_OF(RPC_X_BAD_STUB_DATA);
  1527. //
  1528. // WININET errors
  1529. //
  1530. CASE_OF(ERROR_INTERNET_OUT_OF_HANDLES);
  1531. CASE_OF(ERROR_INTERNET_TIMEOUT);
  1532. CASE_OF(ERROR_INTERNET_EXTENDED_ERROR);
  1533. CASE_OF(ERROR_INTERNET_INTERNAL_ERROR);
  1534. CASE_OF(ERROR_INTERNET_INVALID_URL);
  1535. CASE_OF(ERROR_INTERNET_UNRECOGNIZED_SCHEME);
  1536. CASE_OF(ERROR_INTERNET_NAME_NOT_RESOLVED);
  1537. CASE_OF(ERROR_INTERNET_PROTOCOL_NOT_FOUND);
  1538. CASE_OF(ERROR_INTERNET_INVALID_OPTION);
  1539. CASE_OF(ERROR_INTERNET_BAD_OPTION_LENGTH);
  1540. CASE_OF(ERROR_INTERNET_OPTION_NOT_SETTABLE);
  1541. CASE_OF(ERROR_INTERNET_SHUTDOWN);
  1542. CASE_OF(ERROR_INTERNET_INCORRECT_USER_NAME);
  1543. CASE_OF(ERROR_INTERNET_INCORRECT_PASSWORD);
  1544. CASE_OF(ERROR_INTERNET_LOGIN_FAILURE);
  1545. CASE_OF(ERROR_INTERNET_INVALID_OPERATION);
  1546. CASE_OF(ERROR_INTERNET_OPERATION_CANCELLED);
  1547. CASE_OF(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
  1548. CASE_OF(ERROR_INTERNET_INCORRECT_HANDLE_STATE);
  1549. CASE_OF(ERROR_INTERNET_NOT_PROXY_REQUEST);
  1550. CASE_OF(ERROR_INTERNET_REGISTRY_VALUE_NOT_FOUND);
  1551. CASE_OF(ERROR_INTERNET_BAD_REGISTRY_PARAMETER);
  1552. CASE_OF(ERROR_INTERNET_NO_DIRECT_ACCESS);
  1553. CASE_OF(ERROR_INTERNET_NO_CONTEXT);
  1554. CASE_OF(ERROR_INTERNET_NO_CALLBACK);
  1555. CASE_OF(ERROR_INTERNET_REQUEST_PENDING);
  1556. CASE_OF(ERROR_INTERNET_INCORRECT_FORMAT);
  1557. CASE_OF(ERROR_INTERNET_ITEM_NOT_FOUND);
  1558. CASE_OF(ERROR_INTERNET_CANNOT_CONNECT);
  1559. CASE_OF(ERROR_INTERNET_CONNECTION_ABORTED);
  1560. CASE_OF(ERROR_INTERNET_CONNECTION_RESET);
  1561. CASE_OF(ERROR_INTERNET_FORCE_RETRY);
  1562. CASE_OF(ERROR_INTERNET_INVALID_PROXY_REQUEST);
  1563. CASE_OF(ERROR_INTERNET_NEED_UI);
  1564. CASE_OF(ERROR_INTERNET_HANDLE_EXISTS);
  1565. CASE_OF(ERROR_INTERNET_SEC_CERT_DATE_INVALID);
  1566. CASE_OF(ERROR_INTERNET_SEC_CERT_CN_INVALID);
  1567. CASE_OF(ERROR_INTERNET_HTTP_TO_HTTPS_ON_REDIR);
  1568. CASE_OF(ERROR_INTERNET_HTTPS_TO_HTTP_ON_REDIR);
  1569. CASE_OF(ERROR_INTERNET_MIXED_SECURITY);
  1570. CASE_OF(ERROR_INTERNET_CHG_POST_IS_NON_SECURE);
  1571. CASE_OF(ERROR_INTERNET_POST_IS_NON_SECURE);
  1572. CASE_OF(ERROR_INTERNET_CLIENT_AUTH_CERT_NEEDED);
  1573. CASE_OF(ERROR_INTERNET_INVALID_CA);
  1574. CASE_OF(ERROR_INTERNET_CLIENT_AUTH_NOT_SETUP);
  1575. CASE_OF(ERROR_INTERNET_ASYNC_THREAD_FAILED);
  1576. CASE_OF(ERROR_INTERNET_REDIRECT_SCHEME_CHANGE);
  1577. CASE_OF(ERROR_INTERNET_DIALOG_PENDING);
  1578. CASE_OF(ERROR_INTERNET_RETRY_DIALOG);
  1579. CASE_OF(ERROR_INTERNET_NO_NEW_CONTAINERS);
  1580. CASE_OF(ERROR_INTERNET_HTTPS_HTTP_SUBMIT_REDIR);
  1581. CASE_OF(ERROR_INTERNET_INSERT_CDROM);
  1582. CASE_OF(ERROR_INTERNET_FORTEZZA_LOGIN_NEEDED);
  1583. CASE_OF(ERROR_INTERNET_SEC_CERT_ERRORS);
  1584. CASE_OF(ERROR_INTERNET_SECURITY_CHANNEL_ERROR);
  1585. CASE_OF(ERROR_INTERNET_UNABLE_TO_CACHE_FILE);
  1586. CASE_OF(ERROR_INTERNET_TCPIP_NOT_INSTALLED);
  1587. CASE_OF(ERROR_INTERNET_OFFLINE);
  1588. CASE_OF(ERROR_INTERNET_SERVER_UNREACHABLE);
  1589. CASE_OF(ERROR_INTERNET_PROXY_SERVER_UNREACHABLE);
  1590. CASE_OF(ERROR_INTERNET_BAD_AUTO_PROXY_SCRIPT);
  1591. CASE_OF(ERROR_INTERNET_UNABLE_TO_DOWNLOAD_SCRIPT);
  1592. CASE_OF(ERROR_INTERNET_SEC_INVALID_CERT);
  1593. CASE_OF(ERROR_INTERNET_SEC_CERT_REVOKED);
  1594. CASE_OF(ERROR_INTERNET_FAILED_DUETOSECURITYCHECK);
  1595. CASE_OF(ERROR_INTERNET_NOT_INITIALIZED);
  1596. CASE_OF(ERROR_FTP_TRANSFER_IN_PROGRESS);
  1597. CASE_OF(ERROR_FTP_DROPPED);
  1598. CASE_OF(ERROR_FTP_NO_PASSIVE_MODE);
  1599. CASE_OF(ERROR_GOPHER_PROTOCOL_ERROR);
  1600. CASE_OF(ERROR_GOPHER_NOT_FILE);
  1601. CASE_OF(ERROR_GOPHER_DATA_ERROR);
  1602. CASE_OF(ERROR_GOPHER_END_OF_DATA);
  1603. CASE_OF(ERROR_GOPHER_INVALID_LOCATOR);
  1604. CASE_OF(ERROR_GOPHER_INCORRECT_LOCATOR_TYPE);
  1605. CASE_OF(ERROR_GOPHER_NOT_GOPHER_PLUS);
  1606. CASE_OF(ERROR_GOPHER_ATTRIBUTE_NOT_FOUND);
  1607. CASE_OF(ERROR_GOPHER_UNKNOWN_LOCATOR);
  1608. CASE_OF(ERROR_HTTP_HEADER_NOT_FOUND);
  1609. CASE_OF(ERROR_HTTP_DOWNLEVEL_SERVER);
  1610. CASE_OF(ERROR_HTTP_INVALID_SERVER_RESPONSE);
  1611. CASE_OF(ERROR_HTTP_INVALID_HEADER);
  1612. CASE_OF(ERROR_HTTP_INVALID_QUERY_REQUEST);
  1613. CASE_OF(ERROR_HTTP_HEADER_ALREADY_EXISTS);
  1614. CASE_OF(ERROR_HTTP_REDIRECT_FAILED);
  1615. CASE_OF(ERROR_HTTP_NOT_REDIRECTED);
  1616. CASE_OF(ERROR_HTTP_COOKIE_NEEDS_CONFIRMATION);
  1617. CASE_OF(ERROR_HTTP_COOKIE_DECLINED);
  1618. CASE_OF(ERROR_HTTP_REDIRECT_NEEDS_CONFIRMATION);
  1619. //
  1620. // internal WININET errors
  1621. //
  1622. CASE_OF(ERROR_INTERNET_INTERNAL_SOCKET_ERROR);
  1623. CASE_OF(ERROR_INTERNET_CONNECTION_AVAILABLE);
  1624. CASE_OF(ERROR_INTERNET_NO_KNOWN_SERVERS);
  1625. CASE_OF(ERROR_INTERNET_PING_FAILED);
  1626. CASE_OF(ERROR_INTERNET_NO_PING_SUPPORT);
  1627. CASE_OF(ERROR_INTERNET_CACHE_SUCCESS);
  1628. //
  1629. // SSPI errors
  1630. //
  1631. CASE_OF(SEC_E_INSUFFICIENT_MEMORY);
  1632. CASE_OF(SEC_E_INVALID_HANDLE);
  1633. CASE_OF(SEC_E_UNSUPPORTED_FUNCTION);
  1634. CASE_OF(SEC_E_TARGET_UNKNOWN);
  1635. CASE_OF(SEC_E_INTERNAL_ERROR);
  1636. CASE_OF(SEC_E_SECPKG_NOT_FOUND);
  1637. CASE_OF(SEC_E_NOT_OWNER);
  1638. CASE_OF(SEC_E_CANNOT_INSTALL);
  1639. CASE_OF(SEC_E_INVALID_TOKEN);
  1640. CASE_OF(SEC_E_CANNOT_PACK);
  1641. CASE_OF(SEC_E_QOP_NOT_SUPPORTED);
  1642. CASE_OF(SEC_E_NO_IMPERSONATION);
  1643. CASE_OF(SEC_E_LOGON_DENIED);
  1644. CASE_OF(SEC_E_UNKNOWN_CREDENTIALS);
  1645. CASE_OF(SEC_E_NO_CREDENTIALS);
  1646. CASE_OF(SEC_E_MESSAGE_ALTERED);
  1647. CASE_OF(SEC_E_OUT_OF_SEQUENCE);
  1648. CASE_OF(SEC_E_NO_AUTHENTICATING_AUTHORITY);
  1649. CASE_OF(SEC_I_CONTINUE_NEEDED);
  1650. CASE_OF(SEC_I_COMPLETE_NEEDED);
  1651. CASE_OF(SEC_I_COMPLETE_AND_CONTINUE);
  1652. CASE_OF(SEC_I_LOCAL_LOGON);
  1653. CASE_OF(SEC_E_BAD_PKGID);
  1654. CASE_OF(SEC_E_CONTEXT_EXPIRED);
  1655. CASE_OF(SEC_E_INCOMPLETE_MESSAGE);
  1656. CASE_OF(SEC_E_WRONG_PRINCIPAL);
  1657. //
  1658. // WINSOCK errors
  1659. //
  1660. CASE_OF(WSAEINTR);
  1661. CASE_OF(WSAEBADF);
  1662. CASE_OF(WSAEACCES);
  1663. CASE_OF(WSAEFAULT);
  1664. CASE_OF(WSAEINVAL);
  1665. CASE_OF(WSAEMFILE);
  1666. CASE_OF(WSAEWOULDBLOCK);
  1667. CASE_OF(WSAEINPROGRESS);
  1668. CASE_OF(WSAEALREADY);
  1669. CASE_OF(WSAENOTSOCK);
  1670. CASE_OF(WSAEDESTADDRREQ);
  1671. CASE_OF(WSAEMSGSIZE);
  1672. CASE_OF(WSAEPROTOTYPE);
  1673. CASE_OF(WSAENOPROTOOPT);
  1674. CASE_OF(WSAEPROTONOSUPPORT);
  1675. CASE_OF(WSAESOCKTNOSUPPORT);
  1676. CASE_OF(WSAEOPNOTSUPP);
  1677. CASE_OF(WSAEPFNOSUPPORT);
  1678. CASE_OF(WSAEAFNOSUPPORT);
  1679. CASE_OF(WSAEADDRINUSE);
  1680. CASE_OF(WSAEADDRNOTAVAIL);
  1681. CASE_OF(WSAENETDOWN);
  1682. CASE_OF(WSAENETUNREACH);
  1683. CASE_OF(WSAENETRESET);
  1684. CASE_OF(WSAECONNABORTED);
  1685. CASE_OF(WSAECONNRESET);
  1686. CASE_OF(WSAENOBUFS);
  1687. CASE_OF(WSAEISCONN);
  1688. CASE_OF(WSAENOTCONN);
  1689. CASE_OF(WSAESHUTDOWN);
  1690. CASE_OF(WSAETOOMANYREFS);
  1691. CASE_OF(WSAETIMEDOUT);
  1692. CASE_OF(WSAECONNREFUSED);
  1693. CASE_OF(WSAELOOP);
  1694. CASE_OF(WSAENAMETOOLONG);
  1695. CASE_OF(WSAEHOSTDOWN);
  1696. CASE_OF(WSAEHOSTUNREACH);
  1697. CASE_OF(WSAENOTEMPTY);
  1698. CASE_OF(WSAEPROCLIM);
  1699. CASE_OF(WSAEUSERS);
  1700. CASE_OF(WSAEDQUOT);
  1701. CASE_OF(WSAESTALE);
  1702. CASE_OF(WSAEREMOTE);
  1703. CASE_OF(WSAEDISCON);
  1704. CASE_OF(WSASYSNOTREADY);
  1705. CASE_OF(WSAVERNOTSUPPORTED);
  1706. CASE_OF(WSANOTINITIALISED);
  1707. CASE_OF(WSAHOST_NOT_FOUND);
  1708. CASE_OF(WSATRY_AGAIN);
  1709. CASE_OF(WSANO_RECOVERY);
  1710. CASE_OF(WSANO_DATA);
  1711. #if 0
  1712. //
  1713. // RAS errors
  1714. //
  1715. CASE_OF(PENDING);
  1716. CASE_OF(ERROR_INVALID_PORT_HANDLE);
  1717. CASE_OF(ERROR_PORT_ALREADY_OPEN);
  1718. CASE_OF(ERROR_BUFFER_TOO_SMALL);
  1719. CASE_OF(ERROR_WRONG_INFO_SPECIFIED);
  1720. CASE_OF(ERROR_CANNOT_SET_PORT_INFO);
  1721. CASE_OF(ERROR_PORT_NOT_CONNECTED);
  1722. CASE_OF(ERROR_EVENT_INVALID);
  1723. CASE_OF(ERROR_DEVICE_DOES_NOT_EXIST);
  1724. CASE_OF(ERROR_BUFFER_INVALID);
  1725. CASE_OF(ERROR_ROUTE_NOT_AVAILABLE);
  1726. CASE_OF(ERROR_ROUTE_NOT_ALLOCATED);
  1727. CASE_OF(ERROR_INVALID_COMPRESSION_SPECIFIED);
  1728. CASE_OF(ERROR_OUT_OF_BUFFERS);
  1729. CASE_OF(ERROR_PORT_NOT_FOUND);
  1730. CASE_OF(ERROR_ASYNC_REQUEST_PENDING);
  1731. CASE_OF(ERROR_ALREADY_DISCONNECTING);
  1732. CASE_OF(ERROR_PORT_NOT_OPEN);
  1733. CASE_OF(ERROR_PORT_DISCONNECTED);
  1734. CASE_OF(ERROR_NO_ENDPOINTS);
  1735. CASE_OF(ERROR_CANNOT_OPEN_PHONEBOOK);
  1736. CASE_OF(ERROR_CANNOT_LOAD_PHONEBOOK);
  1737. CASE_OF(ERROR_CANNOT_FIND_PHONEBOOK_ENTRY);
  1738. CASE_OF(ERROR_CANNOT_WRITE_PHONEBOOK);
  1739. CASE_OF(ERROR_CORRUPT_PHONEBOOK);
  1740. CASE_OF(ERROR_CANNOT_LOAD_STRING);
  1741. CASE_OF(ERROR_KEY_NOT_FOUND);
  1742. CASE_OF(ERROR_DISCONNECTION);
  1743. CASE_OF(ERROR_REMOTE_DISCONNECTION);
  1744. CASE_OF(ERROR_HARDWARE_FAILURE);
  1745. CASE_OF(ERROR_USER_DISCONNECTION);
  1746. CASE_OF(ERROR_INVALID_SIZE);
  1747. CASE_OF(ERROR_PORT_NOT_AVAILABLE);
  1748. CASE_OF(ERROR_CANNOT_PROJECT_CLIENT);
  1749. CASE_OF(ERROR_UNKNOWN);
  1750. CASE_OF(ERROR_WRONG_DEVICE_ATTACHED);
  1751. CASE_OF(ERROR_BAD_STRING);
  1752. CASE_OF(ERROR_REQUEST_TIMEOUT);
  1753. CASE_OF(ERROR_CANNOT_GET_LANA);
  1754. CASE_OF(ERROR_NETBIOS_ERROR);
  1755. CASE_OF(ERROR_SERVER_OUT_OF_RESOURCES);
  1756. CASE_OF(ERROR_NAME_EXISTS_ON_NET);
  1757. CASE_OF(ERROR_SERVER_GENERAL_NET_FAILURE);
  1758. CASE_OF(WARNING_MSG_ALIAS_NOT_ADDED);
  1759. CASE_OF(ERROR_AUTH_INTERNAL);
  1760. CASE_OF(ERROR_RESTRICTED_LOGON_HOURS);
  1761. CASE_OF(ERROR_ACCT_DISABLED);
  1762. CASE_OF(ERROR_PASSWD_EXPIRED);
  1763. CASE_OF(ERROR_NO_DIALIN_PERMISSION);
  1764. CASE_OF(ERROR_SERVER_NOT_RESPONDING);
  1765. CASE_OF(ERROR_FROM_DEVICE);
  1766. CASE_OF(ERROR_UNRECOGNIZED_RESPONSE);
  1767. CASE_OF(ERROR_MACRO_NOT_FOUND);
  1768. CASE_OF(ERROR_MACRO_NOT_DEFINED);
  1769. CASE_OF(ERROR_MESSAGE_MACRO_NOT_FOUND);
  1770. CASE_OF(ERROR_DEFAULTOFF_MACRO_NOT_FOUND);
  1771. CASE_OF(ERROR_FILE_COULD_NOT_BE_OPENED);
  1772. CASE_OF(ERROR_DEVICENAME_TOO_LONG);
  1773. CASE_OF(ERROR_DEVICENAME_NOT_FOUND);
  1774. CASE_OF(ERROR_NO_RESPONSES);
  1775. CASE_OF(ERROR_NO_COMMAND_FOUND);
  1776. CASE_OF(ERROR_WRONG_KEY_SPECIFIED);
  1777. CASE_OF(ERROR_UNKNOWN_DEVICE_TYPE);
  1778. CASE_OF(ERROR_ALLOCATING_MEMORY);
  1779. CASE_OF(ERROR_PORT_NOT_CONFIGURED);
  1780. CASE_OF(ERROR_DEVICE_NOT_READY);
  1781. CASE_OF(ERROR_READING_INI_FILE);
  1782. CASE_OF(ERROR_NO_CONNECTION);
  1783. CASE_OF(ERROR_BAD_USAGE_IN_INI_FILE);
  1784. CASE_OF(ERROR_READING_SECTIONNAME);
  1785. CASE_OF(ERROR_READING_DEVICETYPE);
  1786. CASE_OF(ERROR_READING_DEVICENAME);
  1787. CASE_OF(ERROR_READING_USAGE);
  1788. CASE_OF(ERROR_READING_MAXCONNECTBPS);
  1789. CASE_OF(ERROR_READING_MAXCARRIERBPS);
  1790. CASE_OF(ERROR_LINE_BUSY);
  1791. CASE_OF(ERROR_VOICE_ANSWER);
  1792. CASE_OF(ERROR_NO_ANSWER);
  1793. CASE_OF(ERROR_NO_CARRIER);
  1794. CASE_OF(ERROR_NO_DIALTONE);
  1795. CASE_OF(ERROR_IN_COMMAND);
  1796. CASE_OF(ERROR_WRITING_SECTIONNAME);
  1797. CASE_OF(ERROR_WRITING_DEVICETYPE);
  1798. CASE_OF(ERROR_WRITING_DEVICENAME);
  1799. CASE_OF(ERROR_WRITING_MAXCONNECTBPS);
  1800. CASE_OF(ERROR_WRITING_MAXCARRIERBPS);
  1801. CASE_OF(ERROR_WRITING_USAGE);
  1802. CASE_OF(ERROR_WRITING_DEFAULTOFF);
  1803. CASE_OF(ERROR_READING_DEFAULTOFF);
  1804. CASE_OF(ERROR_EMPTY_INI_FILE);
  1805. CASE_OF(ERROR_AUTHENTICATION_FAILURE);
  1806. CASE_OF(ERROR_PORT_OR_DEVICE);
  1807. CASE_OF(ERROR_NOT_BINARY_MACRO);
  1808. CASE_OF(ERROR_DCB_NOT_FOUND);
  1809. CASE_OF(ERROR_STATE_MACHINES_NOT_STARTED);
  1810. CASE_OF(ERROR_STATE_MACHINES_ALREADY_STARTED);
  1811. CASE_OF(ERROR_PARTIAL_RESPONSE_LOOPING);
  1812. CASE_OF(ERROR_UNKNOWN_RESPONSE_KEY);
  1813. CASE_OF(ERROR_RECV_BUF_FULL);
  1814. CASE_OF(ERROR_CMD_TOO_LONG);
  1815. CASE_OF(ERROR_UNSUPPORTED_BPS);
  1816. CASE_OF(ERROR_UNEXPECTED_RESPONSE);
  1817. CASE_OF(ERROR_INTERACTIVE_MODE);
  1818. CASE_OF(ERROR_BAD_CALLBACK_NUMBER);
  1819. CASE_OF(ERROR_INVALID_AUTH_STATE);
  1820. CASE_OF(ERROR_WRITING_INITBPS);
  1821. CASE_OF(ERROR_X25_DIAGNOSTIC);
  1822. CASE_OF(ERROR_ACCT_EXPIRED);
  1823. CASE_OF(ERROR_CHANGING_PASSWORD);
  1824. CASE_OF(ERROR_OVERRUN);
  1825. CASE_OF(ERROR_RASMAN_CANNOT_INITIALIZE);
  1826. CASE_OF(ERROR_BIPLEX_PORT_NOT_AVAILABLE);
  1827. CASE_OF(ERROR_NO_ACTIVE_ISDN_LINES);
  1828. CASE_OF(ERROR_NO_ISDN_CHANNELS_AVAILABLE);
  1829. CASE_OF(ERROR_TOO_MANY_LINE_ERRORS);
  1830. CASE_OF(ERROR_IP_CONFIGURATION);
  1831. CASE_OF(ERROR_NO_IP_ADDRESSES);
  1832. CASE_OF(ERROR_PPP_TIMEOUT);
  1833. CASE_OF(ERROR_PPP_REMOTE_TERMINATED);
  1834. CASE_OF(ERROR_PPP_NO_PROTOCOLS_CONFIGURED);
  1835. CASE_OF(ERROR_PPP_NO_RESPONSE);
  1836. CASE_OF(ERROR_PPP_INVALID_PACKET);
  1837. CASE_OF(ERROR_PHONE_NUMBER_TOO_LONG);
  1838. CASE_OF(ERROR_IPXCP_NO_DIALOUT_CONFIGURED);
  1839. CASE_OF(ERROR_IPXCP_NO_DIALIN_CONFIGURED);
  1840. CASE_OF(ERROR_IPXCP_DIALOUT_ALREADY_ACTIVE);
  1841. CASE_OF(ERROR_ACCESSING_TCPCFGDLL);
  1842. CASE_OF(ERROR_NO_IP_RAS_ADAPTER);
  1843. CASE_OF(ERROR_SLIP_REQUIRES_IP);
  1844. CASE_OF(ERROR_PROJECTION_NOT_COMPLETE);
  1845. CASE_OF(ERROR_PROTOCOL_NOT_CONFIGURED);
  1846. CASE_OF(ERROR_PPP_NOT_CONVERGING);
  1847. CASE_OF(ERROR_PPP_CP_REJECTED);
  1848. CASE_OF(ERROR_PPP_LCP_TERMINATED);
  1849. CASE_OF(ERROR_PPP_REQUIRED_ADDRESS_REJECTED);
  1850. CASE_OF(ERROR_PPP_NCP_TERMINATED);
  1851. CASE_OF(ERROR_PPP_LOOPBACK_DETECTED);
  1852. CASE_OF(ERROR_PPP_NO_ADDRESS_ASSIGNED);
  1853. CASE_OF(ERROR_CANNOT_USE_LOGON_CREDENTIALS);
  1854. CASE_OF(ERROR_TAPI_CONFIGURATION);
  1855. CASE_OF(ERROR_NO_LOCAL_ENCRYPTION);
  1856. CASE_OF(ERROR_NO_REMOTE_ENCRYPTION);
  1857. CASE_OF(ERROR_REMOTE_REQUIRES_ENCRYPTION);
  1858. CASE_OF(ERROR_IPXCP_NET_NUMBER_CONFLICT);
  1859. CASE_OF(ERROR_INVALID_SMM);
  1860. CASE_OF(ERROR_SMM_UNINITIALIZED);
  1861. CASE_OF(ERROR_NO_MAC_FOR_PORT);
  1862. CASE_OF(ERROR_SMM_TIMEOUT);
  1863. CASE_OF(ERROR_BAD_PHONE_NUMBER);
  1864. CASE_OF(ERROR_WRONG_MODULE);
  1865. CASE_OF(ERROR_INVALID_CALLBACK_NUMBER);
  1866. CASE_OF(ERROR_SCRIPT_SYNTAX);
  1867. #endif // 0
  1868. default:
  1869. return "?";
  1870. }
  1871. }
  1872. LPSTR
  1873. InternetMapStatus(
  1874. IN DWORD Status
  1875. )
  1876. /*++
  1877. Routine Description:
  1878. Convert INTERNET_STATUS_ value to symbolic name
  1879. Arguments:
  1880. Status - to map
  1881. Return Value:
  1882. LPSTR - pointer to symbolic name, or "?" if unknown
  1883. --*/
  1884. {
  1885. switch (Status) {
  1886. CASE_OF(INTERNET_STATUS_RESOLVING_NAME);
  1887. CASE_OF(INTERNET_STATUS_NAME_RESOLVED);
  1888. CASE_OF(INTERNET_STATUS_CONNECTING_TO_SERVER);
  1889. CASE_OF(INTERNET_STATUS_CONNECTED_TO_SERVER);
  1890. CASE_OF(INTERNET_STATUS_SENDING_REQUEST);
  1891. CASE_OF(INTERNET_STATUS_REQUEST_SENT);
  1892. CASE_OF(INTERNET_STATUS_RECEIVING_RESPONSE);
  1893. CASE_OF(INTERNET_STATUS_RESPONSE_RECEIVED);
  1894. CASE_OF(INTERNET_STATUS_CTL_RESPONSE_RECEIVED);
  1895. CASE_OF(INTERNET_STATUS_PREFETCH);
  1896. CASE_OF(INTERNET_STATUS_CLOSING_CONNECTION);
  1897. CASE_OF(INTERNET_STATUS_CONNECTION_CLOSED);
  1898. CASE_OF(INTERNET_STATUS_HANDLE_CREATED);
  1899. CASE_OF(INTERNET_STATUS_HANDLE_CLOSING);
  1900. CASE_OF(INTERNET_STATUS_REQUEST_COMPLETE);
  1901. CASE_OF(INTERNET_STATUS_REDIRECT);
  1902. CASE_OF(INTERNET_STATUS_INTERMEDIATE_RESPONSE);
  1903. CASE_OF(INTERNET_STATUS_STATE_CHANGE);
  1904. CASE_OF(INTERNET_STATUS_USER_INPUT_REQUIRED);
  1905. }
  1906. return "?";
  1907. }
  1908. LPSTR
  1909. InternetMapSSPIError(
  1910. IN DWORD Status
  1911. )
  1912. /*++
  1913. Routine Description:
  1914. Convert a SSL/PCT SSPI Error Code to a string.
  1915. Arguments:
  1916. Status - to map
  1917. Return Value:
  1918. LPSTR - pointer to symbolic name, or "?" if unknown
  1919. --*/
  1920. {
  1921. switch (Status) {
  1922. CASE_OF(STATUS_SUCCESS);
  1923. CASE_OF(SEC_E_INSUFFICIENT_MEMORY );
  1924. CASE_OF(SEC_E_INVALID_HANDLE );
  1925. CASE_OF(SEC_E_UNSUPPORTED_FUNCTION );
  1926. CASE_OF(SEC_E_TARGET_UNKNOWN );
  1927. CASE_OF(SEC_E_INTERNAL_ERROR );
  1928. CASE_OF(SEC_E_SECPKG_NOT_FOUND );
  1929. CASE_OF(SEC_E_NOT_OWNER );
  1930. CASE_OF(SEC_E_CANNOT_INSTALL );
  1931. CASE_OF(SEC_E_INVALID_TOKEN );
  1932. CASE_OF(SEC_E_CANNOT_PACK );
  1933. CASE_OF(SEC_E_QOP_NOT_SUPPORTED );
  1934. CASE_OF(SEC_E_NO_IMPERSONATION );
  1935. CASE_OF(SEC_E_LOGON_DENIED );
  1936. CASE_OF(SEC_E_UNKNOWN_CREDENTIALS );
  1937. CASE_OF(SEC_E_NO_CREDENTIALS );
  1938. CASE_OF(SEC_E_MESSAGE_ALTERED );
  1939. CASE_OF(SEC_E_OUT_OF_SEQUENCE );
  1940. CASE_OF(SEC_E_NO_AUTHENTICATING_AUTHORITY);
  1941. CASE_OF(SEC_I_CONTINUE_NEEDED );
  1942. CASE_OF(SEC_I_COMPLETE_NEEDED );
  1943. CASE_OF(SEC_I_COMPLETE_AND_CONTINUE );
  1944. CASE_OF(SEC_I_LOCAL_LOGON );
  1945. CASE_OF(SEC_E_BAD_PKGID );
  1946. CASE_OF(SEC_E_CONTEXT_EXPIRED );
  1947. CASE_OF(SEC_E_INCOMPLETE_MESSAGE );
  1948. // CASE_OF(SEC_E_NO_SPM );
  1949. // CASE_OF(SEC_E_NOT_SUPPORTED );
  1950. }
  1951. return "?";
  1952. }
  1953. LPSTR
  1954. InternetMapOption(
  1955. IN DWORD Option
  1956. )
  1957. /*++
  1958. Routine Description:
  1959. Convert INTERNET_OPTION_ value to symbolic name
  1960. Arguments:
  1961. Option - to map
  1962. Return Value:
  1963. LPSTR - pointer to symbolic name, or "?" if unknown
  1964. --*/
  1965. {
  1966. switch (Option) {
  1967. CASE_OF(INTERNET_OPTION_CALLBACK);
  1968. CASE_OF(INTERNET_OPTION_CONNECT_TIMEOUT);
  1969. CASE_OF(INTERNET_OPTION_CONNECT_RETRIES);
  1970. CASE_OF(INTERNET_OPTION_CONNECT_BACKOFF);
  1971. CASE_OF(INTERNET_OPTION_SEND_TIMEOUT);
  1972. CASE_OF(INTERNET_OPTION_RECEIVE_TIMEOUT);
  1973. CASE_OF(INTERNET_OPTION_DATA_SEND_TIMEOUT);
  1974. CASE_OF(INTERNET_OPTION_DATA_RECEIVE_TIMEOUT);
  1975. CASE_OF(INTERNET_OPTION_HANDLE_TYPE);
  1976. CASE_OF(INTERNET_OPTION_CONTEXT_VALUE_OLD);
  1977. CASE_OF(INTERNET_OPTION_NAME_RES_THREAD);
  1978. CASE_OF(INTERNET_OPTION_READ_BUFFER_SIZE);
  1979. CASE_OF(INTERNET_OPTION_WRITE_BUFFER_SIZE);
  1980. CASE_OF(INTERNET_OPTION_GATEWAY_NAME);
  1981. CASE_OF(INTERNET_OPTION_ASYNC_ID);
  1982. CASE_OF(INTERNET_OPTION_ASYNC_PRIORITY);
  1983. CASE_OF(INTERNET_OPTION_ASYNC_REQUEST_COUNT);
  1984. CASE_OF(INTERNET_OPTION_MAXIMUM_WORKER_THREADS);
  1985. CASE_OF(INTERNET_OPTION_ASYNC_QUEUE_DEPTH);
  1986. CASE_OF(INTERNET_OPTION_WORKER_THREAD_TIMEOUT);
  1987. CASE_OF(INTERNET_OPTION_PARENT_HANDLE);
  1988. CASE_OF(INTERNET_OPTION_KEEP_CONNECTION);
  1989. CASE_OF(INTERNET_OPTION_REQUEST_FLAGS);
  1990. CASE_OF(INTERNET_OPTION_EXTENDED_ERROR);
  1991. CASE_OF(INTERNET_OPTION_RECEIVE_ALL_MODE);
  1992. CASE_OF(INTERNET_OPTION_OFFLINE_MODE);
  1993. CASE_OF(INTERNET_OPTION_CACHE_STREAM_HANDLE);
  1994. CASE_OF(INTERNET_OPTION_USERNAME);
  1995. CASE_OF(INTERNET_OPTION_PASSWORD);
  1996. CASE_OF(INTERNET_OPTION_ASYNC);
  1997. CASE_OF(INTERNET_OPTION_SECURITY_FLAGS);
  1998. CASE_OF(INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT);
  1999. CASE_OF(INTERNET_OPTION_DATAFILE_NAME);
  2000. CASE_OF(INTERNET_OPTION_URL);
  2001. CASE_OF(INTERNET_OPTION_SECURITY_CERTIFICATE);
  2002. CASE_OF(INTERNET_OPTION_SECURITY_KEY_BITNESS);
  2003. CASE_OF(INTERNET_OPTION_REFRESH);
  2004. CASE_OF(INTERNET_OPTION_PROXY);
  2005. CASE_OF(INTERNET_OPTION_SETTINGS_CHANGED);
  2006. CASE_OF(INTERNET_OPTION_VERSION);
  2007. CASE_OF(INTERNET_OPTION_USER_AGENT);
  2008. CASE_OF(INTERNET_OPTION_END_BROWSER_SESSION);
  2009. CASE_OF(INTERNET_OPTION_PROXY_USERNAME);
  2010. CASE_OF(INTERNET_OPTION_PROXY_PASSWORD);
  2011. CASE_OF(INTERNET_OPTION_CONTEXT_VALUE);
  2012. CASE_OF(INTERNET_OPTION_CONNECT_LIMIT);
  2013. CASE_OF(INTERNET_OPTION_SECURITY_SELECT_CLIENT_CERT);
  2014. CASE_OF(INTERNET_OPTION_POLICY);
  2015. CASE_OF(INTERNET_OPTION_OFFLINE_TIMEOUT);
  2016. CASE_OF(INTERNET_OPTION_LINE_STATE);
  2017. CASE_OF(INTERNET_OPTION_IDLE_STATE);
  2018. CASE_OF(INTERNET_OPTION_OFFLINE_SEMANTICS);
  2019. CASE_OF(INTERNET_OPTION_SECONDARY_CACHE_KEY);
  2020. CASE_OF(INTERNET_OPTION_CALLBACK_FILTER);
  2021. CASE_OF(INTERNET_OPTION_CONNECT_TIME);
  2022. CASE_OF(INTERNET_OPTION_SEND_THROUGHPUT);
  2023. CASE_OF(INTERNET_OPTION_REQUEST_PRIORITY);
  2024. CASE_OF(INTERNET_OPTION_HTTP_VERSION);
  2025. CASE_OF(INTERNET_OPTION_RESET_URLCACHE_SESSION);
  2026. CASE_OF(INTERNET_OPTION_NET_SPEED);
  2027. CASE_OF(INTERNET_OPTION_ERROR_MASK);
  2028. CASE_OF(INTERNET_OPTION_FROM_CACHE_TIMEOUT);
  2029. CASE_OF(INTERNET_OPTION_BYPASS_EDITED_ENTRY);
  2030. CASE_OF(INTERNET_OPTION_SECURITY_CONNECTION_INFO);
  2031. CASE_OF(INTERNET_OPTION_DIAGNOSTIC_SOCKET_INFO);
  2032. CASE_OF(INTERNET_OPTION_SEND_UTF8_SERVERNAME_TO_PROXY);
  2033. }
  2034. return "?";
  2035. }
  2036. LPSTR
  2037. InternetMapHttpOption(
  2038. IN DWORD Option
  2039. )
  2040. /*++
  2041. Routine Description:
  2042. Convert HTTP_QUERY_ option value to symbolic name
  2043. Arguments:
  2044. Option - to map
  2045. Return Value:
  2046. LPSTR - pointer to symbolic name, or "?" if unknown
  2047. --*/
  2048. {
  2049. switch (Option) {
  2050. CASE_OF(HTTP_QUERY_MIME_VERSION); // 0
  2051. CASE_OF(HTTP_QUERY_CONTENT_TYPE); // 1
  2052. CASE_OF(HTTP_QUERY_CONTENT_TRANSFER_ENCODING); // 2
  2053. CASE_OF(HTTP_QUERY_CONTENT_ID); // 3
  2054. CASE_OF(HTTP_QUERY_CONTENT_DESCRIPTION); // 4
  2055. CASE_OF(HTTP_QUERY_CONTENT_LENGTH); // 5
  2056. CASE_OF(HTTP_QUERY_CONTENT_LANGUAGE); // 6
  2057. CASE_OF(HTTP_QUERY_ALLOW); // 7
  2058. CASE_OF(HTTP_QUERY_PUBLIC); // 8
  2059. CASE_OF(HTTP_QUERY_DATE); // 9
  2060. CASE_OF(HTTP_QUERY_EXPIRES); // 10
  2061. CASE_OF(HTTP_QUERY_LAST_MODIFIED); // 11
  2062. CASE_OF(HTTP_QUERY_MESSAGE_ID); // 12
  2063. CASE_OF(HTTP_QUERY_URI); // 13
  2064. CASE_OF(HTTP_QUERY_DERIVED_FROM); // 14
  2065. CASE_OF(HTTP_QUERY_COST); // 15
  2066. CASE_OF(HTTP_QUERY_LINK); // 16
  2067. CASE_OF(HTTP_QUERY_PRAGMA); // 17
  2068. CASE_OF(HTTP_QUERY_VERSION); // 18
  2069. CASE_OF(HTTP_QUERY_STATUS_CODE); // 19
  2070. CASE_OF(HTTP_QUERY_STATUS_TEXT); // 20
  2071. CASE_OF(HTTP_QUERY_RAW_HEADERS); // 21
  2072. CASE_OF(HTTP_QUERY_RAW_HEADERS_CRLF); // 22
  2073. CASE_OF(HTTP_QUERY_CONNECTION); // 23
  2074. CASE_OF(HTTP_QUERY_ACCEPT); // 24
  2075. CASE_OF(HTTP_QUERY_ACCEPT_CHARSET); // 25
  2076. CASE_OF(HTTP_QUERY_ACCEPT_ENCODING); // 26
  2077. CASE_OF(HTTP_QUERY_ACCEPT_LANGUAGE); // 27
  2078. CASE_OF(HTTP_QUERY_AUTHORIZATION); // 28
  2079. CASE_OF(HTTP_QUERY_CONTENT_ENCODING); // 29
  2080. CASE_OF(HTTP_QUERY_FORWARDED); // 30
  2081. CASE_OF(HTTP_QUERY_FROM); // 31
  2082. CASE_OF(HTTP_QUERY_IF_MODIFIED_SINCE); // 32
  2083. CASE_OF(HTTP_QUERY_LOCATION); // 33
  2084. CASE_OF(HTTP_QUERY_ORIG_URI); // 34
  2085. CASE_OF(HTTP_QUERY_REFERER); // 35
  2086. CASE_OF(HTTP_QUERY_RETRY_AFTER); // 36
  2087. CASE_OF(HTTP_QUERY_SERVER); // 37
  2088. CASE_OF(HTTP_QUERY_TITLE); // 38
  2089. CASE_OF(HTTP_QUERY_USER_AGENT); // 39
  2090. CASE_OF(HTTP_QUERY_WWW_AUTHENTICATE); // 40
  2091. CASE_OF(HTTP_QUERY_PROXY_AUTHENTICATE); // 41
  2092. CASE_OF(HTTP_QUERY_ACCEPT_RANGES); // 42
  2093. CASE_OF(HTTP_QUERY_SET_COOKIE); // 43
  2094. CASE_OF(HTTP_QUERY_COOKIE); // 44
  2095. CASE_OF(HTTP_QUERY_REQUEST_METHOD); // 45
  2096. CASE_OF(HTTP_QUERY_REFRESH); // 46
  2097. CASE_OF(HTTP_QUERY_CONTENT_DISPOSITION); // 47
  2098. CASE_OF(HTTP_QUERY_AGE); // 48
  2099. CASE_OF(HTTP_QUERY_CACHE_CONTROL); // 49
  2100. CASE_OF(HTTP_QUERY_CONTENT_BASE); // 50
  2101. CASE_OF(HTTP_QUERY_CONTENT_LOCATION); // 51
  2102. CASE_OF(HTTP_QUERY_CONTENT_MD5); // 52
  2103. CASE_OF(HTTP_QUERY_CONTENT_RANGE); // 53
  2104. CASE_OF(HTTP_QUERY_ETAG); // 54
  2105. CASE_OF(HTTP_QUERY_HOST); // 55
  2106. CASE_OF(HTTP_QUERY_IF_MATCH); // 56
  2107. CASE_OF(HTTP_QUERY_IF_NONE_MATCH); // 57
  2108. CASE_OF(HTTP_QUERY_IF_RANGE); // 58
  2109. CASE_OF(HTTP_QUERY_IF_UNMODIFIED_SINCE); // 59
  2110. CASE_OF(HTTP_QUERY_MAX_FORWARDS); // 60
  2111. CASE_OF(HTTP_QUERY_PROXY_AUTHORIZATION); // 61
  2112. CASE_OF(HTTP_QUERY_RANGE); // 62
  2113. CASE_OF(HTTP_QUERY_TRANSFER_ENCODING); // 63
  2114. CASE_OF(HTTP_QUERY_UPGRADE); // 64
  2115. CASE_OF(HTTP_QUERY_VARY); // 65
  2116. CASE_OF(HTTP_QUERY_VIA); // 66
  2117. CASE_OF(HTTP_QUERY_WARNING); // 67
  2118. CASE_OF(HTTP_QUERY_EXPECT); // 68
  2119. CASE_OF(HTTP_QUERY_PROXY_CONNECTION); // 69
  2120. CASE_OF(HTTP_QUERY_UNLESS_MODIFIED_SINCE); // 70
  2121. CASE_OF(HTTP_QUERY_ECHO_REQUEST); // 71
  2122. CASE_OF(HTTP_QUERY_ECHO_REPLY); // 72
  2123. CASE_OF(HTTP_QUERY_ECHO_HEADERS); // 73
  2124. CASE_OF(HTTP_QUERY_ECHO_HEADERS_CRLF); // 74
  2125. CASE_OF(HTTP_QUERY_CUSTOM); // 65535
  2126. }
  2127. return "?";
  2128. }
  2129. LPSTR
  2130. InternetMapHttpState(
  2131. IN DWORD State
  2132. )
  2133. /*++
  2134. Routine Description:
  2135. Convert HTTPREQ_STATE_ to symbolic name
  2136. Arguments:
  2137. State - to map
  2138. Return Value:
  2139. LPSTR
  2140. --*/
  2141. {
  2142. switch (State) {
  2143. CASE_OF(HttpRequestStateCreating);
  2144. CASE_OF(HttpRequestStateOpen);
  2145. CASE_OF(HttpRequestStateRequest);
  2146. CASE_OF(HttpRequestStateResponse);
  2147. CASE_OF(HttpRequestStateObjectData);
  2148. CASE_OF(HttpRequestStateError);
  2149. CASE_OF(HttpRequestStateClosing);
  2150. CASE_OF(HttpRequestStateReopen);
  2151. }
  2152. return "?";
  2153. }
  2154. LPSTR
  2155. InternetMapHttpStateFlag(
  2156. IN DWORD Flag
  2157. )
  2158. /*++
  2159. Routine Description:
  2160. Convert HTTPREQ_STATE_ flag to symbolic name
  2161. Arguments:
  2162. Flag - to map
  2163. Return Value:
  2164. LPSTR
  2165. --*/
  2166. {
  2167. switch (Flag) {
  2168. case HTTPREQ_STATE_ANYTHING_OK:
  2169. return "ANYTHING";
  2170. case HTTPREQ_STATE_CLOSE_OK:
  2171. return "CLOSE";
  2172. case HTTPREQ_STATE_ADD_OK:
  2173. return "ADD";
  2174. case HTTPREQ_STATE_SEND_OK:
  2175. return "SEND";
  2176. case HTTPREQ_STATE_READ_OK:
  2177. return "READ";
  2178. case HTTPREQ_STATE_QUERY_REQUEST_OK:
  2179. return "QUERY_REQUEST";
  2180. case HTTPREQ_STATE_QUERY_RESPONSE_OK:
  2181. return "QUERY_RESPONSE";
  2182. case HTTPREQ_STATE_REUSE_OK:
  2183. return "REUSE";
  2184. }
  2185. return "?";
  2186. }
  2187. LPSTR
  2188. InternetMapAuthScheme(
  2189. IN DWORD Scheme
  2190. )
  2191. /*++
  2192. Routine Description:
  2193. Convert AUTHCTX::SCHEME_ to symbolic name
  2194. Arguments:
  2195. Scheme - to map
  2196. Return Value:
  2197. LPSTR
  2198. --*/
  2199. {
  2200. switch (Scheme) {
  2201. CASE_OF(AUTHCTX::SCHEME_BASIC);
  2202. CASE_OF(AUTHCTX::SCHEME_DIGEST);
  2203. CASE_OF(AUTHCTX::SCHEME_NTLM);
  2204. CASE_OF(AUTHCTX::SCHEME_MSN);
  2205. CASE_OF(AUTHCTX::SCHEME_DPA);
  2206. CASE_OF(AUTHCTX::SCHEME_KERBEROS);
  2207. CASE_OF(AUTHCTX::SCHEME_NEGOTIATE);
  2208. CASE_OF(AUTHCTX::SCHEME_UNKNOWN);
  2209. }
  2210. return "?";
  2211. }
  2212. LPSTR
  2213. InternetMapAuthState(
  2214. IN DWORD State
  2215. )
  2216. /*++
  2217. Routine Description:
  2218. Convert AUTHSTATE_ to symbolic name
  2219. Arguments:
  2220. State - to map
  2221. Return Value:
  2222. LPSTR
  2223. --*/
  2224. {
  2225. switch (State) {
  2226. CASE_OF(AUTHSTATE_NONE);
  2227. CASE_OF(AUTHSTATE_NEGOTIATE);
  2228. CASE_OF(AUTHSTATE_CHALLENGE);
  2229. CASE_OF(AUTHSTATE_NEEDTUNNEL);
  2230. }
  2231. return "?";
  2232. }
  2233. LPSTR
  2234. InternetMapAsyncRequest(
  2235. IN AR_TYPE Type
  2236. )
  2237. /*++
  2238. Routine Description:
  2239. Convert AR_TYPE to symbolic name
  2240. Arguments:
  2241. Type - Async request type
  2242. Return Value:
  2243. LPSTR - pointer to symbolic name, or "?" if unknown
  2244. --*/
  2245. {
  2246. switch (Type) {
  2247. CASE_OF(AR_INTERNET_CONNECT);
  2248. CASE_OF(AR_INTERNET_OPEN_URL);
  2249. CASE_OF(AR_INTERNET_READ_FILE);
  2250. CASE_OF(AR_INTERNET_WRITE_FILE);
  2251. CASE_OF(AR_INTERNET_QUERY_DATA_AVAILABLE);
  2252. CASE_OF(AR_INTERNET_FIND_NEXT_FILE);
  2253. CASE_OF(AR_FTP_FIND_FIRST_FILE);
  2254. CASE_OF(AR_FTP_GET_FILE);
  2255. CASE_OF(AR_FTP_PUT_FILE);
  2256. CASE_OF(AR_FTP_DELETE_FILE);
  2257. CASE_OF(AR_FTP_RENAME_FILE);
  2258. CASE_OF(AR_FTP_OPEN_FILE);
  2259. CASE_OF(AR_FTP_CREATE_DIRECTORY);
  2260. CASE_OF(AR_FTP_REMOVE_DIRECTORY);
  2261. CASE_OF(AR_FTP_SET_CURRENT_DIRECTORY);
  2262. CASE_OF(AR_FTP_GET_CURRENT_DIRECTORY);
  2263. CASE_OF(AR_GOPHER_FIND_FIRST_FILE);
  2264. CASE_OF(AR_GOPHER_OPEN_FILE);
  2265. CASE_OF(AR_GOPHER_GET_ATTRIBUTE);
  2266. CASE_OF(AR_HTTP_SEND_REQUEST);
  2267. CASE_OF(AR_HTTP_BEGIN_SEND_REQUEST);
  2268. CASE_OF(AR_HTTP_END_SEND_REQUEST);
  2269. CASE_OF(AR_READ_PREFETCH);
  2270. CASE_OF(AR_SYNC_EVENT);
  2271. CASE_OF(AR_TIMER_EVENT);
  2272. CASE_OF(AR_HTTP_REQUEST1);
  2273. CASE_OF(AR_FILE_IO);
  2274. CASE_OF(AR_INTERNET_READ_FILE_EX);
  2275. }
  2276. return "?";
  2277. }
  2278. LPSTR
  2279. InternetMapHandleType(
  2280. IN DWORD HandleType
  2281. )
  2282. /*++
  2283. Routine Description:
  2284. Map handle type to symbolic name
  2285. Arguments:
  2286. HandleType - from handle object
  2287. Return Value:
  2288. LPSTR
  2289. --*/
  2290. {
  2291. switch (HandleType) {
  2292. CASE_OF(TypeGenericHandle);
  2293. CASE_OF(TypeInternetHandle);
  2294. CASE_OF(TypeFtpConnectHandle);
  2295. CASE_OF(TypeFtpFindHandle);
  2296. CASE_OF(TypeFtpFindHandleHtml);
  2297. CASE_OF(TypeFtpFileHandle);
  2298. CASE_OF(TypeFtpFileHandleHtml);
  2299. CASE_OF(TypeGopherConnectHandle);
  2300. CASE_OF(TypeGopherFindHandle);
  2301. CASE_OF(TypeGopherFindHandleHtml);
  2302. CASE_OF(TypeGopherFileHandle);
  2303. CASE_OF(TypeGopherFileHandleHtml);
  2304. CASE_OF(TypeHttpConnectHandle);
  2305. CASE_OF(TypeHttpRequestHandle);
  2306. CASE_OF(TypeFileRequestHandle);
  2307. CASE_OF(TypeWildHandle);
  2308. }
  2309. return "?";
  2310. }
  2311. LPSTR
  2312. InternetMapScheme(
  2313. IN INTERNET_SCHEME Scheme
  2314. )
  2315. /*++
  2316. Routine Description:
  2317. Maps INTERNET_SCHEME_ to symbolic name
  2318. Arguments:
  2319. Scheme - to map
  2320. Return Value:
  2321. LPSTR
  2322. --*/
  2323. {
  2324. switch (Scheme) {
  2325. CASE_OF(INTERNET_SCHEME_UNKNOWN);
  2326. CASE_OF(INTERNET_SCHEME_DEFAULT);
  2327. CASE_OF(INTERNET_SCHEME_FTP);
  2328. CASE_OF(INTERNET_SCHEME_GOPHER);
  2329. CASE_OF(INTERNET_SCHEME_HTTP);
  2330. CASE_OF(INTERNET_SCHEME_HTTPS);
  2331. }
  2332. return "?";
  2333. }
  2334. LPSTR
  2335. InternetMapOpenType(
  2336. IN DWORD OpenType
  2337. )
  2338. /*++
  2339. Routine Description:
  2340. Maps INTERNET_OPEN_TYPE_ to symbolic name
  2341. Arguments:
  2342. OpenType - to map
  2343. Return Value:
  2344. LPSTR
  2345. --*/
  2346. {
  2347. switch (OpenType) {
  2348. CASE_OF(INTERNET_OPEN_TYPE_DIRECT);
  2349. CASE_OF(INTERNET_OPEN_TYPE_PROXY);
  2350. CASE_OF(INTERNET_OPEN_TYPE_PRECONFIG);
  2351. }
  2352. return "?";
  2353. }
  2354. LPSTR
  2355. InternetMapService(
  2356. IN DWORD Service
  2357. )
  2358. /*++
  2359. Routine Description:
  2360. Maps INTERNET_SERVICE_ to symbolic name
  2361. Arguments:
  2362. Service - to map
  2363. Return Value:
  2364. LPSTR
  2365. --*/
  2366. {
  2367. switch (Service) {
  2368. #if 0
  2369. CASE_OF(INTERNET_SERVICE_URL);
  2370. #endif
  2371. CASE_OF(INTERNET_SERVICE_FTP);
  2372. CASE_OF(INTERNET_SERVICE_GOPHER);
  2373. CASE_OF(INTERNET_SERVICE_HTTP);
  2374. }
  2375. return "?";
  2376. }
  2377. LPSTR
  2378. InternetMapWinsockCallbackType(
  2379. IN DWORD CallbackType
  2380. )
  2381. /*++
  2382. Routine Description:
  2383. Maps WINSOCK_CALLBACK_ to symbolic name
  2384. Arguments:
  2385. Service - to map
  2386. Return Value:
  2387. LPSTR
  2388. --*/
  2389. {
  2390. switch (CallbackType) {
  2391. CASE_OF(WINSOCK_CALLBACK_CONNECT);
  2392. CASE_OF(WINSOCK_CALLBACK_GETHOSTBYADDR);
  2393. CASE_OF(WINSOCK_CALLBACK_GETHOSTBYNAME);
  2394. CASE_OF(WINSOCK_CALLBACK_LISTEN);
  2395. CASE_OF(WINSOCK_CALLBACK_RECVFROM);
  2396. CASE_OF(WINSOCK_CALLBACK_SENDTO);
  2397. }
  2398. return "?";
  2399. }
  2400. //
  2401. // private functions
  2402. //
  2403. PRIVATE
  2404. LPSTR
  2405. ExtractFileName(
  2406. IN LPSTR Module,
  2407. OUT LPSTR Buf
  2408. )
  2409. {
  2410. LPSTR filename;
  2411. LPSTR extension;
  2412. int len;
  2413. filename = strrchr(Module, '\\');
  2414. extension = strrchr(Module, '.');
  2415. if (filename) {
  2416. ++filename;
  2417. } else {
  2418. filename = Module;
  2419. }
  2420. if (!extension) {
  2421. extension = filename + strlen(filename);
  2422. }
  2423. len = (int) (extension - filename);
  2424. memcpy(Buf, filename, len);
  2425. Buf[len] = '\0';
  2426. return Buf;
  2427. }
  2428. PRIVATE
  2429. LPSTR
  2430. SetDebugPrefix(
  2431. IN LPSTR Buffer
  2432. )
  2433. {
  2434. LPINTERNET_THREAD_INFO lpThreadInfo = InternetGetThreadInfo();
  2435. //INET_ASSERT(lpThreadInfo != NULL);
  2436. if (!lpThreadInfo) {
  2437. return NULL;
  2438. }
  2439. LPINTERNET_DEBUG_RECORD lpRecord;
  2440. lpRecord = lpThreadInfo->Stack;
  2441. if (InternetDebugControlFlags & DBG_ENTRY_TIME) {
  2442. if ((InternetDebugControlFlags & (DBG_DELTA_TIME | DBG_CUMULATIVE_TIME))
  2443. && lpRecord) {
  2444. DWORD ticks;
  2445. DWORD ticksNow;
  2446. ticksNow = GetTickCountWrap();
  2447. ticks = ticksNow - ((InternetDebugControlFlags & DBG_CUMULATIVE_TIME)
  2448. ? InternetDebugStartTime
  2449. : lpRecord->LastTime);
  2450. Buffer += rsprintf(Buffer,
  2451. "% 5d.%3d ",
  2452. ticks / 1000,
  2453. ticks % 1000
  2454. );
  2455. if (InternetDebugControlFlags & DBG_DELTA_TIME) {
  2456. lpRecord->LastTime = ticksNow;
  2457. }
  2458. } else {
  2459. SYSTEMTIME timeNow;
  2460. InternetDebugGetLocalTime(&timeNow, NULL);
  2461. Buffer += rsprintf(Buffer,
  2462. "%02d:%02d:%02d.%03d ",
  2463. timeNow.wHour,
  2464. timeNow.wMinute,
  2465. timeNow.wSecond,
  2466. timeNow.wMilliseconds
  2467. );
  2468. }
  2469. }
  2470. /*
  2471. if (InternetDebugControlFlags & DBG_LEVEL_INDICATOR) {
  2472. Buffer += rsprintf(Buffer, );
  2473. }
  2474. */
  2475. if (InternetDebugControlFlags & DBG_THREAD_INFO) {
  2476. //
  2477. // thread id
  2478. //
  2479. Buffer += rsprintf(Buffer, "%08x", lpThreadInfo->ThreadId);
  2480. //
  2481. // INTERNET_THREAD_INFO address
  2482. //
  2483. if (InternetDebugControlFlags & DBG_THREAD_INFO_ADR) {
  2484. Buffer += rsprintf(Buffer, ":%08x", lpThreadInfo);
  2485. }
  2486. //
  2487. // ARB address
  2488. //
  2489. //if (InternetDebugControlFlags & DBG_ARB_ADDR) {
  2490. // Buffer += rsprintf(Buffer, ":%08x", lpThreadInfo->lpArb);
  2491. //}
  2492. //
  2493. // FIBER address
  2494. //
  2495. //if (InternetDebugControlFlags & DBG_FIBER_INFO) {
  2496. //
  2497. // LPVOID p;
  2498. //
  2499. // p = (lpThreadInfo->lpArb != NULL)
  2500. // ? lpThreadInfo->lpArb->Header.lpFiber
  2501. // : NULL
  2502. // ;
  2503. // Buffer += rsprintf(Buffer, ":%08x", p);
  2504. //}
  2505. //
  2506. // async ID
  2507. //
  2508. if (InternetDebugControlFlags & DBG_ASYNC_ID) {
  2509. if (lpThreadInfo->IsAsyncWorkerThread) {
  2510. Buffer += rsprintf(Buffer, ":<--->");
  2511. } else if (lpThreadInfo->InCallback) {
  2512. //
  2513. // async worker thread calling back into the app; any WinInet
  2514. // API requests during this time treated as though from the
  2515. // app context
  2516. //
  2517. Buffer += rsprintf(Buffer, ":<c-b>");
  2518. }
  2519. else if (lpThreadInfo->IsAutoProxyProxyThread)
  2520. {
  2521. //
  2522. // this is a specialized Auto-Proxy thread
  2523. //
  2524. Buffer += rsprintf(Buffer, ":<a-p>");
  2525. }
  2526. else
  2527. {
  2528. //
  2529. // this is an app thread
  2530. //
  2531. Buffer += rsprintf(Buffer, ":<app>");
  2532. }
  2533. }
  2534. //
  2535. // request handle
  2536. //
  2537. if (InternetDebugControlFlags & DBG_REQUEST_HANDLE) {
  2538. Buffer += rsprintf(Buffer, ":%6X", lpThreadInfo->hObject);
  2539. }
  2540. *Buffer++ = ' ';
  2541. }
  2542. if (InternetDebugControlFlags & DBG_CALL_DEPTH) {
  2543. Buffer += rsprintf(Buffer, "%03d ", lpThreadInfo->CallDepth);
  2544. }
  2545. for (int i = 0; i < lpThreadInfo->IndentIncrement; ++i) {
  2546. *Buffer++ = ' ';
  2547. }
  2548. //
  2549. // if we are not debugging the category - i.e we got here via a requirement
  2550. // to display an error, or we are in a function that does not have a
  2551. // DEBUG_ENTER - then prefix the string with the current function name
  2552. // (obviously misleading if the function doesn't have a DEBUG_ENTER)
  2553. //
  2554. if (lpRecord != NULL) {
  2555. if (!(lpRecord->Category & InternetDebugCategoryFlags)) {
  2556. Buffer += rsprintf(Buffer, "%s(): ", lpRecord->Function);
  2557. }
  2558. }
  2559. return Buffer;
  2560. }
  2561. int dprintf(char * format, ...) {
  2562. va_list args;
  2563. char buf[PRINTF_STACK_BUFFER_LENGTH];
  2564. int n;
  2565. va_start(args, format);
  2566. n = _sprintf(buf, format, args);
  2567. va_end(args);
  2568. OutputDebugString(buf);
  2569. return n;
  2570. }
  2571. LPSTR
  2572. SourceFilename(
  2573. LPSTR Filespec
  2574. )
  2575. {
  2576. if (!Filespec) {
  2577. return "?";
  2578. }
  2579. LPSTR p;
  2580. if (p = strrchr(Filespec, '\\')) {
  2581. //
  2582. // we want e.g. common\debugmem.cxx, but get
  2583. // common\..\win32\debugmem.cxx. Bah!
  2584. //
  2585. //LPSTR q;
  2586. //
  2587. //if (q = strrchr(p - 1, '\\')) {
  2588. // p = q;
  2589. //}
  2590. }
  2591. return p ? p + 1 : Filespec;
  2592. }
  2593. typedef BOOL (* SYMINITIALIZE)(HANDLE, LPSTR, BOOL);
  2594. typedef BOOL (* SYMLOADMODULE)(HANDLE, HANDLE, PSTR, PSTR, DWORD, DWORD);
  2595. typedef BOOL (* SYMGETSYMFROMADDR)(HANDLE, DWORD, PDWORD, PIMAGEHLP_SYMBOL);
  2596. typedef BOOL (* SYMCLEANUP)(HANDLE);
  2597. PRIVATE HMODULE hSymLib = NULL;
  2598. PRIVATE SYMINITIALIZE pSymInitialize = NULL;
  2599. PRIVATE SYMLOADMODULE pSymLoadModule = NULL;
  2600. PRIVATE SYMGETSYMFROMADDR pSymGetSymFromAddr = NULL;
  2601. PRIVATE SYMCLEANUP pSymCleanup = NULL;
  2602. VOID
  2603. InitSymLib(
  2604. VOID
  2605. )
  2606. {
  2607. if (hSymLib == NULL) {
  2608. hSymLib = LoadLibrary("IMAGEHLP.DLL");
  2609. if (hSymLib != NULL) {
  2610. pSymInitialize = (SYMINITIALIZE)GetProcAddress(hSymLib,
  2611. "SymInitialize"
  2612. );
  2613. pSymLoadModule = (SYMLOADMODULE)GetProcAddress(hSymLib,
  2614. "SymLoadModule"
  2615. );
  2616. pSymGetSymFromAddr = (SYMGETSYMFROMADDR)GetProcAddress(hSymLib,
  2617. "SymGetSymFromAddr"
  2618. );
  2619. pSymCleanup = (SYMCLEANUP)GetProcAddress(hSymLib,
  2620. "SymCleanup"
  2621. );
  2622. if (!pSymInitialize
  2623. || !pSymLoadModule
  2624. || !pSymGetSymFromAddr
  2625. || !pSymCleanup) {
  2626. FreeLibrary(hSymLib);
  2627. hSymLib = NULL;
  2628. pSymInitialize = NULL;
  2629. pSymLoadModule = NULL;
  2630. pSymGetSymFromAddr = NULL;
  2631. pSymCleanup = NULL;
  2632. return;
  2633. }
  2634. }
  2635. pSymInitialize(GetCurrentProcess(), NULL, FALSE);
  2636. //SymInitialize(GetCurrentProcess(), NULL, TRUE);
  2637. pSymLoadModule(GetCurrentProcess(), NULL, "WININET.DLL", "WININET", 0, 0);
  2638. }
  2639. }
  2640. VOID
  2641. TermSymLib(
  2642. VOID
  2643. )
  2644. {
  2645. if (pSymCleanup) {
  2646. pSymCleanup(GetCurrentProcess());
  2647. FreeLibrary(hSymLib);
  2648. }
  2649. }
  2650. LPSTR
  2651. GetDebugSymbol(
  2652. DWORD Address,
  2653. LPDWORD Offset
  2654. )
  2655. {
  2656. *Offset = Address;
  2657. if (!pSymGetSymFromAddr) {
  2658. return "";
  2659. }
  2660. //
  2661. // BUGBUG - only one caller at a time please
  2662. //
  2663. static char symBuf[512];
  2664. //((PIMAGEHLP_SYMBOL)symBuf)->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL);
  2665. ((PIMAGEHLP_SYMBOL)symBuf)->SizeOfStruct = sizeof(symBuf);
  2666. ((PIMAGEHLP_SYMBOL)symBuf)->MaxNameLength = sizeof(symBuf) - sizeof(IMAGEHLP_SYMBOL);
  2667. if (!pSymGetSymFromAddr(GetCurrentProcess(),
  2668. Address,
  2669. Offset,
  2670. (PIMAGEHLP_SYMBOL)symBuf)) {
  2671. ((PIMAGEHLP_SYMBOL)symBuf)->Name[0] = '\0';
  2672. }
  2673. return ((PIMAGEHLP_SYMBOL)symBuf)->Name;
  2674. }
  2675. #if defined(i386)
  2676. VOID
  2677. x86SleazeCallStack(
  2678. OUT LPVOID * lplpvStack,
  2679. IN DWORD dwStackCount,
  2680. IN LPVOID * Ebp
  2681. )
  2682. /*++
  2683. Routine Description:
  2684. Similar to x86SleazeCallersAddress but gathers a variable number of return
  2685. addresses. We assume all functions have stack frame
  2686. Arguments:
  2687. lplpvStack - pointer to returned array of caller's addresses
  2688. dwStackCount - number of elements in lplpvStack
  2689. Ebp - starting Ebp if not 0, else use current stack
  2690. Return Value:
  2691. None.
  2692. --*/
  2693. {
  2694. DWORD my_esp;
  2695. _asm mov my_esp, esp;
  2696. __try {
  2697. if (Ebp == 0) {
  2698. Ebp = (LPVOID *)(&lplpvStack - 2);
  2699. }
  2700. while (dwStackCount--) {
  2701. if (((DWORD)Ebp > my_esp + 0x10000) || ((DWORD)Ebp < my_esp - 0x10000)) {
  2702. break;
  2703. }
  2704. *lplpvStack++ = *(Ebp + 1);
  2705. Ebp = (LPVOID *)*Ebp;
  2706. if (((DWORD)Ebp <= 0x10000)
  2707. || ((DWORD)Ebp >= 0x80000000)
  2708. || ((DWORD)Ebp & 3)
  2709. || ((DWORD)Ebp > my_esp + 0x10000)
  2710. || ((DWORD)Ebp < my_esp - 0x10000)) {
  2711. break;
  2712. }
  2713. }
  2714. } __except(EXCEPTION_EXECUTE_HANDLER) {
  2715. }
  2716. }
  2717. VOID
  2718. x86SleazeCallersAddress(
  2719. LPVOID* pCaller,
  2720. LPVOID* pCallersCaller
  2721. )
  2722. /*++
  2723. Routine Description:
  2724. This is a sleazy function that reads return addresses out of the stack/
  2725. frame pointer (ebp). We pluck out the return address of the function
  2726. that called THE FUNCTION THAT CALLED THIS FUNCTION, and the caller of
  2727. that function. Returning the return address of the function that called
  2728. this function is not interesting to that caller (almost worthy of Sir
  2729. Humphrey Appleby isn't it?)
  2730. Assumes:
  2731. my ebp => | caller's ebp |
  2732. | caller's eip |
  2733. | arg #1 | (pCaller)
  2734. | arg #2 | (pCallersCaller
  2735. Arguments:
  2736. pCaller - place where we return addres of function that called
  2737. the function that called this function
  2738. pCallersCaller - place where we return caller of above
  2739. Return Value:
  2740. None.
  2741. --*/
  2742. {
  2743. //
  2744. // this only works on x86 and only if not fpo functions!
  2745. //
  2746. LPVOID* ebp;
  2747. ebp = (PVOID*)&pCaller - 2; // told you it was sleazy
  2748. ebp = (PVOID*)*(PVOID*)ebp;
  2749. *pCaller = *(ebp + 1);
  2750. ebp = (PVOID*)*(PVOID*)ebp;
  2751. *pCallersCaller = *(ebp + 1);
  2752. }
  2753. #endif // defined(i386)
  2754. #endif // ENABLE_DEBUG
  2755. INTERNETAPI_(BOOL) InternetDebugGetLocalTime(
  2756. OUT SYSTEMTIME * pstLocalTime,
  2757. OUT DWORD * pdwMicroSec
  2758. )
  2759. {
  2760. #ifndef ENABLE_DEBUG
  2761. // QUICK HACK TO KEEP THINGS CLEAN AND STILL MEASURE WITH HIGH PERFORMANCE
  2762. // COUNTER
  2763. static BOOL pcTested = FALSE;
  2764. static LONGLONG ftInit; // initial local time
  2765. static LONGLONG pcInit; // initial perf counter
  2766. static LONGLONG pcFreq; // perf counter frequency
  2767. if (!pcTested)
  2768. {
  2769. pcTested = TRUE;
  2770. if (QueryPerformanceFrequency ((LARGE_INTEGER *) &pcFreq) && pcFreq)
  2771. {
  2772. QueryPerformanceCounter ((LARGE_INTEGER *) &pcInit);
  2773. SYSTEMTIME st;
  2774. GetLocalTime (&st);
  2775. SystemTimeToFileTime (&st, (FILETIME *) &ftInit);
  2776. }
  2777. }
  2778. if (!pcFreq)
  2779. GetLocalTime (pstLocalTime);
  2780. else
  2781. {
  2782. LONGLONG pcCurrent, ftCurrent;
  2783. QueryPerformanceCounter ((LARGE_INTEGER *) &pcCurrent);
  2784. ftCurrent = ftInit + ((10000000 * (pcCurrent - pcInit)) / pcFreq);
  2785. FileTimeToSystemTime ((FILETIME *) &ftCurrent, pstLocalTime);
  2786. }
  2787. return TRUE;
  2788. #else
  2789. if (!pcFreq)
  2790. GetLocalTime (pstLocalTime);
  2791. else
  2792. {
  2793. LONGLONG pcCurrent, ftCurrent;
  2794. QueryPerformanceCounter ((LARGE_INTEGER *) &pcCurrent);
  2795. ftCurrent = ftInit + ((10000000 * (pcCurrent - pcInit)) / pcFreq);
  2796. FileTimeToSystemTime ((FILETIME *) &ftCurrent, pstLocalTime);
  2797. }
  2798. return TRUE;
  2799. #endif // ENABLE_DEBUG
  2800. }