[Wininet] Add some more tracing to Wininet.

Lionel Ulmer lionel.ulmer at free.fr
Sat Feb 7 08:38:48 CST 2004


When debugging this issue, I was always going forth between the includes and
the trace to determine what was going on... And as my cycle times are more
precious than the one of the CPU (especially in debug mode :-) ), I decided
to add DDraw-like tracing to some parts of Wininet to ease my work.

I sent this patch last so if it's not applied, it's not a big deal (but
well, it certainly speeds up debugging when you know that callback 60 is in
fact INTERNET_STATUS_HANDLE_CREATED :-) ).

The only thing I do not like in this patch is that some of those functions
would need to be put into include/wine/debug.h. But this is work for another
day :-)

              Lionel

Changelog:
 Better TRACEing in some functions.

-- 
		 Lionel Ulmer - http://www.bbrox.org/
-------------- next part --------------
--- dlls/wininet_CVS/http.c	Sat Feb  7 15:23:21 2004
+++ dlls/wininet/http.c	Sat Feb  7 15:34:05 2004
@@ -725,13 +725,121 @@
     BOOL bSuccess = FALSE;
     LPWININETHTTPREQA lpwhr;
 
-    TRACE("(0x%08lx)--> %ld\n", dwInfoLevel, dwInfoLevel);
+    if (TRACE_ON(wininet)) {
+#define FE(x) { x, #x }
+	static const wininet_flag_info query_flags[] = {
+	    FE(HTTP_QUERY_MIME_VERSION),
+	    FE(HTTP_QUERY_CONTENT_TYPE),
+	    FE(HTTP_QUERY_CONTENT_TRANSFER_ENCODING),
+	    FE(HTTP_QUERY_CONTENT_ID),
+	    FE(HTTP_QUERY_CONTENT_DESCRIPTION),
+	    FE(HTTP_QUERY_CONTENT_LENGTH),
+	    FE(HTTP_QUERY_CONTENT_LANGUAGE),
+	    FE(HTTP_QUERY_ALLOW),
+	    FE(HTTP_QUERY_PUBLIC),
+	    FE(HTTP_QUERY_DATE),
+	    FE(HTTP_QUERY_EXPIRES),
+	    FE(HTTP_QUERY_LAST_MODIFIED),
+	    FE(HTTP_QUERY_MESSAGE_ID),
+	    FE(HTTP_QUERY_URI),
+	    FE(HTTP_QUERY_DERIVED_FROM),
+	    FE(HTTP_QUERY_COST),
+	    FE(HTTP_QUERY_LINK),
+	    FE(HTTP_QUERY_PRAGMA),
+	    FE(HTTP_QUERY_VERSION),
+	    FE(HTTP_QUERY_STATUS_CODE),
+	    FE(HTTP_QUERY_STATUS_TEXT),
+	    FE(HTTP_QUERY_RAW_HEADERS),
+	    FE(HTTP_QUERY_RAW_HEADERS_CRLF),
+	    FE(HTTP_QUERY_CONNECTION),
+	    FE(HTTP_QUERY_ACCEPT),
+	    FE(HTTP_QUERY_ACCEPT_CHARSET),
+	    FE(HTTP_QUERY_ACCEPT_ENCODING),
+	    FE(HTTP_QUERY_ACCEPT_LANGUAGE),
+	    FE(HTTP_QUERY_AUTHORIZATION),
+	    FE(HTTP_QUERY_CONTENT_ENCODING),
+	    FE(HTTP_QUERY_FORWARDED),
+	    FE(HTTP_QUERY_FROM),
+	    FE(HTTP_QUERY_IF_MODIFIED_SINCE),
+	    FE(HTTP_QUERY_LOCATION),
+	    FE(HTTP_QUERY_ORIG_URI),
+	    FE(HTTP_QUERY_REFERER),
+	    FE(HTTP_QUERY_RETRY_AFTER),
+	    FE(HTTP_QUERY_SERVER),
+	    FE(HTTP_QUERY_TITLE),
+	    FE(HTTP_QUERY_USER_AGENT),
+	    FE(HTTP_QUERY_WWW_AUTHENTICATE),
+	    FE(HTTP_QUERY_PROXY_AUTHENTICATE),
+	    FE(HTTP_QUERY_ACCEPT_RANGES),
+	    FE(HTTP_QUERY_SET_COOKIE),
+	    FE(HTTP_QUERY_COOKIE),
+	    FE(HTTP_QUERY_REQUEST_METHOD),
+	    FE(HTTP_QUERY_REFRESH),
+	    FE(HTTP_QUERY_CONTENT_DISPOSITION),
+	    FE(HTTP_QUERY_AGE),
+	    FE(HTTP_QUERY_CACHE_CONTROL),
+	    FE(HTTP_QUERY_CONTENT_BASE),
+	    FE(HTTP_QUERY_CONTENT_LOCATION),
+	    FE(HTTP_QUERY_CONTENT_MD5),
+	    FE(HTTP_QUERY_CONTENT_RANGE),
+	    FE(HTTP_QUERY_ETAG),
+	    FE(HTTP_QUERY_HOST),
+	    FE(HTTP_QUERY_IF_MATCH),
+	    FE(HTTP_QUERY_IF_NONE_MATCH),
+	    FE(HTTP_QUERY_IF_RANGE),
+	    FE(HTTP_QUERY_IF_UNMODIFIED_SINCE),
+	    FE(HTTP_QUERY_MAX_FORWARDS),
+	    FE(HTTP_QUERY_PROXY_AUTHORIZATION),
+	    FE(HTTP_QUERY_RANGE),
+	    FE(HTTP_QUERY_TRANSFER_ENCODING),
+	    FE(HTTP_QUERY_UPGRADE),
+	    FE(HTTP_QUERY_VARY),
+	    FE(HTTP_QUERY_VIA),
+	    FE(HTTP_QUERY_WARNING),
+	    FE(HTTP_QUERY_CUSTOM)
+	};
+	static const wininet_flag_info modifier_flags[] = {
+	    FE(HTTP_QUERY_FLAG_REQUEST_HEADERS),
+	    FE(HTTP_QUERY_FLAG_SYSTEMTIME),
+	    FE(HTTP_QUERY_FLAG_NUMBER),
+	    FE(HTTP_QUERY_FLAG_COALESCE)
+	};
+#undef FE
+	DWORD info_mod = dwInfoLevel & HTTP_QUERY_MODIFIER_FLAGS_MASK;
+	DWORD info = dwInfoLevel & HTTP_QUERY_HEADER_MASK;
+	int i;
+
+	TRACE("(%p, 0x%08lx)--> %ld\n", hHttpRequest, dwInfoLevel, dwInfoLevel);
+	TRACE("  Attribute:");
+	for (i = 0; i < (sizeof(query_flags) / sizeof(query_flags[0])); i++) {
+	    if (query_flags[i].val == info) {
+		DPRINTF(" %s", query_flags[i].name);
+		break;
+	    }
+	}
+	if (i == (sizeof(query_flags) / sizeof(query_flags[0]))) {
+	    DPRINTF(" Unknown (%08lx)", info);
+	}
 
+	DPRINTF(" Modifier:");
+	for (i = 0; i < (sizeof(modifier_flags) / sizeof(modifier_flags[0])); i++) {
+	    if (modifier_flags[i].val & info_mod) {
+		DPRINTF(" %s", modifier_flags[i].name);
+		info_mod &= ~ modifier_flags[i].val;
+	    }
+	}
+	
+	if (info_mod) {
+	    DPRINTF(" Unknown (%08lx)", info_mod);
+	}
+	DPRINTF("\n");
+    }
+    
     lpwhr = (LPWININETHTTPREQA) WININET_GetObject( hHttpRequest );
     if (NULL == lpwhr ||  lpwhr->hdr.htype != WH_HHTTPREQ)
     {
         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
-        return FALSE;
+	goto lend;
     }
 
     /* Find requested header structure */
@@ -831,8 +939,10 @@
     /* coalesce value to reuqested type */
     if (dwInfoLevel & HTTP_QUERY_FLAG_NUMBER)
     {
-       *(int *)lpBuffer = atoi(lphttpHdr->lpszValue);
-	   bSuccess = TRUE;
+	*(int *)lpBuffer = atoi(lphttpHdr->lpszValue);
+	bSuccess = TRUE;
+
+	TRACE(" returning number : %d\n", *(int *)lpBuffer);
     }
     else if (dwInfoLevel & HTTP_QUERY_FLAG_SYSTEMTIME)
     {
@@ -847,16 +957,20 @@
         if(STHook==NULL)
             goto lend;
 
-	    STHook->wDay = tmpTM.tm_mday;
-	    STHook->wHour = tmpTM.tm_hour;
-	    STHook->wMilliseconds = 0;
-	    STHook->wMinute = tmpTM.tm_min;
-	    STHook->wDayOfWeek = tmpTM.tm_wday;
-	    STHook->wMonth = tmpTM.tm_mon + 1;
-	    STHook->wSecond = tmpTM.tm_sec;
-	    STHook->wYear = tmpTM.tm_year;
-
-	    bSuccess = TRUE;
+	STHook->wDay = tmpTM.tm_mday;
+	STHook->wHour = tmpTM.tm_hour;
+	STHook->wMilliseconds = 0;
+	STHook->wMinute = tmpTM.tm_min;
+	STHook->wDayOfWeek = tmpTM.tm_wday;
+	STHook->wMonth = tmpTM.tm_mon + 1;
+	STHook->wSecond = tmpTM.tm_sec;
+	STHook->wYear = tmpTM.tm_year;
+	
+	bSuccess = TRUE;
+	
+	TRACE(" returning time : %04d/%02d/%02d - %d - %02d:%02d:%02d.%02d\n", 
+	      STHook->wYear, STHook->wMonth, STHook->wDay, STHook->wDayOfWeek,
+	      STHook->wHour, STHook->wMinute, STHook->wSecond, STHook->wMilliseconds);
     }
     else if (dwInfoLevel & HTTP_QUERY_FLAG_COALESCE)
     {
@@ -885,6 +999,8 @@
         ((char*)lpBuffer)[len]=0;
         *lpdwBufferLength = len;
         bSuccess = TRUE;
+
+	TRACE(" returning string : '%s'\n", debugstr_a(lpBuffer));
     }
 
 lend:
--- dlls/wininet_CVS/internet.c	Sat Feb  7 15:23:21 2004
+++ dlls/wininet/internet.c	Sat Feb  7 15:34:05 2004
@@ -405,10 +405,45 @@
     LPCSTR lpszProxy, LPCSTR lpszProxyBypass, DWORD dwFlags)
 {
     LPWININETAPPINFOA lpwai = NULL;
-    HINTERNET handle;
+    HINTERNET handle = NULL;
 
-    TRACE("(%s, %li, %s, %s, %li)\n", debugstr_a(lpszAgent), dwAccessType,
-	 debugstr_a(lpszProxy), debugstr_a(lpszProxyBypass), dwFlags);
+    if (TRACE_ON(wininet)) {
+#define FE(x) { x, #x }
+	static const wininet_flag_info access_type[] = {
+	    FE(INTERNET_OPEN_TYPE_PRECONFIG),
+	    FE(INTERNET_OPEN_TYPE_DIRECT),
+	    FE(INTERNET_OPEN_TYPE_PROXY),
+	    FE(INTERNET_OPEN_TYPE_PRECONFIG_WITH_NO_AUTOPROXY)
+	};
+	static const wininet_flag_info flag[] = {
+	    FE(INTERNET_FLAG_ASYNC),
+	    FE(INTERNET_FLAG_FROM_CACHE),
+	    FE(INTERNET_FLAG_OFFLINE)
+	};
+#undef FE
+	int i;
+	const char *access_type_str = "Unknown";
+	DWORD flag_val = dwFlags;
+	
+	TRACE("(%s, %li, %s, %s, %li)\n", debugstr_a(lpszAgent), dwAccessType,
+	      debugstr_a(lpszProxy), debugstr_a(lpszProxyBypass), dwFlags);
+	for (i = 0; i < (sizeof(access_type) / sizeof(access_type[0])); i++) {
+	    if (access_type[i].val == dwAccessType) {
+		access_type_str = access_type[i].name;
+		break;
+	    }
+	}
+	TRACE("  access type : %s\n", access_type_str);
+	TRACE("  flags       :");
+	for (i = 0; i < (sizeof(flag) / sizeof(flag[0])); i++) {
+	    if (flag[i].val & flag_val) {
+		DPRINTF(" %s", flag[i].name);
+		flag_val &= ~flag[i].val;
+	    }
+	}	
+	if (flag_val) DPRINTF(" Unknown flags (%08lx)", flag_val);
+	DPRINTF("\n");
+    }
 
     /* Clear any error information */
     INTERNET_SetLastError(0);
@@ -417,7 +452,7 @@
     if (NULL == lpwai)
     {
         INTERNET_SetLastError(ERROR_OUTOFMEMORY);
-        return NULL;
+	goto lend;
     }
  
     memset(lpwai, 0, sizeof(WININETAPPINFOA));
@@ -433,7 +468,7 @@
     {
         HeapFree( GetProcessHeap(), 0, lpwai );
         INTERNET_SetLastError(ERROR_OUTOFMEMORY);
-        return NULL;
+	goto lend;
     }
 
     if (NULL != lpszAgent)
@@ -461,6 +496,7 @@
             strcpy( lpwai->lpszProxyBypass, lpszProxyBypass );
     }
 
+ lend:
     TRACE("returning %p\n", (HINTERNET)lpwai);
 
     return handle;
@@ -2382,7 +2418,39 @@
 
     if (!INTERNET_GetWorkRequest(&workRequest))
         return;
-    TRACE("Got work %d\n", workRequest.asyncall);
+
+    if (TRACE_ON(wininet)) {
+	static const wininet_flag_info work_request_types[] = {
+#define FE(x) { x, #x }
+	    FE(FTPPUTFILEA),
+	    FE(FTPSETCURRENTDIRECTORYA),
+	    FE(FTPCREATEDIRECTORYA),
+	    FE(FTPFINDFIRSTFILEA),
+	    FE(FTPGETCURRENTDIRECTORYA),
+	    FE(FTPOPENFILEA),
+	    FE(FTPGETFILEA),
+	    FE(FTPDELETEFILEA),
+	    FE(FTPREMOVEDIRECTORYA),
+	    FE(FTPRENAMEFILEA),
+	    FE(INTERNETFINDNEXTA),
+	    FE(HTTPSENDREQUESTA),
+	    FE(HTTPOPENREQUESTA),
+	    FE(SENDCALLBACK),
+	    FE(INTERNETOPENURLA)
+#undef FE
+	};
+	int i;
+	const char *val = "Unknown";
+
+	for (i = 0; i < (sizeof(work_request_types) / sizeof(work_request_types[0])); i++) {
+	    if (work_request_types[i].val == workRequest.asyncall) {
+		val = work_request_types[i].name;
+		break;
+	    }
+	}
+
+	TRACE("Got work %d (%s)\n", workRequest.asyncall, val);
+    }
     switch (workRequest.asyncall)
     {
     case FTPPUTFILEA:
--- dlls/wininet_CVS/internet.h	Sat Feb  7 15:23:21 2004
+++ dlls/wininet/internet.h	Sat Feb  7 15:34:05 2004
@@ -408,5 +408,11 @@
 
 #define MAX_REPLY_LEN	 	0x5B4
 
+/* Used for debugging - maybe need to be shared in the Wine debugging code ? */
+typedef struct
+{
+    DWORD val;
+    const char* name;
+} wininet_flag_info;
 
 #endif /* _WINE_INTERNET_H_ */
--- dlls/wininet_CVS/utility.c	Fri Oct  3 17:10:29 2003
+++ dlls/wininet/utility.c	Sat Feb  7 15:34:05 2004
@@ -169,6 +169,49 @@
  * Helper function for sending async Callbacks
  */
 
+static const char *get_callback_name(DWORD dwInternetStatus) {
+    static const wininet_flag_info internet_status[] = {
+#define FE(x) { x, #x }
+	FE(INTERNET_STATUS_RESOLVING_NAME),
+	FE(INTERNET_STATUS_NAME_RESOLVED),
+	FE(INTERNET_STATUS_CONNECTING_TO_SERVER),
+	FE(INTERNET_STATUS_CONNECTED_TO_SERVER),
+	FE(INTERNET_STATUS_SENDING_REQUEST),
+	FE(INTERNET_STATUS_REQUEST_SENT),
+	FE(INTERNET_STATUS_RECEIVING_RESPONSE),
+	FE(INTERNET_STATUS_RESPONSE_RECEIVED),
+	FE(INTERNET_STATUS_CTL_RESPONSE_RECEIVED),
+	FE(INTERNET_STATUS_PREFETCH),
+	FE(INTERNET_STATUS_CLOSING_CONNECTION),
+	FE(INTERNET_STATUS_CONNECTION_CLOSED),
+	FE(INTERNET_STATUS_HANDLE_CREATED),
+	FE(INTERNET_STATUS_HANDLE_CLOSING),
+	FE(INTERNET_STATUS_REQUEST_COMPLETE),
+	FE(INTERNET_STATUS_REDIRECT),
+	FE(INTERNET_STATUS_INTERMEDIATE_RESPONSE),
+	FE(INTERNET_STATUS_USER_INPUT_REQUIRED),
+	FE(INTERNET_STATUS_STATE_CHANGE),
+	FE(INTERNET_STATUS_COOKIE_SENT),
+	FE(INTERNET_STATUS_COOKIE_RECEIVED),
+	FE(INTERNET_STATUS_PRIVACY_IMPACTED),
+	FE(INTERNET_STATUS_P3P_HEADER),
+	FE(INTERNET_STATUS_P3P_POLICYREF),
+	FE(INTERNET_STATUS_COOKIE_HISTORY),
+	FE(INTERNET_STATE_CONNECTED),
+	FE(INTERNET_STATE_DISCONNECTED),
+	FE(INTERNET_STATE_DISCONNECTED_BY_USER),
+	FE(INTERNET_STATE_IDLE),
+	FE(INTERNET_STATE_BUSY)
+#undef FE
+    };
+    int i;
+
+    for (i = 0; i < (sizeof(internet_status) / sizeof(internet_status[0])); i++) {
+	if (internet_status[i].val == dwInternetStatus) return internet_status[i].name;
+    }
+    return "Unknown";
+}
+
 VOID SendAsyncCallbackInt(LPWININETAPPINFOA hIC, HINTERNET hHttpSession,
                              DWORD dwContext, DWORD dwInternetStatus, LPVOID
                              lpvStatusInfo, DWORD dwStatusInfoLength)
@@ -181,12 +224,12 @@
         if( !dwContext )
             return;
 
-        TRACE("--> Callback %ld\n",dwInternetStatus);
+        TRACE("--> Callback %ld (%s)\n",dwInternetStatus, get_callback_name(dwInternetStatus));
 
         hIC->lpfnStatusCB(hHttpSession, dwContext, dwInternetStatus,
                           lpvStatusInfo, dwStatusInfoLength);
 
-        TRACE("<-- Callback %ld\n",dwInternetStatus);
+        TRACE("<-- Callback %ld (%s)\n",dwInternetStatus, get_callback_name(dwInternetStatus));
 }
 
 
@@ -195,7 +238,7 @@
                              DWORD dwContext, DWORD dwInternetStatus, LPVOID
                              lpvStatusInfo,  DWORD dwStatusInfoLength)
 {
-        TRACE("Send Callback %ld\n",dwInternetStatus);
+        TRACE("Send Callback %ld (%s)\n",dwInternetStatus, get_callback_name(dwInternetStatus));
 
         if (! (hIC->lpfnStatusCB))
             return;


More information about the wine-patches mailing list