New wininet vendor import

svn path=/trunk/; revision=20909

reactos/include/wine/shlwapi.h

@@ -13,6 +13,7 @@
 #define __WINE_SHLWAPI_H
 
 #define URL_FILE_USE_PATHURL 0x00010000
+#define URL_BROWSER_MODE     URL_DONT_ESCAPE_EXTRA_INFO
 
 HRESULT WINAPI SHCreateStreamOnFileEx(LPCWSTR,DWORD,DWORD,BOOL,struct IStream*,struct IStream**);
 

reactos/include/wine/winnetwk.h

@@ -24,6 +24,8 @@ typedef struct tagPASSWORD_CACHE_ENTRY
 } PASSWORD_CACHE_ENTRY;
 
 typedef BOOL (CALLBACK *ENUMPASSWORDPROC)(PASSWORD_CACHE_ENTRY *, DWORD);
+DWORD WINAPI WNetCachePassword( LPSTR, WORD, LPSTR, WORD, BYTE, WORD );
 UINT WINAPI WNetEnumCachedPasswords( LPSTR, WORD, BYTE, ENUMPASSWORDPROC, DWORD);
+DWORD WINAPI WNetGetCachedPassword( LPSTR, WORD, LPSTR, LPWORD, BYTE );
 
 #endif /* __WINE_WINNETWK_H */

reactos/lib/wininet/cookie.c

@@ -0,0 +1,501 @@
+/*
+ * Wininet - cookie handling stuff
+ *
+ * Copyright 2002 TransGaming Technologies Inc.
+ *
+ * David Hammerton
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "config.h"
+#include "wine/port.h"
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+#include "windef.h"
+#include "winbase.h"
+#include "wininet.h"
+#include "winerror.h"
+
+#include "wine/debug.h"
+#include "internet.h"
+
+#include "wine/list.h"
+
+#define RESPONSE_TIMEOUT        30            /* FROM internet.c */
+
+
+WINE_DEFAULT_DEBUG_CHANNEL(wininet);
+
+/* FIXME
+ *     Cookies are currently memory only.
+ *     Cookies are NOT THREAD SAFE
+ *     Cookies could use A LOT OF MEMORY. We need some kind of memory management here!
+ *     Cookies should care about the expiry time
+ */
+
+typedef struct _cookie_domain cookie_domain;
+typedef struct _cookie cookie;
+
+struct _cookie
+{
+    struct list entry;
+
+    struct _cookie_domain *parent;
+
+    LPWSTR lpCookieName;
+    LPWSTR lpCookieData;
+    time_t expiry; /* FIXME: not used */
+};
+
+struct _cookie_domain
+{
+    struct list entry;
+
+    LPWSTR lpCookieDomain;
+    LPWSTR lpCookiePath;
+    struct list cookie_list;
+};
+
+static struct list domain_list = LIST_INIT(domain_list);
+
+static cookie *COOKIE_addCookie(cookie_domain *domain, LPCWSTR name, LPCWSTR data);
+static cookie *COOKIE_findCookie(cookie_domain *domain, LPCWSTR lpszCookieName);
+static void COOKIE_deleteCookie(cookie *deadCookie, BOOL deleteDomain);
+static cookie_domain *COOKIE_addDomain(LPCWSTR domain, LPCWSTR path);
+static void COOKIE_deleteDomain(cookie_domain *deadDomain);
+
+
+/* adds a cookie to the domain */
+static cookie *COOKIE_addCookie(cookie_domain *domain, LPCWSTR name, LPCWSTR data)
+{
+    cookie *newCookie = HeapAlloc(GetProcessHeap(), 0, sizeof(cookie));
+
+    list_init(&newCookie->entry);
+    newCookie->lpCookieName = NULL;
+    newCookie->lpCookieData = NULL;
+
+    if (name)
+    {
+	newCookie->lpCookieName = HeapAlloc(GetProcessHeap(), 0, (strlenW(name) + 1)*sizeof(WCHAR));
+        lstrcpyW(newCookie->lpCookieName, name);
+    }
+    if (data)
+    {
+	newCookie->lpCookieData = HeapAlloc(GetProcessHeap(), 0, (strlenW(data) + 1)*sizeof(WCHAR));
+        lstrcpyW(newCookie->lpCookieData, data);
+    }
+
+    TRACE("added cookie %p (data is %s)\n", newCookie, debugstr_w(data) );
+
+    list_add_tail(&domain->cookie_list, &newCookie->entry);
+    newCookie->parent = domain;
+    return newCookie;
+}
+
+
+/* finds a cookie in the domain matching the cookie name */
+static cookie *COOKIE_findCookie(cookie_domain *domain, LPCWSTR lpszCookieName)
+{
+    struct list * cursor;
+    TRACE("(%p, %s)\n", domain, debugstr_w(lpszCookieName));
+
+    LIST_FOR_EACH(cursor, &domain->cookie_list)
+    {
+        cookie *searchCookie = LIST_ENTRY(cursor, cookie, entry);
+	BOOL candidate = TRUE;
+	if (candidate && lpszCookieName)
+	{
+	    if (candidate && !searchCookie->lpCookieName)
+		candidate = FALSE;
+	    if (candidate && strcmpW(lpszCookieName, searchCookie->lpCookieName) != 0)
+                candidate = FALSE;
+	}
+	if (candidate)
+	    return searchCookie;
+    }
+    return NULL;
+}
+
+/* removes a cookie from the list, if its the last cookie we also remove the domain */
+static void COOKIE_deleteCookie(cookie *deadCookie, BOOL deleteDomain)
+{
+    HeapFree(GetProcessHeap(), 0, deadCookie->lpCookieName);
+    HeapFree(GetProcessHeap(), 0, deadCookie->lpCookieData);
+    list_remove(&deadCookie->entry);
+
+    /* special case: last cookie, lets remove the domain to save memory */
+    if (list_empty(&deadCookie->parent->cookie_list) && deleteDomain)
+        COOKIE_deleteDomain(deadCookie->parent);
+    HeapFree(GetProcessHeap(), 0, deadCookie);
+}
+
+/* allocates a domain and adds it to the end */
+static cookie_domain *COOKIE_addDomain(LPCWSTR domain, LPCWSTR path)
+{
+    cookie_domain *newDomain = HeapAlloc(GetProcessHeap(), 0, sizeof(cookie_domain));
+
+    list_init(&newDomain->entry);
+    list_init(&newDomain->cookie_list);
+    newDomain->lpCookieDomain = NULL;
+    newDomain->lpCookiePath = NULL;
+
+    if (domain)
+    {
+	newDomain->lpCookieDomain = HeapAlloc(GetProcessHeap(), 0, (strlenW(domain) + 1)*sizeof(WCHAR));
+        strcpyW(newDomain->lpCookieDomain, domain);
+    }
+    if (path)
+    {
+	newDomain->lpCookiePath = HeapAlloc(GetProcessHeap(), 0, (strlenW(path) + 1)*sizeof(WCHAR));
+        lstrcpyW(newDomain->lpCookiePath, path);
+    }
+
+    list_add_tail(&domain_list, &newDomain->entry);
+
+    TRACE("Adding domain: %p\n", newDomain);
+    return newDomain;
+}
+
+static void COOKIE_crackUrlSimple(LPCWSTR lpszUrl, LPWSTR hostName, int hostNameLen, LPWSTR path, int pathLen)
+{
+    URL_COMPONENTSW UrlComponents;
+
+    UrlComponents.lpszExtraInfo = NULL;
+    UrlComponents.lpszPassword = NULL;
+    UrlComponents.lpszScheme = NULL;
+    UrlComponents.lpszUrlPath = path;
+    UrlComponents.lpszUserName = NULL;
+    UrlComponents.lpszHostName = hostName;
+    UrlComponents.dwHostNameLength = hostNameLen;
+    UrlComponents.dwUrlPathLength = pathLen;
+
+    InternetCrackUrlW(lpszUrl, 0, 0, &UrlComponents);
+}
+
+/* match a domain. domain must match if the domain is not NULL. path must match if the path is not NULL */
+static BOOL COOKIE_matchDomain(LPCWSTR lpszCookieDomain, LPCWSTR lpszCookiePath,
+                               cookie_domain *searchDomain, BOOL allow_partial)
+{
+    TRACE("searching on domain %p\n", searchDomain);
+	if (lpszCookieDomain)
+	{
+	    if (!searchDomain->lpCookieDomain)
+            return FALSE;
+
+	    TRACE("comparing domain %s with %s\n", 
+            debugstr_w(lpszCookieDomain), 
+            debugstr_w(searchDomain->lpCookieDomain));
+
+        if (allow_partial && !strstrW(lpszCookieDomain, searchDomain->lpCookieDomain))
+            return FALSE;
+        else if (!allow_partial && lstrcmpW(lpszCookieDomain, searchDomain->lpCookieDomain) != 0)
+            return FALSE;
+ 	}
+    if (lpszCookiePath)
+    {
+        TRACE("comparing paths: %s with %s\n", debugstr_w(lpszCookiePath), debugstr_w(searchDomain->lpCookiePath));
+        if (!searchDomain->lpCookiePath)
+            return FALSE;
+        if (strcmpW(lpszCookiePath, searchDomain->lpCookiePath))
+            return FALSE;
+	}
+	return TRUE;
+}
+
+/* remove a domain from the list and delete it */
+static void COOKIE_deleteDomain(cookie_domain *deadDomain)
+{
+    struct list * cursor;
+    while ((cursor = list_tail(&deadDomain->cookie_list)))
+    {
+        COOKIE_deleteCookie(LIST_ENTRY(cursor, cookie, entry), FALSE);
+        list_remove(cursor);
+    }
+
+    HeapFree(GetProcessHeap(), 0, deadDomain->lpCookieDomain);
+    HeapFree(GetProcessHeap(), 0, deadDomain->lpCookiePath);
+
+    list_remove(&deadDomain->entry);
+
+    HeapFree(GetProcessHeap(), 0, deadDomain);
+}
+
+/***********************************************************************
+ *           InternetGetCookieW (WININET.@)
+ *
+ * Retrieve cookie from the specified url
+ *
+ *  It should be noted that on windows the lpszCookieName parameter is "not implemented".
+ *    So it won't be implemented here.
+ *
+ * RETURNS
+ *    TRUE  on success
+ *    FALSE on failure
+ *
+ */
+BOOL WINAPI InternetGetCookieW(LPCWSTR lpszUrl, LPCWSTR lpszCookieName,
+    LPWSTR lpCookieData, LPDWORD lpdwSize)
+{
+    struct list * cursor;
+    int cnt = 0, domain_count = 0;
+    int cookie_count = 0;
+    WCHAR hostName[2048], path[2048];
+
+    TRACE("(%s, %s, %p, %p)\n", debugstr_w(lpszUrl),debugstr_w(lpszCookieName),
+	  lpCookieData, lpdwSize);
+
+    COOKIE_crackUrlSimple(lpszUrl, hostName, sizeof(hostName)/sizeof(hostName[0]), path, sizeof(path)/sizeof(path[0]));
+
+    LIST_FOR_EACH(cursor, &domain_list)
+    {
+        cookie_domain *cookiesDomain = LIST_ENTRY(cursor, cookie_domain, entry);
+        if (COOKIE_matchDomain(hostName, NULL /* FIXME: path */, cookiesDomain, TRUE))
+        {
+            struct list * cursor;
+            domain_count++;
+            TRACE("found domain %p\n", cookiesDomain);
+    
+            LIST_FOR_EACH(cursor, &cookiesDomain->cookie_list)
+            {
+                cookie *thisCookie = LIST_ENTRY(cursor, cookie, entry);
+                if (lpCookieData == NULL) /* return the size of the buffer required to lpdwSize */
+                {
+                    if (cookie_count != 0)
+                        cnt += 2; /* '; ' */
+                    cnt += strlenW(thisCookie->lpCookieName);
+                    cnt += 1; /* = */
+                    cnt += strlenW(thisCookie->lpCookieData);
+                }
+                else
+                {
+                    static const WCHAR szsc[] = { ';',' ',0 };
+                    static const WCHAR szpseq[] = { '%','s','=','%','s',0 };
+                    if (cookie_count != 0)
+                        cnt += snprintfW(lpCookieData + cnt, *lpdwSize - cnt, szsc);
+                    cnt += snprintfW(lpCookieData + cnt, *lpdwSize - cnt, szpseq,
+                                    thisCookie->lpCookieName,
+                                    thisCookie->lpCookieData);
+                    TRACE("Cookie: %s=%s\n", debugstr_w(thisCookie->lpCookieName), debugstr_w(thisCookie->lpCookieData));
+                }
+                cookie_count++;
+            }
+        }
+    }
+    if (lpCookieData == NULL)
+    {
+	cnt += 1; /* NULL */
+	*lpdwSize = cnt*sizeof(WCHAR);
+	TRACE("returning\n");
+	return TRUE;
+    }
+
+    if (!domain_count)
+        return FALSE;
+
+    *lpdwSize = (cnt + 1)*sizeof(WCHAR);
+
+    TRACE("Returning %i (from %i domains): %s\n", cnt, domain_count,
+           debugstr_w(lpCookieData));
+
+    return (cnt ? TRUE : FALSE);
+}
+
+
+/***********************************************************************
+ *           InternetGetCookieA (WININET.@)
+ *
+ * Retrieve cookie from the specified url
+ *
+ * RETURNS
+ *    TRUE  on success
+ *    FALSE on failure
+ *
+ */
+BOOL WINAPI InternetGetCookieA(LPCSTR lpszUrl, LPCSTR lpszCookieName,
+    LPSTR lpCookieData, LPDWORD lpdwSize)
+{
+    DWORD len;
+    LPWSTR szCookieData = NULL, szUrl = NULL, szCookieName = NULL;
+    BOOL r;
+
+    TRACE("(%s,%s,%p)\n", debugstr_a(lpszUrl), debugstr_a(lpszCookieName),
+        lpCookieData);
+
+    if( lpszUrl )
+    {
+        len = MultiByteToWideChar( CP_ACP, 0, lpszUrl, -1, NULL, 0 );
+        szUrl = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
+        MultiByteToWideChar( CP_ACP, 0, lpszUrl, -1, szUrl, len );
+    }
+
+    if( lpszCookieName )
+    {
+        len = MultiByteToWideChar( CP_ACP, 0, lpszCookieName, -1, NULL, 0 );
+        szCookieName = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
+        MultiByteToWideChar( CP_ACP, 0, lpszCookieName, -1, szCookieName, len );
+    }
+
+    r = InternetGetCookieW( szUrl, szCookieName, NULL, &len );
+    if( r )
+    {
+        szCookieData = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
+        if( !szCookieData )
+            return FALSE;
+
+        r = InternetGetCookieW( szUrl, szCookieName, szCookieData, &len );
+
+        *lpdwSize = WideCharToMultiByte( CP_ACP, 0, szCookieData, len,
+                                lpCookieData, *lpdwSize, NULL, NULL );
+    }
+
+    HeapFree( GetProcessHeap(), 0, szCookieData );
+    HeapFree( GetProcessHeap(), 0, szCookieName );
+    HeapFree( GetProcessHeap(), 0, szUrl );
+
+    return r;
+}
+
+
+/***********************************************************************
+ *           InternetSetCookieW (WININET.@)
+ *
+ * Sets cookie for the specified url
+ *
+ * RETURNS
+ *    TRUE  on success
+ *    FALSE on failure
+ *
+ */
+BOOL WINAPI InternetSetCookieW(LPCWSTR lpszUrl, LPCWSTR lpszCookieName,
+    LPCWSTR lpCookieData)
+{
+    cookie_domain *thisCookieDomain = NULL;
+    cookie *thisCookie;
+    WCHAR hostName[2048], path[2048];
+    struct list * cursor;
+
+    TRACE("(%s,%s,%s)\n", debugstr_w(lpszUrl),
+        debugstr_w(lpszCookieName), debugstr_w(lpCookieData));
+
+    if (!lpCookieData || !strlenW(lpCookieData))
+    {
+        TRACE("no cookie data, not adding\n");
+	return FALSE;
+    }
+    if (!lpszCookieName)
+    {
+	/* some apps (or is it us??) try to add a cookie with no cookie name, but
+         * the cookie data in the form of name=data. */
+	/* FIXME, probably a bug here, for now I don't care */
+	WCHAR *ourCookieName, *ourCookieData;
+	int ourCookieNameSize;
+        BOOL ret;
+
+	if (!(ourCookieData = strchrW(lpCookieData, '=')))
+	{
+            TRACE("something terribly wrong with cookie data %s\n", 
+                   debugstr_w(ourCookieData));
+	    return FALSE;
+	}
+	ourCookieNameSize = ourCookieData - lpCookieData;
+	ourCookieData += 1;
+	ourCookieName = HeapAlloc(GetProcessHeap(), 0, 
+                              (ourCookieNameSize + 1)*sizeof(WCHAR));
+	memcpy(ourCookieName, ourCookieData, ourCookieNameSize * sizeof(WCHAR));
+	ourCookieName[ourCookieNameSize] = '\0';
+	TRACE("setting (hacked) cookie of %s, %s\n",
+               debugstr_w(ourCookieName), debugstr_w(ourCookieData));
+        ret = InternetSetCookieW(lpszUrl, ourCookieName, ourCookieData);
+	HeapFree(GetProcessHeap(), 0, ourCookieName);
+        return ret;
+    }
+
+    COOKIE_crackUrlSimple(lpszUrl, hostName, sizeof(hostName)/sizeof(hostName[0]), path, sizeof(path)/sizeof(path[0]));
+
+    LIST_FOR_EACH(cursor, &domain_list)
+    {
+        thisCookieDomain = LIST_ENTRY(cursor, cookie_domain, entry);
+        if (COOKIE_matchDomain(hostName, NULL /* FIXME: path */, thisCookieDomain, FALSE))
+            break;
+        thisCookieDomain = NULL;
+    }
+    if (!thisCookieDomain)
+        thisCookieDomain = COOKIE_addDomain(hostName, path);
+
+    if ((thisCookie = COOKIE_findCookie(thisCookieDomain, lpszCookieName)))
+	COOKIE_deleteCookie(thisCookie, FALSE);
+
+    thisCookie = COOKIE_addCookie(thisCookieDomain, lpszCookieName, lpCookieData);
+    return TRUE;
+}
+
+
+/***********************************************************************
+ *           InternetSetCookieA (WININET.@)
+ *
+ * Sets cookie for the specified url
+ *
+ * RETURNS
+ *    TRUE  on success
+ *    FALSE on failure
+ *
+ */
+BOOL WINAPI InternetSetCookieA(LPCSTR lpszUrl, LPCSTR lpszCookieName,
+    LPCSTR lpCookieData)
+{
+    DWORD len;
+    LPWSTR szCookieData = NULL, szUrl = NULL, szCookieName = NULL;
+    BOOL r;
+
+    TRACE("(%s,%s,%s)\n", debugstr_a(lpszUrl),
+        debugstr_a(lpszCookieName), debugstr_a(lpCookieData));
+
+    if( lpszUrl )
+    {
+        len = MultiByteToWideChar( CP_ACP, 0, lpszUrl, -1, NULL, 0 );
+        szUrl = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
+        MultiByteToWideChar( CP_ACP, 0, lpszUrl, -1, szUrl, len );
+    }
+
+    if( lpszCookieName )
+    {
+        len = MultiByteToWideChar( CP_ACP, 0, lpszCookieName, -1, NULL, 0 );
+        szCookieName = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
+        MultiByteToWideChar( CP_ACP, 0, lpszCookieName, -1, szCookieName, len );
+    }
+
+    if( lpCookieData )
+    {
+        len = MultiByteToWideChar( CP_ACP, 0, lpCookieData, -1, NULL, 0 );
+        szCookieData = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
+        MultiByteToWideChar( CP_ACP, 0, lpCookieData, -1, szCookieData, len );
+    }
+
+    r = InternetSetCookieW( szUrl, szCookieName, szCookieData );
+
+    HeapFree( GetProcessHeap(), 0, szCookieData );
+    HeapFree( GetProcessHeap(), 0, szCookieName );
+    HeapFree( GetProcessHeap(), 0, szUrl );
+
+    return r;
+}

reactos/lib/wininet/dialogs.c

@@ -0,0 +1,384 @@
+/*
+ * Wininet
+ *
+ * Copyright 2003 Mike McCormack for CodeWeavers Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "config.h"
+#include "wine/port.h"
+
+#include <stdarg.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "winuser.h"
+#include "winreg.h"
+#include "wininet.h"
+#include "winnetwk.h"
+#include "winnls.h"
+#include "wine/debug.h"
+#include "winerror.h"
+#define NO_SHLWAPI_STREAM
+#include "shlwapi.h"
+
+#include "internet.h"
+
+#include "wine/unicode.h"
+
+#include "resource.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(wininet);
+
+struct WININET_ErrorDlgParams
+{
+    HWND       hWnd;
+    HINTERNET  hRequest;
+    DWORD      dwError;
+    DWORD      dwFlags;
+    LPVOID*    lppvData;
+};
+
+/***********************************************************************
+ *         WININET_GetProxyServer
+ *
+ *  Determine the name of the proxy server the request is using
+ */
+static BOOL WININET_GetProxyServer( HINTERNET hRequest, LPWSTR szBuf, DWORD sz )
+{
+    LPWININETHTTPREQW lpwhr;
+    LPWININETHTTPSESSIONW lpwhs = NULL;
+    LPWININETAPPINFOW hIC = NULL;
+    LPWSTR p;
+
+    lpwhr = (LPWININETHTTPREQW) WININET_GetObject( hRequest );
+    if (NULL == lpwhr)
+	return FALSE;
+
+    lpwhs = (LPWININETHTTPSESSIONW) lpwhr->hdr.lpwhparent;
+    if (NULL == lpwhs)
+	return FALSE;
+
+    hIC = (LPWININETAPPINFOW) lpwhs->hdr.lpwhparent;
+    if (NULL == hIC)
+	return FALSE;
+
+    lstrcpynW(szBuf, hIC->lpszProxy, sz);
+
+    /* FIXME: perhaps it would be better to use InternetCrackUrl here */
+    p = strchrW(szBuf, ':');
+    if(*p)
+        *p = 0;
+
+    return TRUE;
+}
+
+/***********************************************************************
+ *         WININET_GetAuthRealm
+ *
+ *  Determine the name of the (basic) Authentication realm
+ */
+static BOOL WININET_GetAuthRealm( HINTERNET hRequest, LPWSTR szBuf, DWORD sz )
+{
+    LPWSTR p, q;
+    DWORD index;
+    static const WCHAR szRealm[] = { 'r','e','a','l','m','=',0 };
+
+    /* extract the Realm from the proxy response and show it */
+    index = 0;
+    if( !HttpQueryInfoW( hRequest, HTTP_QUERY_PROXY_AUTHENTICATE,
+                         szBuf, &sz, &index) )
+        return FALSE;
+
+    /*
+     * FIXME: maybe we should check that we're
+     * dealing with 'Basic' Authentication
+     */
+    p = strchrW( szBuf, ' ' );
+    if( p && !strncmpW( p+1, szRealm, strlenW(szRealm) ) )
+    {
+        /* remove quotes */
+        p += 7;
+        if( *p == '"' )
+        {
+            p++;
+            q = strrchrW( p, '"' );
+            if( q )
+                *q = 0;
+        }
+    }
+
+    strcpyW( szBuf, p );
+
+    return TRUE;
+}
+
+/***********************************************************************
+ *         WININET_GetSetPassword
+ */
+static BOOL WININET_GetSetPassword( HWND hdlg, LPCWSTR szServer, 
+                                    LPCWSTR szRealm, BOOL bSet )
+{
+    WCHAR szResource[0x80], szUserPass[0x40];
+    LPWSTR p;
+    HWND hUserItem, hPassItem;
+    DWORD r, dwMagic = 19;
+    UINT r_len, u_len;
+    WORD sz;
+    static const WCHAR szColon[] = { ':',0 };
+    static const WCHAR szbs[] = { '/', 0 };
+
+    hUserItem = GetDlgItem( hdlg, IDC_USERNAME );
+    hPassItem = GetDlgItem( hdlg, IDC_PASSWORD );
+
+    /* now try fetch the username and password */
+    lstrcpyW( szResource, szServer);
+    lstrcatW( szResource, szbs);
+    lstrcatW( szResource, szRealm);
+
+    /*
+     * WNetCachePassword is only concerned with the length
+     * of the data stored (which we tell it) and it does
+     * not use strlen() internally so we can add WCHAR data
+     * instead of ASCII data and get it back the same way.
+     */
+    if( bSet )
+    {
+        szUserPass[0] = 0;
+        GetWindowTextW( hUserItem, szUserPass, 
+                        (sizeof szUserPass-1)/sizeof(WCHAR) );
+        lstrcatW(szUserPass, szColon);
+        u_len = strlenW( szUserPass );
+        GetWindowTextW( hPassItem, szUserPass+u_len, 
+                        (sizeof szUserPass)/sizeof(WCHAR)-u_len );
+
+        r_len = (strlenW( szResource ) + 1)*sizeof(WCHAR);
+        u_len = (strlenW( szUserPass ) + 1)*sizeof(WCHAR);
+        r = WNetCachePassword( (CHAR*)szResource, r_len,
+                               (CHAR*)szUserPass, u_len, dwMagic, 0 );
+
+        return ( r == WN_SUCCESS );
+    }
+
+    sz = sizeof szUserPass;
+    r_len = (strlenW( szResource ) + 1)*sizeof(WCHAR);
+    r = WNetGetCachedPassword( (CHAR*)szResource, r_len,
+                               (CHAR*)szUserPass, &sz, dwMagic );
+    if( r != WN_SUCCESS )
+        return FALSE;
+
+    p = strchrW( szUserPass, ':' );
+    if( p )
+    {
+        *p = 0;
+        SetWindowTextW( hUserItem, szUserPass );
+        SetWindowTextW( hPassItem, p+1 );
+    }
+
+    return TRUE;
+}
+
+/***********************************************************************
+ *         WININET_SetProxyAuthorization
+ */
+static BOOL WININET_SetProxyAuthorization( HINTERNET hRequest,
+                                         LPWSTR username, LPWSTR password )
+{
+    LPWININETHTTPREQW lpwhr;
+    LPWININETHTTPSESSIONW lpwhs;
+    LPWININETAPPINFOW hIC;
+    LPWSTR p;
+
+    lpwhr = (LPWININETHTTPREQW) WININET_GetObject( hRequest );
+    if( !lpwhr )
+	return FALSE;
+        
+    lpwhs = (LPWININETHTTPSESSIONW) lpwhr->hdr.lpwhparent;
+    if (NULL == lpwhs ||  lpwhs->hdr.htype != WH_HHTTPSESSION)
+    {
+        INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
+	return FALSE;
+    }
+
+    hIC = (LPWININETAPPINFOW) lpwhs->hdr.lpwhparent;
+
+    p = HeapAlloc( GetProcessHeap(), 0, (strlenW( username ) + 1)*sizeof(WCHAR) );
+    if( !p )
+        return FALSE;
+    
+    lstrcpyW( p, username );
+    hIC->lpszProxyUsername = p;
+
+    p = HeapAlloc( GetProcessHeap(), 0, (strlenW( password ) + 1)*sizeof(WCHAR) );
+    if( !p )
+        return FALSE;
+    
+    lstrcpyW( p, password );
+    hIC->lpszProxyPassword = p;
+
+    return TRUE;
+}
+
+/***********************************************************************
+ *         WININET_ProxyPasswordDialog
+ */
+static INT_PTR WINAPI WININET_ProxyPasswordDialog(
+    HWND hdlg, UINT uMsg, WPARAM wParam, LPARAM lParam )
+{
+    HWND hitem;
+    struct WININET_ErrorDlgParams *params;
+    WCHAR szRealm[0x80], szServer[0x80];
+
+    if( uMsg == WM_INITDIALOG )
+    {
+        TRACE("WM_INITDIALOG (%08lx)\n", lParam);
+
+        /* save the parameter list */
+        params = (struct WININET_ErrorDlgParams*) lParam;
+        SetWindowLongPtrW( hdlg, GWLP_USERDATA, lParam );
+
+        /* extract the Realm from the proxy response and show it */
+        if( WININET_GetAuthRealm( params->hRequest,
+                                  szRealm, sizeof szRealm/sizeof(WCHAR)) )
+        {
+            hitem = GetDlgItem( hdlg, IDC_REALM );
+            SetWindowTextW( hitem, szRealm );
+        }
+
+        /* extract the name of the proxy server */
+        if( WININET_GetProxyServer( params->hRequest, 
+                                    szServer, sizeof szServer/sizeof(WCHAR)) )
+        {
+            hitem = GetDlgItem( hdlg, IDC_PROXY );
+            SetWindowTextW( hitem, szServer );
+        }
+
+        WININET_GetSetPassword( hdlg, szServer, szRealm, FALSE );
+
+        return TRUE;
+    }
+
+    params = (struct WININET_ErrorDlgParams*)
+                 GetWindowLongPtrW( hdlg, GWLP_USERDATA );
+
+    switch( uMsg )
+    {
+    case WM_COMMAND:
+        if( wParam == IDOK )
+        {
+            WCHAR username[0x20], password[0x20];
+
+            username[0] = 0;
+            hitem = GetDlgItem( hdlg, IDC_USERNAME );
+            if( hitem )
+                GetWindowTextW( hitem, username, sizeof username/sizeof(WCHAR) );
+            
+            password[0] = 0;
+            hitem = GetDlgItem( hdlg, IDC_PASSWORD );
+            if( hitem )
+                GetWindowTextW( hitem, password, sizeof password/sizeof(WCHAR) );
+
+            hitem = GetDlgItem( hdlg, IDC_SAVEPASSWORD );
+            if( hitem &&
+                SendMessageW( hitem, BM_GETSTATE, 0, 0 ) &&
+                WININET_GetAuthRealm( params->hRequest,
+                                  szRealm, sizeof szRealm/sizeof(WCHAR)) &&
+                WININET_GetProxyServer( params->hRequest, 
+                                    szServer, sizeof szServer/sizeof(WCHAR)) )
+            {
+                WININET_GetSetPassword( hdlg, szServer, szRealm, TRUE );
+            }
+            WININET_SetProxyAuthorization( params->hRequest, username, password );
+
+            EndDialog( hdlg, ERROR_INTERNET_FORCE_RETRY );
+            return TRUE;
+        }
+        if( wParam == IDCANCEL )
+        {
+            EndDialog( hdlg, 0 );
+            return TRUE;
+        }
+        break;
+    }
+    return FALSE;
+}
+
+/***********************************************************************
+ *         WININET_GetConnectionStatus
+ */
+static INT WININET_GetConnectionStatus( HINTERNET hRequest )
+{
+    WCHAR szStatus[0x20];
+    DWORD sz, index, dwStatus;
+
+    TRACE("%p\n", hRequest );
+
+    sz = sizeof szStatus;
+    index = 0;
+    if( !HttpQueryInfoW( hRequest, HTTP_QUERY_STATUS_CODE,
+                    szStatus, &sz, &index))
+        return -1;
+    dwStatus = atoiW( szStatus );
+
+    TRACE("request %p status = %ld\n", hRequest, dwStatus );
+
+    return dwStatus;
+}
+
+
+/***********************************************************************
+ *         InternetErrorDlg
+ */
+DWORD WINAPI InternetErrorDlg(HWND hWnd, HINTERNET hRequest,
+                 DWORD dwError, DWORD dwFlags, LPVOID* lppvData)
+{
+    struct WININET_ErrorDlgParams params;
+    HMODULE hwininet = GetModuleHandleA( "wininet.dll" );
+    INT dwStatus;
+
+    TRACE("%p %p %ld %08lx %p\n", hWnd, hRequest, dwError, dwFlags, lppvData);
+
+    params.hWnd = hWnd;
+    params.hRequest = hRequest;
+    params.dwError = dwError;
+    params.dwFlags = dwFlags;
+    params.lppvData = lppvData;
+
+    switch( dwError )
+    {
+    case ERROR_SUCCESS:
+        if( !(dwFlags & FLAGS_ERROR_UI_FILTER_FOR_ERRORS ) )
+            return 0;
+        dwStatus = WININET_GetConnectionStatus( hRequest );
+        if( HTTP_STATUS_PROXY_AUTH_REQ != dwStatus )
+            return ERROR_SUCCESS;
+        return DialogBoxParamW( hwininet, MAKEINTRESOURCEW( IDD_PROXYDLG ),
+                    hWnd, WININET_ProxyPasswordDialog, (LPARAM) &params );
+
+    case ERROR_INTERNET_INCORRECT_PASSWORD:
+        return DialogBoxParamW( hwininet, MAKEINTRESOURCEW( IDD_PROXYDLG ),
+                    hWnd, WININET_ProxyPasswordDialog, (LPARAM) &params );
+
+    case ERROR_INTERNET_HTTP_TO_HTTPS_ON_REDIR:
+    case ERROR_INTERNET_INVALID_CA:
+    case ERROR_INTERNET_POST_IS_NON_SECURE:
+    case ERROR_INTERNET_SEC_CERT_CN_INVALID:
+    case ERROR_INTERNET_SEC_CERT_DATE_INVALID:
+        FIXME("Need to display dialog for error %ld\n", dwError);
+        return ERROR_SUCCESS;
+    }
+    return ERROR_INVALID_PARAMETER;
+}

reactos/lib/wininet/gopher.c

@@ -0,0 +1,256 @@
+/*
+ * WININET - Gopher implementation
+ *
+ * Copyright 2003 Kirill Smelkov
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "config.h"
+
+#include <stdarg.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "wininet.h"
+
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(wininet);
+
+/***********************************************************************
+ *           GopherCreateLocatorA (WININET.@)
+ *
+ * Create a Gopher locator string from its component parts
+ *
+ * PARAMS
+ *  lpszHost            [I] host name
+ *  nServerPort         [I] port in host byteorder or INTERNET_INVALID_PORT_NUMBER for default
+ *  lpszDisplayString   [I] document/directory to display (NULL - default directory)
+ *  lpszSelectorString  [I] selector string for server (NULL - none)
+ *  dwGopherType        [I] selector type (see GOPHER_TYPE_xxx)
+ *  lpszLocator         [O] buffer for locator string
+ *  lpdwBufferLength    [I] locator buffer length
+ *
+ * RETURNS
+ *  TRUE  on success
+ *  FALSE on failure
+ *
+ */
+BOOL WINAPI GopherCreateLocatorA(
+ LPCSTR        lpszHost,
+ INTERNET_PORT nServerPort,
+ LPCSTR        lpszDisplayString,
+ LPCSTR        lpszSelectorString,
+ DWORD         dwGopherType,
+ LPSTR         lpszLocator,
+ LPDWORD       lpdwBufferLength
+)
+{
+    FIXME("stub\n");
+    return FALSE;
+}
+
+/***********************************************************************
+ *           GopherCreateLocatorW (WININET.@)
+ * 
+ * Unicode version of GopherCreateLocatorA
+ */
+BOOL WINAPI GopherCreateLocatorW(
+ LPCWSTR       lpszHost,
+ INTERNET_PORT nServerPort,
+ LPCWSTR       lpszDisplayString,
+ LPCWSTR       lpszSelectorString,
+ DWORD         dwHopherType,
+ LPWSTR        lpszLocator,
+ LPDWORD       lpdwBufferLength
+)
+{
+    FIXME("stub\n");
+    return FALSE;
+}
+
+/***********************************************************************
+ *           GopherFindFirstFileA (WININET.@)
+ *
+ * Create a session and locate the requested documents
+ *
+ * PARAMS
+ *  hConnect        [I] Handle to a Gopher session returned by InternetConnect
+ *  lpszLocator     [I] - address of a string containing the name of the item to locate.
+ *                      - Locator created by the GopherCreateLocator function.
+ * lpszSearchString [I] what to search for if this request is to an index server.
+ *                      Otherwise, this parameter should be NULL.
+ * lpFindData       [O] retrived information
+ * dwFlags          [I] INTERNET_FLAG_{HYPERLINK, NEED_FILE, NO_CACHE_WRITE, RELOAD, RESYNCHRONIZE}
+ * dwContext        [I] application private value
+ *
+ * RETURNS
+ *  HINTERNET handle on success
+ *  NULL on error
+ */
+HINTERNET WINAPI GopherFindFirstFileA(
+ HINTERNET hConnect,
+ LPCSTR    lpszLocator,
+ LPCSTR    lpszSearchString,
+ LPGOPHER_FIND_DATAA
+           lpFindData,
+ DWORD     dwFlags,
+ DWORD     dwContext
+)
+{
+    FIXME("stub\n");
+    return NULL;
+}
+
+/***********************************************************************
+ *           GopherFindFirstFileW (WININET.@)
+ *
+ * Unicode version of GopherFindFirstFileA
+ */
+HINTERNET WINAPI GopherFindFirstFileW(
+ HINTERNET hConnect,
+ LPCWSTR   lpszLocator,
+ LPCWSTR   lpszSearchString,
+ LPGOPHER_FIND_DATAW
+           lpFindData,
+ DWORD     dwFlags,
+ DWORD     dwContext
+)
+{
+    FIXME("stub\n");
+    return NULL;
+}
+
+/***********************************************************************
+ *           GopherGetAttributeA (WININET.@)
+ *
+ * Retrieves the specific attribute information from the server.
+ * 
+ * RETURNS
+ *  TRUE on success
+ *  FALSE on failure
+ */
+BOOL WINAPI GopherGetAttributeA(
+ HINTERNET hConnect,
+ LPCSTR    lpszLocator,
+ LPCSTR    lpszAttributeName,
+ LPBYTE    lpBuffer,
+ DWORD     dwBufferLength,
+ LPDWORD   lpdwCharactersReturned,
+ GOPHER_ATTRIBUTE_ENUMERATORA
+           lpfnEnumerator,
+ DWORD     dwContext
+)
+{
+    FIXME("stub\n");
+    return FALSE;
+}
+
+/***********************************************************************
+ *           GopherGetAttributeW (WININET.@)
+ *
+ * Unicode version of GopherGetAttributeA
+ */
+BOOL WINAPI GopherGetAttributeW(
+ HINTERNET hConnect,
+ LPCWSTR   lpszLocator,
+ LPCWSTR   lpszAttributeName,
+ LPBYTE    lpBuffer,
+ DWORD     dwBufferLength,
+ LPDWORD   lpdwCharactersReturned,
+ GOPHER_ATTRIBUTE_ENUMERATORW
+           lpfnEnumerator,
+ DWORD     dwContext
+)
+{
+    FIXME("stub\n");
+    return FALSE;
+}
+
+/***********************************************************************
+ *           GopherGetLocatorTypeA (WININET.@)
+ *
+ * Parses a Gopher locator and determines its attributes.
+ *
+ * PARAMS
+ *  lpszLocator     [I] Address of the Gopher locator string to parse
+ *  lpdwGopherType  [O] destination for bitmasked type of locator
+ *
+ * RETURNS
+ *  TRUE  on success
+ *  FALSE on failure
+ */
+BOOL WINAPI GopherGetLocatorTypeA(LPCSTR lpszLocator, LPDWORD lpdwGopherType)
+{
+    FIXME("stub\n");
+    return FALSE;
+}
+
+/***********************************************************************
+ *           GopherGetLocatorTypeW (WININET.@)
+ *
+ * Unicode version of GopherGetLocatorTypeA
+ */
+BOOL WINAPI GopherGetLocatorTypeW(LPCWSTR lpszLocator, LPDWORD lpdwGopherType)
+{
+    FIXME("stub\n");
+    return FALSE;
+}
+
+/***********************************************************************
+ *           GopherOpenFileA (WININET.@)
+ *
+ * Begins reading a Gopher data file from a Gopher server.
+ *
+ * PARAMS
+ *  hConnect    [I] handle to a Gopher session
+ *  lpszLocator [I] file locator
+ *  lpszView    [I] file view (or default if NULL)
+ *  dwFlags     [I] INTERNET_FLAG_{HYPERLINK, NEED_FILE, NO_CACHE_WRITE, RELOAD, RESYNCHRONIZE}
+ *  dwContext   [I] application private value
+ *
+ * RETURNS
+ *  handle  on success
+ *  NULL    on error
+ */
+HINTERNET WINAPI GopherOpenFileA(
+ HINTERNET hConnect,
+ LPCSTR    lpszLocator,
+ LPCSTR    lpszView,
+ DWORD     dwFlags,
+ DWORD     dwContext
+)
+{
+    FIXME("stub\n");
+    return NULL;
+}
+
+/***********************************************************************
+ *           GopherOpenFileW (WININET.@)
+ *
+ * Unicode version of GopherOpenFileA
+ */
+HINTERNET WINAPI GopherOpenFileW(
+ HINTERNET hConnect,
+ LPCWSTR   lpszLocator,
+ LPCWSTR   lpszView,
+ DWORD     dwFlags,
+ DWORD     dwContext
+)
+{
+    FIXME("stub\n");
+    return NULL;
+}

reactos/lib/wininet/internet.h

@@ -0,0 +1,496 @@
+/*
+ * Wininet
+ *
+ * Copyright 1999 Corel Corporation
+ *
+ * Ulrich Czekalla
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _WINE_INTERNET_H_
+#define _WINE_INTERNET_H_
+
+#include "wine/unicode.h"
+
+#include <time.h>
+#ifdef HAVE_NETDB_H
+# include <netdb.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+# include <sys/types.h>
+# include <netinet/in.h>
+#endif
+#ifdef HAVE_OPENSSL_SSL_H
+#define DSA __ssl_DSA  /* avoid conflict with commctrl.h */
+#undef FAR
+# include <openssl/ssl.h>
+#undef FAR
+#define FAR do_not_use_this_in_wine
+#undef DSA
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+# include <sys/socket.h>
+#endif
+
+#if defined(__MINGW32__) || defined (_MSC_VER)
+#include "winsock2.h"
+#ifndef MSG_WAITALL
+#define MSG_WAITALL 0
+#endif
+#else
+#define closesocket close
+#endif /* __MINGW32__ */
+
+/* used for netconnection.c stuff */
+typedef struct
+{
+    BOOL useSSL;
+    int socketFD;
+#ifdef HAVE_OPENSSL_SSL_H
+    SSL *ssl_s;
+    char *peek_msg;
+    char *peek_msg_mem;
+#endif
+} WININET_NETCONNECTION;
+
+inline static LPSTR WININET_strdup( LPCSTR str )
+{
+    LPSTR ret = HeapAlloc( GetProcessHeap(), 0, strlen(str) + 1 );
+    if (ret) strcpy( ret, str );
+    return ret;
+}
+
+inline static LPWSTR WININET_strdupW( LPCWSTR str )
+{
+    LPWSTR ret = HeapAlloc( GetProcessHeap(), 0, (strlenW(str) + 1)*sizeof(WCHAR) );
+    if (ret) strcpyW( ret, str );
+    return ret;
+}
+
+inline static LPWSTR WININET_strdup_AtoW( LPCSTR str )
+{
+    int len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0);
+    LPWSTR ret = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
+    if (ret)
+        MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len);
+    return ret;
+}
+
+inline static LPSTR WININET_strdup_WtoA( LPCWSTR str )
+{
+    int len = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL);
+    LPSTR ret = HeapAlloc( GetProcessHeap(), 0, len );
+    if (ret)
+        WideCharToMultiByte( CP_ACP, 0, str, -1, ret, len, NULL, NULL);
+    return ret;
+}
+
+inline static void WININET_find_data_WtoA(LPWIN32_FIND_DATAW dataW, LPWIN32_FIND_DATAA dataA)
+{
+    dataA->dwFileAttributes = dataW->dwFileAttributes;
+    dataA->ftCreationTime   = dataW->ftCreationTime;
+    dataA->ftLastAccessTime = dataW->ftLastAccessTime;
+    dataA->ftLastWriteTime  = dataW->ftLastWriteTime;
+    dataA->nFileSizeHigh    = dataW->nFileSizeHigh;
+    dataA->nFileSizeLow     = dataW->nFileSizeLow;
+    dataA->dwReserved0      = dataW->dwReserved0;
+    dataA->dwReserved1      = dataW->dwReserved1;
+    WideCharToMultiByte(CP_ACP, 0, dataW->cFileName, -1, 
+        dataA->cFileName, sizeof(dataA->cFileName),
+        NULL, NULL);
+    WideCharToMultiByte(CP_ACP, 0, dataW->cAlternateFileName, -1, 
+        dataA->cAlternateFileName, sizeof(dataA->cAlternateFileName),
+        NULL, NULL);
+}
+
+typedef enum
+{
+    WH_HINIT = INTERNET_HANDLE_TYPE_INTERNET,
+    WH_HFTPSESSION = INTERNET_HANDLE_TYPE_CONNECT_FTP,
+    WH_HGOPHERSESSION = INTERNET_HANDLE_TYPE_CONNECT_GOPHER,
+    WH_HHTTPSESSION = INTERNET_HANDLE_TYPE_CONNECT_HTTP,
+    WH_HFILE = INTERNET_HANDLE_TYPE_FTP_FILE,
+    WH_HFINDNEXT = INTERNET_HANDLE_TYPE_FTP_FIND,
+    WH_HHTTPREQ = INTERNET_HANDLE_TYPE_HTTP_REQUEST,
+} WH_TYPE;
+
+#define INET_OPENURL 0x0001
+#define INET_CALLBACKW 0x0002
+
+struct _WININETHANDLEHEADER;
+typedef struct _WININETHANDLEHEADER WININETHANDLEHEADER, *LPWININETHANDLEHEADER;
+
+typedef void (*WININET_object_destructor)( LPWININETHANDLEHEADER );
+
+struct _WININETHANDLEHEADER
+{
+    WH_TYPE htype;
+    DWORD  dwFlags;
+    DWORD  dwContext;
+    DWORD  dwError;
+    DWORD  dwInternalFlags;
+    DWORD  dwRefCount;
+    WININET_object_destructor destroy;
+    INTERNET_STATUS_CALLBACK lpfnStatusCB;
+    struct _WININETHANDLEHEADER *lpwhparent;
+};
+
+
+typedef struct
+{
+    WININETHANDLEHEADER hdr;
+    LPWSTR  lpszAgent;
+    LPWSTR  lpszProxy;
+    LPWSTR  lpszProxyBypass;
+    LPWSTR  lpszProxyUsername;
+    LPWSTR  lpszProxyPassword;
+    DWORD   dwAccessType;
+} WININETAPPINFOW, *LPWININETAPPINFOW;
+
+
+typedef struct
+{
+    WININETHANDLEHEADER hdr;
+    LPWSTR  lpszHostName; /* the final destination of the request */
+    LPWSTR  lpszServerName; /* the name of the server we directly connect to */
+    LPWSTR  lpszUserName;
+    INTERNET_PORT nHostPort; /* the final destination port of the request */
+    INTERNET_PORT nServerPort; /* the port of the server we directly connect to */
+    struct sockaddr_in socketAddress;
+} WININETHTTPSESSIONW, *LPWININETHTTPSESSIONW;
+
+#define HDR_ISREQUEST		0x0001
+#define HDR_COMMADELIMITED	0x0002
+#define HDR_SEMIDELIMITED	0x0004
+
+typedef struct
+{
+    LPWSTR lpszField;
+    LPWSTR lpszValue;
+    WORD wFlags;
+    WORD wCount;
+} HTTPHEADERW, *LPHTTPHEADERW;
+
+
+typedef struct
+{
+    WININETHANDLEHEADER hdr;
+    LPWSTR lpszPath;
+    LPWSTR lpszVerb;
+    LPWSTR lpszRawHeaders;
+    WININET_NETCONNECTION netConnection;
+    LPWSTR lpszVersion;
+    LPWSTR lpszStatusText;
+    HTTPHEADERW *pCustHeaders;
+    DWORD nCustHeaders;
+} WININETHTTPREQW, *LPWININETHTTPREQW;
+
+
+typedef struct
+{
+    WININETHANDLEHEADER hdr;
+    BOOL session_deleted;
+    int nDataSocket;
+} WININETFILE, *LPWININETFILE;
+
+
+typedef struct
+{
+    WININETHANDLEHEADER hdr;
+    int sndSocket;
+    int lstnSocket;
+    int pasvSocket; /* data socket connected by us in case of passive FTP */
+    LPWININETFILE download_in_progress;
+    struct sockaddr_in socketAddress;
+    struct sockaddr_in lstnSocketAddress;
+    LPWSTR  lpszPassword;
+    LPWSTR  lpszUserName;
+} WININETFTPSESSIONW, *LPWININETFTPSESSIONW;
+
+
+typedef struct
+{
+    BOOL bIsDirectory;
+    LPWSTR lpszName;
+    DWORD nSize;
+    struct tm tmLastModified;
+    unsigned short permissions;
+} FILEPROPERTIESW, *LPFILEPROPERTIESW;
+
+
+typedef struct
+{
+    WININETHANDLEHEADER hdr;
+    DWORD index;
+    DWORD size;
+    LPFILEPROPERTIESW lpafp;
+} WININETFINDNEXTW, *LPWININETFINDNEXTW;
+
+typedef enum
+{
+    FTPPUTFILEW,
+    FTPSETCURRENTDIRECTORYW,
+    FTPCREATEDIRECTORYW,
+    FTPFINDFIRSTFILEW,
+    FTPGETCURRENTDIRECTORYW,
+    FTPOPENFILEW,
+    FTPGETFILEW,
+    FTPDELETEFILEW,
+    FTPREMOVEDIRECTORYW,
+    FTPRENAMEFILEW,
+    INTERNETFINDNEXTW,
+    HTTPSENDREQUESTW,
+    HTTPOPENREQUESTW,
+    SENDCALLBACK,
+    INTERNETOPENURLW,
+    INTERNETREADFILEEXA,
+} ASYNC_FUNC;
+
+struct WORKREQ_FTPPUTFILEW
+{
+    LPWSTR lpszLocalFile;
+    LPWSTR lpszNewRemoteFile;
+    DWORD  dwFlags;
+    DWORD  dwContext;
+};
+
+struct WORKREQ_FTPSETCURRENTDIRECTORYW
+{
+    LPWSTR lpszDirectory;
+};
+
+struct WORKREQ_FTPCREATEDIRECTORYW
+{
+    LPWSTR lpszDirectory;
+};
+
+struct WORKREQ_FTPFINDFIRSTFILEW
+{
+    LPWSTR lpszSearchFile;
+    LPWIN32_FIND_DATAW lpFindFileData;
+    DWORD  dwFlags;
+    DWORD  dwContext;
+};
+
+struct WORKREQ_FTPGETCURRENTDIRECTORYW
+{
+    LPWSTR lpszDirectory;
+    DWORD *lpdwDirectory;
+};
+
+struct WORKREQ_FTPOPENFILEW
+{
+    LPWSTR lpszFilename;
+    DWORD  dwAccess;
+    DWORD  dwFlags;
+    DWORD  dwContext;
+};
+
+struct WORKREQ_FTPGETFILEW
+{
+    LPWSTR lpszRemoteFile;
+    LPWSTR lpszNewFile;
+    BOOL   fFailIfExists;
+    DWORD  dwLocalFlagsAttribute;
+    DWORD  dwFlags;
+    DWORD  dwContext;
+};
+
+struct WORKREQ_FTPDELETEFILEW
+{
+    LPWSTR lpszFilename;
+};
+
+struct WORKREQ_FTPREMOVEDIRECTORYW
+{
+    LPWSTR lpszDirectory;
+};
+
+struct WORKREQ_FTPRENAMEFILEW
+{
+    LPWSTR lpszSrcFile;
+    LPWSTR lpszDestFile;
+};
+
+struct WORKREQ_INTERNETFINDNEXTW
+{
+    LPWIN32_FIND_DATAW lpFindFileData;
+};
+
+struct WORKREQ_HTTPOPENREQUESTW
+{
+    LPWSTR lpszVerb;
+    LPWSTR lpszObjectName;
+    LPWSTR lpszVersion;
+    LPWSTR lpszReferrer;
+    LPCWSTR *lpszAcceptTypes;
+    DWORD  dwFlags;
+    DWORD  dwContext;
+};
+
+struct WORKREQ_HTTPSENDREQUESTW
+{
+    LPWSTR lpszHeader;
+    DWORD  dwHeaderLength;
+    LPVOID lpOptional;
+    DWORD  dwOptionalLength;
+    DWORD  dwContentLength;
+    BOOL   bEndRequest;
+};
+
+struct WORKREQ_SENDCALLBACK
+{
+    DWORD     dwContext;
+    DWORD     dwInternetStatus;
+    LPVOID    lpvStatusInfo;
+    DWORD     dwStatusInfoLength;
+};
+
+struct WORKREQ_INTERNETOPENURLW
+{
+    HINTERNET hInternet;
+    LPWSTR     lpszUrl;
+    LPWSTR     lpszHeaders;
+    DWORD     dwHeadersLength;
+    DWORD     dwFlags;
+    DWORD     dwContext;
+};
+
+struct WORKREQ_INTERNETREADFILEEXA
+{
+    LPINTERNET_BUFFERSA lpBuffersOut;
+};
+
+typedef struct WORKREQ
+{
+    ASYNC_FUNC asyncall;
+    WININETHANDLEHEADER *hdr;
+
+    union {
+        struct WORKREQ_FTPPUTFILEW              FtpPutFileW;
+        struct WORKREQ_FTPSETCURRENTDIRECTORYW  FtpSetCurrentDirectoryW;
+        struct WORKREQ_FTPCREATEDIRECTORYW      FtpCreateDirectoryW;
+        struct WORKREQ_FTPFINDFIRSTFILEW        FtpFindFirstFileW;
+        struct WORKREQ_FTPGETCURRENTDIRECTORYW  FtpGetCurrentDirectoryW;
+        struct WORKREQ_FTPOPENFILEW             FtpOpenFileW;
+        struct WORKREQ_FTPGETFILEW              FtpGetFileW;
+        struct WORKREQ_FTPDELETEFILEW           FtpDeleteFileW;
+        struct WORKREQ_FTPREMOVEDIRECTORYW      FtpRemoveDirectoryW;
+        struct WORKREQ_FTPRENAMEFILEW           FtpRenameFileW;
+        struct WORKREQ_INTERNETFINDNEXTW        InternetFindNextW;
+        struct WORKREQ_HTTPOPENREQUESTW         HttpOpenRequestW;
+        struct WORKREQ_HTTPSENDREQUESTW         HttpSendRequestW;
+        struct WORKREQ_SENDCALLBACK             SendCallback;
+	struct WORKREQ_INTERNETOPENURLW         InternetOpenUrlW;
+        struct WORKREQ_INTERNETREADFILEEXA      InternetReadFileExA;
+    } u;
+
+    struct WORKREQ *next;
+    struct WORKREQ *prev;
+
+} WORKREQUEST, *LPWORKREQUEST;
+
+HINTERNET WININET_AllocHandle( LPWININETHANDLEHEADER info );
+LPWININETHANDLEHEADER WININET_GetObject( HINTERNET hinternet );
+LPWININETHANDLEHEADER WININET_AddRef( LPWININETHANDLEHEADER info );
+BOOL WININET_Release( LPWININETHANDLEHEADER info );
+BOOL WININET_FreeHandle( HINTERNET hinternet );
+HINTERNET WININET_FindHandle( LPWININETHANDLEHEADER info );
+
+time_t ConvertTimeString(LPCWSTR asctime);
+
+HINTERNET FTP_Connect(LPWININETAPPINFOW hIC, LPCWSTR lpszServerName,
+	INTERNET_PORT nServerPort, LPCWSTR lpszUserName,
+	LPCWSTR lpszPassword, DWORD dwFlags, DWORD dwContext,
+	DWORD dwInternalFlags);
+
+HINTERNET HTTP_Connect(LPWININETAPPINFOW hIC, LPCWSTR lpszServerName,
+	INTERNET_PORT nServerPort, LPCWSTR lpszUserName,
+	LPCWSTR lpszPassword, DWORD dwFlags, DWORD dwContext,
+	DWORD dwInternalFlags);
+
+BOOL GetAddress(LPCWSTR lpszServerName, INTERNET_PORT nServerPort,
+	struct sockaddr_in *psa);
+
+void INTERNET_SetLastError(DWORD dwError);
+DWORD INTERNET_GetLastError(void);
+BOOL INTERNET_AsyncCall(LPWORKREQUEST lpWorkRequest);
+LPSTR INTERNET_GetResponseBuffer(void);
+LPSTR INTERNET_GetNextLine(INT nSocket, LPDWORD dwLen);
+
+BOOLAPI FTP_FtpPutFileW(LPWININETFTPSESSIONW lpwfs, LPCWSTR lpszLocalFile,
+    LPCWSTR lpszNewRemoteFile, DWORD dwFlags, DWORD dwContext);
+BOOLAPI FTP_FtpSetCurrentDirectoryW(LPWININETFTPSESSIONW lpwfs, LPCWSTR lpszDirectory);
+BOOLAPI FTP_FtpCreateDirectoryW(LPWININETFTPSESSIONW lpwfs, LPCWSTR lpszDirectory);
+INTERNETAPI HINTERNET WINAPI FTP_FtpFindFirstFileW(LPWININETFTPSESSIONW lpwfs,
+    LPCWSTR lpszSearchFile, LPWIN32_FIND_DATAW lpFindFileData, DWORD dwFlags, DWORD dwContext);
+BOOLAPI FTP_FtpGetCurrentDirectoryW(LPWININETFTPSESSIONW lpwfs, LPWSTR lpszCurrentDirectory,
+	LPDWORD lpdwCurrentDirectory);
+BOOL FTP_ConvertFileProp(LPFILEPROPERTIESW lpafp, LPWIN32_FIND_DATAW lpFindFileData);
+BOOL FTP_FtpRenameFileW(LPWININETFTPSESSIONW lpwfs, LPCWSTR lpszSrc, LPCWSTR lpszDest);
+BOOL FTP_FtpRemoveDirectoryW(LPWININETFTPSESSIONW lpwfs, LPCWSTR lpszDirectory);
+BOOL FTP_FtpDeleteFileW(LPWININETFTPSESSIONW lpwfs, LPCWSTR lpszFileName);
+HINTERNET FTP_FtpOpenFileW(LPWININETFTPSESSIONW lpwfs, LPCWSTR lpszFileName,
+	DWORD fdwAccess, DWORD dwFlags, DWORD dwContext);
+BOOLAPI FTP_FtpGetFileW(LPWININETFTPSESSIONW lpwfs, LPCWSTR lpszRemoteFile, LPCWSTR lpszNewFile,
+	BOOL fFailIfExists, DWORD dwLocalFlagsAttribute, DWORD dwInternetFlags,
+	DWORD dwContext);
+
+BOOLAPI HTTP_HttpSendRequestW(LPWININETHTTPREQW lpwhr, LPCWSTR lpszHeaders,
+	DWORD dwHeaderLength, LPVOID lpOptional, DWORD dwOptionalLength,
+	DWORD dwContentLength, BOOL bEndRequest);
+INTERNETAPI HINTERNET WINAPI HTTP_HttpOpenRequestW(LPWININETHTTPSESSIONW lpwhs,
+	LPCWSTR lpszVerb, LPCWSTR lpszObjectName, LPCWSTR lpszVersion,
+	LPCWSTR lpszReferrer , LPCWSTR *lpszAcceptTypes,
+	DWORD dwFlags, DWORD dwContext);
+
+VOID SendAsyncCallback(LPWININETHANDLEHEADER hdr, DWORD dwContext,
+                       DWORD dwInternetStatus, LPVOID lpvStatusInfo,
+                       DWORD dwStatusInfoLength);
+
+VOID INTERNET_SendCallback(LPWININETHANDLEHEADER hdr, DWORD dwContext,
+                           DWORD dwInternetStatus, LPVOID lpvStatusInfo,
+                           DWORD dwStatusInfoLength);
+
+LPHTTPHEADERW HTTP_GetHeader(LPWININETHTTPREQW lpwhr, LPCWSTR header);
+
+BOOL NETCON_connected(WININET_NETCONNECTION *connection);
+void NETCON_init(WININET_NETCONNECTION *connnection, BOOL useSSL);
+BOOL NETCON_create(WININET_NETCONNECTION *connection, int domain,
+	      int type, int protocol);
+BOOL NETCON_close(WININET_NETCONNECTION *connection);
+BOOL NETCON_connect(WININET_NETCONNECTION *connection, const struct sockaddr *serv_addr,
+		    unsigned int addrlen);
+BOOL NETCON_secure_connect(WININET_NETCONNECTION *connection, LPCWSTR hostname);
+BOOL NETCON_send(WININET_NETCONNECTION *connection, const void *msg, size_t len, int flags,
+		int *sent /* out */);
+BOOL NETCON_recv(WININET_NETCONNECTION *connection, void *buf, size_t len, int flags,
+		int *recvd /* out */);
+BOOL NETCON_getNextLine(WININET_NETCONNECTION *connection, LPSTR lpszBuffer, LPDWORD dwBuffer);
+
+extern void URLCacheContainers_CreateDefaults(void);
+extern void URLCacheContainers_DeleteAll(void);
+
+#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_ */

reactos/lib/wininet/netconnection.c

@@ -0,0 +1,598 @@
+/*
+ * Wininet - networking layer. Uses unix sockets or OpenSSL.
+ *
+ * Copyright 2002 TransGaming Technologies Inc.
+ *
+ * David Hammerton
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "config.h"
+#include "wine/port.h"
+
+#ifdef HAVE_SYS_TIME_H
+# include <sys/time.h>
+#endif
+#include <sys/types.h>
+#ifdef HAVE_SYS_SOCKET_H
+# include <sys/socket.h>
+#endif
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+
+#include "wine/library.h"
+#include "windef.h"
+#include "winbase.h"
+#include "wininet.h"
+#include "winerror.h"
+
+/* To avoid conflicts with the Unix socket headers. we only need it for
+ * the error codes anyway. */
+#define USE_WS_PREFIX
+#include "winsock2.h"
+
+#include "wine/debug.h"
+#include "internet.h"
+
+#define RESPONSE_TIMEOUT        30            /* FROM internet.c */
+
+
+WINE_DEFAULT_DEBUG_CHANNEL(wininet);
+
+/* FIXME!!!!!!
+ *    This should use winsock - To use winsock the functions will have to change a bit
+ *        as they are designed for unix sockets.
+ *    SSL stuff should use crypt32.dll
+ */
+
+#if defined HAVE_OPENSSL_SSL_H && defined HAVE_OPENSSL_ERR_H
+
+#include <openssl/err.h>
+
+#ifndef SONAME_LIBSSL
+#define SONAME_LIBSSL "libssl.so"
+#endif
+#ifndef SONAME_LIBCRYPTO
+#define SONAME_LIBCRYPTO "libcrypto.so"
+#endif
+
+static void *OpenSSL_ssl_handle;
+static void *OpenSSL_crypto_handle;
+
+static SSL_METHOD *meth;
+static SSL_CTX *ctx;
+
+#define MAKE_FUNCPTR(f) static typeof(f) * p##f
+
+/* OpenSSL functions that we use */
+MAKE_FUNCPTR(SSL_library_init);
+MAKE_FUNCPTR(SSL_load_error_strings);
+MAKE_FUNCPTR(SSLv23_method);
+MAKE_FUNCPTR(SSL_CTX_new);
+MAKE_FUNCPTR(SSL_new);
+MAKE_FUNCPTR(SSL_free);
+MAKE_FUNCPTR(SSL_set_fd);
+MAKE_FUNCPTR(SSL_connect);
+MAKE_FUNCPTR(SSL_shutdown);
+MAKE_FUNCPTR(SSL_write);
+MAKE_FUNCPTR(SSL_read);
+MAKE_FUNCPTR(SSL_get_verify_result);
+MAKE_FUNCPTR(SSL_get_peer_certificate);
+MAKE_FUNCPTR(SSL_CTX_get_timeout);
+MAKE_FUNCPTR(SSL_CTX_set_timeout);
+MAKE_FUNCPTR(SSL_CTX_set_default_verify_paths);
+
+/* OpenSSL's libcrypto functions that we use */
+MAKE_FUNCPTR(BIO_new_fp);
+MAKE_FUNCPTR(ERR_get_error);
+MAKE_FUNCPTR(ERR_error_string);
+#undef MAKE_FUNCPTR
+
+#endif
+
+void NETCON_init(WININET_NETCONNECTION *connection, BOOL useSSL)
+{
+    connection->useSSL = FALSE;
+    connection->socketFD = -1;
+    if (useSSL)
+    {
+#if defined HAVE_OPENSSL_SSL_H && defined HAVE_OPENSSL_ERR_H
+        TRACE("using SSL connection\n");
+	if (OpenSSL_ssl_handle) /* already initilzed everything */
+            return;
+	OpenSSL_ssl_handle = wine_dlopen(SONAME_LIBSSL, RTLD_NOW, NULL, 0);
+	if (!OpenSSL_ssl_handle)
+	{
+	    ERR("trying to use a SSL connection, but couldn't load %s. Expect trouble.\n",
+		SONAME_LIBSSL);
+            connection->useSSL = FALSE;
+            return;
+	}
+	OpenSSL_crypto_handle = wine_dlopen(SONAME_LIBCRYPTO, RTLD_NOW, NULL, 0);
+	if (!OpenSSL_crypto_handle)
+	{
+	    ERR("trying to use a SSL connection, but couldn't load %s. Expect trouble.\n",
+		SONAME_LIBCRYPTO);
+            connection->useSSL = FALSE;
+            return;
+	}
+
+        /* mmm nice ugly macroness */
+#define DYNSSL(x) \
+    p##x = wine_dlsym(OpenSSL_ssl_handle, #x, NULL, 0); \
+    if (!p##x) \
+    { \
+        ERR("failed to load symbol %s\n", #x); \
+        connection->useSSL = FALSE; \
+        return; \
+    }
+
+	DYNSSL(SSL_library_init);
+	DYNSSL(SSL_load_error_strings);
+	DYNSSL(SSLv23_method);
+	DYNSSL(SSL_CTX_new);
+	DYNSSL(SSL_new);
+	DYNSSL(SSL_free);
+	DYNSSL(SSL_set_fd);
+	DYNSSL(SSL_connect);
+	DYNSSL(SSL_shutdown);
+	DYNSSL(SSL_write);
+	DYNSSL(SSL_read);
+	DYNSSL(SSL_get_verify_result);
+	DYNSSL(SSL_get_peer_certificate);
+	DYNSSL(SSL_CTX_get_timeout);
+	DYNSSL(SSL_CTX_set_timeout);
+	DYNSSL(SSL_CTX_set_default_verify_paths);
+#undef DYNSSL
+
+#define DYNCRYPTO(x) \
+    p##x = wine_dlsym(OpenSSL_crypto_handle, #x, NULL, 0); \
+    if (!p##x) \
+    { \
+        ERR("failed to load symbol %s\n", #x); \
+        connection->useSSL = FALSE; \
+        return; \
+    }
+	DYNCRYPTO(BIO_new_fp);
+	DYNCRYPTO(ERR_get_error);
+	DYNCRYPTO(ERR_error_string);
+#undef DYNCRYPTO
+
+	pSSL_library_init();
+	pSSL_load_error_strings();
+	pBIO_new_fp(stderr, BIO_NOCLOSE); /* FIXME: should use winedebug stuff */
+
+	meth = pSSLv23_method();
+        connection->peek_msg = NULL;
+        connection->peek_msg_mem = NULL;
+#else
+	FIXME("can't use SSL, not compiled in.\n");
+        connection->useSSL = FALSE;
+#endif
+    }
+}
+
+BOOL NETCON_connected(WININET_NETCONNECTION *connection)
+{
+    if (connection->socketFD == -1)
+        return FALSE;
+    else
+        return TRUE;
+}
+
+/******************************************************************************
+ * NETCON_create
+ * Basically calls 'socket()'
+ */
+BOOL NETCON_create(WININET_NETCONNECTION *connection, int domain,
+	      int type, int protocol)
+{
+#if defined HAVE_OPENSSL_SSL_H && defined HAVE_OPENSSL_ERR_H
+    if (connection->useSSL)
+        return FALSE;
+#endif
+
+    connection->socketFD = socket(domain, type, protocol);
+    if (INVALID_SOCKET == connection->socketFD)
+    {
+        INTERNET_SetLastError(WSAGetLastError());
+        return FALSE;
+    }
+    return TRUE;
+}
+
+/******************************************************************************
+ * NETCON_close
+ * Basically calls 'close()' unless we should use SSL
+ */
+BOOL NETCON_close(WININET_NETCONNECTION *connection)
+{
+    int result;
+
+    if (!NETCON_connected(connection)) return FALSE;
+
+#if defined HAVE_OPENSSL_SSL_H && defined HAVE_OPENSSL_ERR_H
+    if (connection->useSSL)
+    {
+        HeapFree(GetProcessHeap(),0,connection->peek_msg_mem);
+        connection->peek_msg = NULL;
+        connection->peek_msg_mem = NULL;
+
+        pSSL_shutdown(connection->ssl_s);
+        pSSL_free(connection->ssl_s);
+        connection->ssl_s = NULL;
+
+        connection->useSSL = FALSE;
+    }
+#endif
+
+    result = closesocket(connection->socketFD);
+    connection->socketFD = -1;
+
+    if (0 != result)
+    {
+        INTERNET_SetLastError(WSAGetLastError());
+        return FALSE;
+    }
+    return TRUE;
+}
+#if defined HAVE_OPENSSL_SSL_H && defined HAVE_OPENSSL_ERR_H
+static BOOL check_hostname(X509 *cert, char *hostname)
+{
+    /* FIXME: implement */
+    return TRUE;
+}
+#endif
+/******************************************************************************
+ * NETCON_secure_connect
+ * Initiates a secure connection over an existing plaintext connection.
+ */
+BOOL NETCON_secure_connect(WININET_NETCONNECTION *connection, LPCWSTR hostname)
+{
+#if defined HAVE_OPENSSL_SSL_H && defined HAVE_OPENSSL_ERR_H
+    long verify_res;
+    X509 *cert;
+    int len;
+    char *hostname_unix;
+
+    /* can't connect if we are already connected */
+    if (connection->useSSL)
+    {
+        ERR("already connected\n");
+        return FALSE;
+    }
+
+    ctx = pSSL_CTX_new(meth);
+    if (!pSSL_CTX_set_default_verify_paths(ctx))
+    {
+        ERR("SSL_CTX_set_default_verify_paths failed: %s\n",
+            pERR_error_string(pERR_get_error(), 0));
+        return FALSE;
+    }
+    connection->ssl_s = pSSL_new(ctx);
+    if (!connection->ssl_s)
+    {
+        ERR("SSL_new failed: %s\n",
+            pERR_error_string(pERR_get_error(), 0));
+        goto fail;
+    }
+
+    if (!pSSL_set_fd(connection->ssl_s, connection->socketFD))
+    {
+        ERR("SSL_set_fd failed: %s\n",
+            pERR_error_string(pERR_get_error(), 0));
+        goto fail;
+    }
+
+    if (pSSL_connect(connection->ssl_s) <= 0)
+    {
+        ERR("SSL_connect failed: %s\n",
+            pERR_error_string(pERR_get_error(), 0));
+        INTERNET_SetLastError(ERROR_INTERNET_SECURITY_CHANNEL_ERROR);
+        goto fail;
+    }
+    cert = pSSL_get_peer_certificate(connection->ssl_s);
+    if (!cert)
+    {
+        ERR("no certificate for server %s\n", debugstr_w(hostname));
+        /* FIXME: is this the best error? */
+        INTERNET_SetLastError(ERROR_INTERNET_INVALID_CA);
+        goto fail;
+    }
+    verify_res = pSSL_get_verify_result(connection->ssl_s);
+    if (verify_res != X509_V_OK)
+    {
+        ERR("couldn't verify the security of the connection, %ld\n", verify_res);
+        /* FIXME: we should set an error and return, but we only warn at
+         * the moment */
+    }
+
+    len = WideCharToMultiByte(CP_THREAD_ACP, 0, hostname, -1, NULL, 0, NULL, NULL);
+    hostname_unix = HeapAlloc(GetProcessHeap(), 0, len);
+    if (!hostname_unix)
+    {
+        INTERNET_SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+        goto fail;
+    }
+    WideCharToMultiByte(CP_THREAD_ACP, 0, hostname, -1, hostname_unix, len, NULL, NULL);
+
+    if (!check_hostname(cert, hostname_unix))
+    {
+        HeapFree(GetProcessHeap(), 0, hostname_unix);
+        INTERNET_SetLastError(ERROR_INTERNET_SEC_CERT_CN_INVALID);
+        goto fail;
+    }
+
+    HeapFree(GetProcessHeap(), 0, hostname_unix);
+    connection->useSSL = TRUE;
+    return TRUE;
+
+fail:
+    if (connection->ssl_s)
+    {
+        pSSL_shutdown(connection->ssl_s);
+        pSSL_free(connection->ssl_s);
+        connection->ssl_s = NULL;
+    }
+#endif
+    return FALSE;
+}
+
+/******************************************************************************
+ * NETCON_connect
+ * Connects to the specified address.
+ */
+BOOL NETCON_connect(WININET_NETCONNECTION *connection, const struct sockaddr *serv_addr,
+		    unsigned int addrlen)
+{
+    int result;
+
+    if (!NETCON_connected(connection)) return FALSE;
+
+    result = connect(connection->socketFD, serv_addr, addrlen);
+    if (SOCKET_ERROR == result)
+    {
+        WARN("Unable to connect to host (%s)\n", strerror(errno));
+        INTERNET_SetLastError(WSAGetLastError());
+
+        closesocket(connection->socketFD);
+        connection->socketFD = -1;
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+/******************************************************************************
+ * NETCON_send
+ * Basically calls 'send()' unless we should use SSL
+ * number of chars send is put in *sent
+ */
+BOOL NETCON_send(WININET_NETCONNECTION *connection, const void *msg, size_t len, int flags,
+		int *sent /* out */)
+{
+    if (!NETCON_connected(connection)) return FALSE;
+    if (!connection->useSSL)
+    {
+	*sent = send(connection->socketFD, msg, len, flags);
+	if (SOCKET_ERROR == *sent)
+	{
+	    INTERNET_SetLastError(WSAGetLastError());
+	    return FALSE;
+	}
+        return TRUE;
+    }
+    else
+    {
+#if defined HAVE_OPENSSL_SSL_H && defined HAVE_OPENSSL_ERR_H
+	if (flags)
+            FIXME("SSL_write doesn't support any flags (%08x)\n", flags);
+	*sent = pSSL_write(connection->ssl_s, msg, len);
+	if (*sent < 1 && len)
+	    return FALSE;
+        return TRUE;
+#else
+	return FALSE;
+#endif
+    }
+}
+
+/******************************************************************************
+ * NETCON_recv
+ * Basically calls 'recv()' unless we should use SSL
+ * number of chars received is put in *recvd
+ */
+BOOL NETCON_recv(WININET_NETCONNECTION *connection, void *buf, size_t len, int flags,
+		int *recvd /* out */)
+{
+    if (!NETCON_connected(connection)) return FALSE;
+    if (!connection->useSSL)
+    {
+	*recvd = recv(connection->socketFD, buf, len, flags);
+	if (SOCKET_ERROR == *recvd)
+	{
+	    INTERNET_SetLastError(WSAGetLastError());
+	    return FALSE;
+	}
+        return TRUE;
+    }
+    else
+    {
+#if defined HAVE_OPENSSL_SSL_H && defined HAVE_OPENSSL_ERR_H
+	if (flags & (~MSG_PEEK))
+	    FIXME("SSL_read does not support the following flag: %08x\n", flags);
+
+        /* this ugly hack is all for MSG_PEEK. eww gross */
+	if (flags & MSG_PEEK && !connection->peek_msg)
+	{
+	    connection->peek_msg = connection->peek_msg_mem = HeapAlloc(GetProcessHeap(), 0, (sizeof(char) * len) + 1);
+	}
+	else if (flags & MSG_PEEK && connection->peek_msg)
+	{
+	    size_t peek_msg_len = strlen(connection->peek_msg);
+	    if (len < peek_msg_len)
+		FIXME("buffer isn't big enough. Do the expect us to wrap?\n");
+	    memcpy(buf, connection->peek_msg, min(len,peek_msg_len+1));
+	    *recvd = min(len, peek_msg_len);
+            return TRUE;
+	}
+	else if (connection->peek_msg)
+	{
+	    size_t peek_msg_len = strlen(connection->peek_msg);
+	    memcpy(buf, connection->peek_msg, min(len,peek_msg_len+1));
+	    connection->peek_msg += *recvd = min(len, peek_msg_len);
+	    if (*connection->peek_msg == '\0' || *(connection->peek_msg - 1) == '\0')
+	    {
+		HeapFree(GetProcessHeap(), 0, connection->peek_msg_mem);
+		connection->peek_msg_mem = NULL;
+                connection->peek_msg = NULL;
+	    }
+            return TRUE;
+	}
+	*recvd = pSSL_read(connection->ssl_s, buf, len);
+	if (flags & MSG_PEEK) /* must copy stuff into buffer */
+	{
+	    if (!*recvd)
+	    {
+		HeapFree(GetProcessHeap(), 0, connection->peek_msg_mem);
+		connection->peek_msg_mem = NULL;
+		connection->peek_msg = NULL;
+	    }
+	    else
+	    {
+		memcpy(connection->peek_msg, buf, *recvd);
+		connection->peek_msg[*recvd] = '\0';
+	    }
+	}
+	if (*recvd < 1 && len)
+            return FALSE;
+        return TRUE;
+#else
+	return FALSE;
+#endif
+    }
+}
+
+/******************************************************************************
+ * NETCON_getNextLine
+ */
+BOOL NETCON_getNextLine(WININET_NETCONNECTION *connection, LPSTR lpszBuffer, LPDWORD dwBuffer)
+{
+
+    TRACE("\n");
+
+    if (!NETCON_connected(connection)) return FALSE;
+
+    if (!connection->useSSL)
+    {
+	struct timeval tv;
+	fd_set infd;
+	BOOL bSuccess = FALSE;
+	DWORD nRecv = 0;
+        int r;
+
+	FD_ZERO(&infd);
+	FD_SET(connection->socketFD, &infd);
+	tv.tv_sec=RESPONSE_TIMEOUT;
+	tv.tv_usec=0;
+
+	while (nRecv < *dwBuffer)
+	{
+	    if (select(connection->socketFD+1,&infd,NULL,NULL,&tv) > 0)
+	    {
+		r = recv(connection->socketFD, &lpszBuffer[nRecv], 1, 0);
+		if (0 == r || SOCKET_ERROR == r)
+		{
+		    INTERNET_SetLastError(WSAGetLastError());
+		    goto lend;
+		}
+
+		if (lpszBuffer[nRecv] == '\n')
+		{
+		    bSuccess = TRUE;
+		    break;
+		}
+		if (lpszBuffer[nRecv] != '\r')
+		    nRecv++;
+	    }
+	    else
+	    {
+		INTERNET_SetLastError(ERROR_INTERNET_TIMEOUT);
+		goto lend;
+	    }
+	}
+
+    lend:             /* FIXME: don't use labels */
+	if (bSuccess)
+	{
+	    lpszBuffer[nRecv++] = '\0';
+	    *dwBuffer = nRecv;
+	    TRACE(":%lu %s\n", nRecv, lpszBuffer);
+            return TRUE;
+	}
+	else
+	{
+	    return FALSE;
+	}
+    }
+    else
+    {
+#if defined HAVE_OPENSSL_SSL_H && defined HAVE_OPENSSL_ERR_H
+	long prev_timeout;
+	DWORD nRecv = 0;
+        BOOL success = TRUE;
+
+        prev_timeout = pSSL_CTX_get_timeout(ctx);
+	pSSL_CTX_set_timeout(ctx, RESPONSE_TIMEOUT);
+
+	while (nRecv < *dwBuffer)
+	{
+	    int recv = 1;
+	    if (!NETCON_recv(connection, &lpszBuffer[nRecv], 1, 0, &recv))
+	    {
+                INTERNET_SetLastError(ERROR_CONNECTION_ABORTED);
+		success = FALSE;
+	    }
+
+	    if (lpszBuffer[nRecv] == '\n')
+	    {
+		success = TRUE;
+                break;
+	    }
+	    if (lpszBuffer[nRecv] != '\r')
+		nRecv++;
+	}
+
+        pSSL_CTX_set_timeout(ctx, prev_timeout);
+	if (success)
+	{
+	    lpszBuffer[nRecv++] = '\0';
+	    *dwBuffer = nRecv;
+	    TRACE("_SSL:%lu %s\n", nRecv, lpszBuffer);
+            return TRUE;
+	}
+        return FALSE;
+#else
+	return FALSE;
+#endif
+    }
+}

reactos/lib/wininet/resource.h

@@ -0,0 +1,29 @@
+/*
+ * Wininet resource definitions
+ *
+ * Copyright 2003 Mike McCormack for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#define IDD_PROXYDLG     0x400
+
+#define IDC_PROXY        0x401
+#define IDC_REALM        0x402
+#define IDC_USERNAME     0x403
+#define IDC_PASSWORD     0x404
+#define IDC_SAVEPASSWORD 0x405
+
+#define IDS_LANCONNECTION 0x500

reactos/lib/wininet/rsrc.rc

@@ -0,0 +1,57 @@
+/*
+ * Top level resource file for Wininet
+ *
+ * Copyright 2003 Mike McCormack for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "windef.h"
+#include "winbase.h"
+#include "winuser.h"
+#include "winnls.h"
+
+#include "resource.h"
+
+/*
+ * Everything that does not depend on language,
+ * like textless bitmaps etc, go into the
+ * neutral language. This will prevent them from
+ * being duplicated for each language.
+ */
+/* #include "wininet_xx.rc" */
+
+/*
+ * Everything specific to any language goes
+ * in one of the specific files.
+ * Note that you can and may override resources
+ * which also have a neutral version. This is to
+ * get localized bitmaps for example.
+ */
+#include "wininet_Bg.rc"
+#include "wininet_Cs.rc"
+#include "wininet_De.rc"
+#include "wininet_En.rc"
+#include "wininet_Es.rc"
+#include "wininet_Fi.rc"
+#include "wininet_Fr.rc"
+#include "wininet_It.rc"
+#include "wininet_Ja.rc"
+#include "wininet_Ko.rc"
+#include "wininet_Nl.rc"
+#include "wininet_No.rc"
+#include "wininet_Pt.rc"
+#include "wininet_Ru.rc"
+#include "wininet_Si.rc"

reactos/lib/wininet/utility.c

@@ -0,0 +1,299 @@
+/*
+ * Wininet - Utility functions
+ *
+ * Copyright 1999 Corel Corporation
+ * Copyright 2002 CodeWeavers Inc.
+ *
+ * Ulrich Czekalla
+ * Aric Stewart
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "config.h"
+#include "wine/port.h"
+
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "wininet.h"
+#include "winerror.h"
+#include "winnls.h"
+
+#include "wine/debug.h"
+#include "internet.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(wininet);
+
+#define TIME_STRING_LEN  30
+
+time_t ConvertTimeString(LPCWSTR asctime)
+{
+    WCHAR tmpChar[TIME_STRING_LEN];
+    WCHAR *tmpChar2;
+    struct tm t;
+    int timelen = strlenW(asctime);
+
+    if(!asctime || !timelen)
+        return 0;
+
+    /* FIXME: the atoiWs below rely on that tmpChar is \0 padded */
+    memset( tmpChar, 0, sizeof(tmpChar) );
+    lstrcpynW(tmpChar, asctime, TIME_STRING_LEN);
+
+    /* Assert that the string is the expected length */
+    if (strlenW(asctime) >= TIME_STRING_LEN) FIXME("\n");
+
+    /* Convert a time such as 'Mon, 15 Nov 1999 16:09:35 GMT' into a SYSTEMTIME structure
+     * We assume the time is in this format
+     * and divide it into easy to swallow chunks
+     */
+    tmpChar[3]='\0';
+    tmpChar[7]='\0';
+    tmpChar[11]='\0';
+    tmpChar[16]='\0';
+    tmpChar[19]='\0';
+    tmpChar[22]='\0';
+    tmpChar[25]='\0';
+
+    t.tm_year = atoiW(tmpChar+12) - 1900;
+    t.tm_mday = atoiW(tmpChar+5);
+    t.tm_hour = atoiW(tmpChar+17);
+    t.tm_min = atoiW(tmpChar+20);
+    t.tm_sec = atoiW(tmpChar+23);
+
+    /* and month */
+    tmpChar2 = tmpChar + 8;
+    switch(tmpChar2[2])
+    {
+        case 'n':
+            if(tmpChar2[1]=='a')
+                t.tm_mon = 0;
+            else
+                t.tm_mon = 5;
+            break;
+        case 'b':
+            t.tm_mon = 1;
+            break;
+        case 'r':
+            if(tmpChar2[1]=='a')
+                t.tm_mon = 2;
+            else
+                t.tm_mon = 3;
+            break;
+        case 'y':
+            t.tm_mon = 4;
+            break;
+        case 'l':
+            t.tm_mon = 6;
+            break;
+        case 'g':
+            t.tm_mon = 7;
+            break;
+        case 'p':
+            t.tm_mon = 8;
+            break;
+        case 't':
+            t.tm_mon = 9;
+            break;
+        case 'v':
+            t.tm_mon = 10;
+            break;
+        case 'c':
+            t.tm_mon = 11;
+            break;
+        default:
+            FIXME("\n");
+    }
+
+    return mktime(&t);
+}
+
+
+BOOL GetAddress(LPCWSTR lpszServerName, INTERNET_PORT nServerPort,
+	struct sockaddr_in *psa)
+{
+    WCHAR *found;
+    char *name;
+    int len, sz;
+    struct hostent *phe;
+
+    TRACE("%s\n", debugstr_w(lpszServerName));
+
+    /* Validate server name first
+     * Check if there is sth. like
+     * pinger.macromedia.com:80
+     * if yes, eliminate the :80....
+     */
+    found = strchrW(lpszServerName, ':');
+    if (found)
+        len = found - lpszServerName;
+    else
+        len = strlenW(lpszServerName);
+
+    sz = WideCharToMultiByte( CP_THREAD_ACP, 0, lpszServerName, len, NULL, 0, NULL, NULL );
+    name = HeapAlloc(GetProcessHeap(), 0, sz+1);
+    WideCharToMultiByte( CP_THREAD_ACP, 0, lpszServerName, len, name, sz, NULL, NULL );
+    name[sz] = 0;
+    phe = gethostbyname(name);
+    HeapFree( GetProcessHeap(), 0, name );
+
+    if (NULL == phe)
+    {
+        TRACE("Failed to get hostname: (%s)\n", debugstr_w(lpszServerName) );
+        return FALSE;
+    }
+
+    memset(psa,0,sizeof(struct sockaddr_in));
+    memcpy((char *)&psa->sin_addr, phe->h_addr, phe->h_length);
+    psa->sin_family = phe->h_addrtype;
+    psa->sin_port = htons((u_short)nServerPort);
+
+    return TRUE;
+}
+
+/*
+ * 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)
+#undef FE
+    };
+    DWORD 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 INTERNET_SendCallback(LPWININETHANDLEHEADER hdr, DWORD dwContext,
+                           DWORD dwInternetStatus, LPVOID lpvStatusInfo,
+                           DWORD dwStatusInfoLength)
+{
+    HINTERNET hHttpSession;
+    LPVOID lpvNewInfo = NULL;
+
+    if( !hdr->lpfnStatusCB )
+        return;
+
+    /* the IE5 version of wininet does not
+       send callbacks if dwContext is zero */
+    if( !dwContext )
+        return;
+
+    hHttpSession = WININET_FindHandle( hdr );
+    if( !hHttpSession ) {
+	TRACE(" Could not convert header '%p' into a handle !\n", hdr);
+        return;
+    }
+
+    lpvNewInfo = lpvStatusInfo;
+    if(!(hdr->dwInternalFlags & INET_CALLBACKW)) {
+        switch(dwInternetStatus)
+        {
+        case INTERNET_STATUS_RESOLVING_NAME:
+        case INTERNET_STATUS_REDIRECT:
+            lpvNewInfo = WININET_strdup_WtoA(lpvStatusInfo);
+        }
+    }
+    
+    TRACE(" callback(%p) (%p (%p), %08lx, %ld (%s), %p, %ld)\n",
+	  hdr->lpfnStatusCB, hHttpSession, hdr, dwContext, dwInternetStatus, get_callback_name(dwInternetStatus),
+	  lpvNewInfo, dwStatusInfoLength);
+    
+    hdr->lpfnStatusCB(hHttpSession, dwContext, dwInternetStatus,
+                      lpvNewInfo, dwStatusInfoLength);
+
+    TRACE(" end callback().\n");
+
+    if(lpvNewInfo != lpvStatusInfo)
+        HeapFree(GetProcessHeap(), 0, lpvNewInfo);
+
+    WININET_Release( hdr );
+}
+
+
+
+VOID SendAsyncCallback(LPWININETHANDLEHEADER hdr, DWORD dwContext,
+                       DWORD dwInternetStatus, LPVOID lpvStatusInfo,
+                       DWORD dwStatusInfoLength)
+{
+    TRACE("(%p, %08lx, %ld (%s), %p, %ld): %sasync call with callback %p\n",
+	  hdr, dwContext, dwInternetStatus, get_callback_name(dwInternetStatus),
+	  lpvStatusInfo, dwStatusInfoLength,
+	  hdr->dwFlags & INTERNET_FLAG_ASYNC ? "" : "non ",
+	  hdr->lpfnStatusCB);
+    
+    if (!(hdr->lpfnStatusCB))
+	return;
+    
+    if (hdr->dwFlags & INTERNET_FLAG_ASYNC)
+    {
+	WORKREQUEST workRequest;
+	struct WORKREQ_SENDCALLBACK *req;
+	void *lpvStatusInfo_copy = lpvStatusInfo;
+
+	if (lpvStatusInfo)
+	{
+	    lpvStatusInfo_copy = HeapAlloc(GetProcessHeap(), 0, dwStatusInfoLength);
+	    memcpy(lpvStatusInfo_copy, lpvStatusInfo, dwStatusInfoLength);
+	}
+
+	workRequest.asyncall = SENDCALLBACK;
+	workRequest.hdr = WININET_AddRef( hdr );
+	req = &workRequest.u.SendCallback;
+	req->dwContext = dwContext;
+	req->dwInternetStatus = dwInternetStatus;
+	req->lpvStatusInfo = lpvStatusInfo_copy;
+	req->dwStatusInfoLength = dwStatusInfoLength;
+	
+	INTERNET_AsyncCall(&workRequest);
+    }
+    else
+	INTERNET_SendCallback(hdr, dwContext, dwInternetStatus,
+			      lpvStatusInfo, dwStatusInfoLength);
+}

reactos/lib/wininet/version.rc

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2002 CodeWeavers
+ *
+ * Aric Stewart
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#define WINE_FILEDESCRIPTION_STR "Wine Internet Connectivity"
+#define WINE_FILENAME_STR "wininet.dll"
+#define WINE_FILEVERSION 6,0,2800,1106
+#define WINE_FILEVERSION_STR "6.0.2800.1106"
+#define WINE_PRODUCTVERSION 6,0,2800,1106
+#define WINE_PRODUCTVERSION_STR "6.0.2800.1106"
+
+#include "wine/wine_common_ver.rc"

reactos/lib/wininet/wininet.spec

@@ -0,0 +1,245 @@
+101 stub -noname DoConnectoidsExist
+102 stub -noname GetDiskInfoA
+103 stub -noname PerformOperationOverUrlCacheA
+104 stub -noname HttpCheckDavComplianceA
+105 stub -noname HttpCheckDavComplianceW
+108 stub -noname ImportCookieFileA
+109 stub -noname ExportCookieFileA
+110 stub -noname ImportCookieFileW
+111 stub -noname ExportCookieFileW
+112 stub -noname IsProfilesEnabled
+116 stub -noname IsDomainlegalCookieDomainA
+117 stub -noname IsDomainLegalCookieDomainW
+118 stub -noname FindP3PPolicySymbol
+120 stub -noname MapResourceToPolicy
+121 stub -noname GetP3PPolicy
+122 stub -noname FreeP3PObject
+123 stub -noname GetP3PRequestStatus
+
+@ stdcall CommitUrlCacheEntryA(str str double double long str long str str)
+@ stdcall CommitUrlCacheEntryW(wstr wstr double double long wstr long wstr wstr)
+@ stdcall CreateMD5SSOHash(wstr wstr wstr ptr)
+@ stdcall CreateUrlCacheContainerA(long long long long long long long long)
+@ stdcall CreateUrlCacheContainerW(long long long long long long long long)
+@ stdcall CreateUrlCacheEntryA(str long str ptr long)
+@ stdcall CreateUrlCacheEntryW(wstr long wstr ptr long)
+@ stdcall CreateUrlCacheGroup(long ptr)
+@ stdcall DeleteIE3Cache(ptr ptr str long)
+@ stdcall DeleteUrlCacheContainerA(long long)
+@ stdcall DeleteUrlCacheContainerW(long long)
+@ stdcall DeleteUrlCacheEntry(str) DeleteUrlCacheEntryA
+@ stdcall DeleteUrlCacheEntryA(str)
+@ stdcall DeleteUrlCacheEntryW(wstr)
+@ stdcall DeleteUrlCacheGroup(double long ptr)
+@ stdcall DetectAutoProxyUrl(str long long)
+@ stdcall -private DllInstall(long wstr)
+@ stdcall FindCloseUrlCache(long)
+@ stdcall FindFirstUrlCacheContainerA(ptr ptr ptr long)
+@ stdcall FindFirstUrlCacheContainerW(ptr ptr ptr long)
+@ stdcall FindFirstUrlCacheEntryA(str ptr ptr)
+@ stdcall FindFirstUrlCacheEntryExA(str long long double ptr ptr ptr ptr ptr)
+@ stdcall FindFirstUrlCacheEntryExW(wstr long long double ptr ptr ptr ptr ptr)
+@ stdcall FindFirstUrlCacheEntryW(wstr ptr ptr)
+@ stdcall FindFirstUrlCacheGroup(long long ptr long ptr ptr)
+@ stdcall FindNextUrlCacheContainerA(long ptr ptr)
+@ stdcall FindNextUrlCacheContainerW(long ptr ptr)
+@ stdcall FindNextUrlCacheEntryA(long ptr ptr)
+@ stdcall FindNextUrlCacheEntryExA(long ptr ptr ptr ptr ptr)
+@ stdcall FindNextUrlCacheEntryExW(long ptr ptr ptr ptr ptr)
+@ stdcall FindNextUrlCacheEntryW(long ptr ptr)
+@ stdcall FindNextUrlCacheGroup(long ptr ptr)
+@ stub ForceNexusLookup
+@ stub ForceNexusLookupExW
+@ stub FreeUrlCacheSpaceA
+@ stub FreeUrlCacheSpaceW
+@ stdcall FtpCommandA(long long long str ptr ptr)
+@ stdcall FtpCommandW(long long long wstr ptr ptr)
+@ stdcall FtpCreateDirectoryA(ptr str)
+@ stdcall FtpCreateDirectoryW(ptr wstr)
+@ stdcall FtpDeleteFileA(ptr str)
+@ stdcall FtpDeleteFileW(ptr wstr)
+@ stdcall FtpFindFirstFileA(ptr str ptr long long)
+@ stdcall FtpFindFirstFileW(ptr wstr ptr long long)
+@ stdcall FtpGetCurrentDirectoryA(ptr str ptr)
+@ stdcall FtpGetCurrentDirectoryW(ptr wstr ptr)
+@ stdcall FtpGetFileA(ptr str str long long long long)
+@ stub FtpGetFileEx
+@ stdcall FtpGetFileSize(long ptr)
+@ stdcall FtpGetFileW(ptr wstr wstr long long long long)
+@ stdcall FtpOpenFileA(ptr str long long long)
+@ stdcall FtpOpenFileW(ptr wstr long long long)
+@ stdcall FtpPutFileA(ptr str str long long)
+@ stub FtpPutFileEx
+@ stdcall FtpPutFileW(ptr wstr wstr long long)
+@ stdcall FtpRemoveDirectoryA(ptr str)
+@ stdcall FtpRemoveDirectoryW(ptr wstr)
+@ stdcall FtpRenameFileA(ptr str str)
+@ stdcall FtpRenameFileW(ptr wstr wstr)
+@ stdcall FtpSetCurrentDirectoryA(ptr str)
+@ stdcall FtpSetCurrentDirectoryW(ptr wstr)
+@ stdcall GetUrlCacheConfigInfoA(ptr ptr long)
+@ stdcall GetUrlCacheConfigInfoW(ptr ptr long)
+@ stdcall GetUrlCacheEntryInfoA(str ptr long)
+@ stdcall GetUrlCacheEntryInfoExA(str ptr ptr str ptr ptr long)
+@ stdcall GetUrlCacheEntryInfoExW(wstr ptr ptr wstr ptr ptr long)
+@ stdcall GetUrlCacheEntryInfoW(wstr ptr long)
+@ stdcall GetUrlCacheGroupAttributeA(double long long ptr ptr ptr)
+@ stdcall GetUrlCacheGroupAttributeW(double long long ptr ptr ptr)
+@ stub GetUrlCacheHeaderData
+@ stdcall GopherCreateLocatorA(str long str str long str ptr)
+@ stdcall GopherCreateLocatorW(wstr long wstr wstr long wstr ptr)
+@ stdcall GopherFindFirstFileA(ptr str str ptr long long)
+@ stdcall GopherFindFirstFileW(ptr wstr wstr ptr long long)
+@ stdcall GopherGetAttributeA(ptr str str ptr long ptr ptr long)
+@ stdcall GopherGetAttributeW(ptr wstr wstr ptr long ptr ptr long)
+@ stdcall GopherGetLocatorTypeA(str ptr)
+@ stdcall GopherGetLocatorTypeW(wstr ptr)
+@ stdcall GopherOpenFileA(ptr str str long long)
+@ stdcall GopherOpenFileW(ptr wstr wstr long long)
+@ stdcall HttpAddRequestHeadersA(ptr str long long)
+@ stdcall HttpAddRequestHeadersW(ptr wstr long long)
+@ stub HttpCheckDavCompliance
+@ stdcall HttpEndRequestA(ptr ptr long long)
+@ stdcall HttpEndRequestW(ptr ptr long long)
+@ stdcall HttpOpenRequestA(ptr str str str str ptr long long)
+@ stdcall HttpOpenRequestW(ptr wstr wstr wstr wstr ptr long long)
+@ stdcall HttpQueryInfoA(ptr long ptr ptr ptr)
+@ stdcall HttpQueryInfoW(ptr long ptr ptr ptr)
+@ stdcall HttpSendRequestA(ptr str long ptr long)
+@ stdcall HttpSendRequestExA(long ptr ptr long long)
+@ stdcall HttpSendRequestExW(long ptr ptr long long)
+@ stdcall HttpSendRequestW(ptr wstr long ptr long)
+@ stub IncrementUrlCacheHeaderData
+@ stub InternetAlgIdToStringA
+@ stub InternetAlgIdToStringW
+@ stdcall InternetAttemptConnect(long)
+@ stdcall InternetAutodial(long ptr)
+@ stub InternetAutodialCallback
+@ stdcall InternetAutodialHangup(long)
+@ stdcall InternetCanonicalizeUrlA(str str ptr long)
+@ stdcall InternetCanonicalizeUrlW(wstr wstr ptr long)
+@ stdcall InternetCheckConnectionA(ptr long long)
+@ stdcall InternetCheckConnectionW(ptr long long)
+@ stdcall InternetClearAllPerSiteCookieDecisions()
+@ stdcall InternetCloseHandle(long)
+@ stdcall InternetCombineUrlA(str str str ptr long)
+@ stdcall InternetCombineUrlW(wstr wstr wstr ptr long)
+@ stdcall InternetConfirmZoneCrossing(long str str long) InternetConfirmZoneCrossingA
+@ stdcall InternetConfirmZoneCrossingA(long str str long)
+@ stdcall InternetConfirmZoneCrossingW(long wstr wstr long)
+@ stdcall InternetConnectA(ptr str long str str long long long)
+@ stdcall InternetConnectW(ptr wstr long wstr wstr long long long)
+@ stdcall InternetCrackUrlA(str long long ptr)
+@ stdcall InternetCrackUrlW(wstr long long ptr)
+@ stdcall InternetCreateUrlA(ptr long ptr ptr)
+@ stdcall InternetCreateUrlW(ptr long ptr ptr)
+@ stub InternetDebugGetLocalTime
+@ stdcall InternetDial(long str long ptr long) InternetDialA
+@ stdcall InternetDialA(long str long ptr long)
+@ stdcall InternetDialW(long wstr long ptr long)
+@ stdcall InternetEnumPerSiteCookieDecisionA(ptr ptr ptr long)
+@ stdcall InternetEnumPerSiteCookieDecisionW(ptr ptr ptr long)
+@ stdcall InternetErrorDlg(long long long long ptr)
+@ stdcall InternetFindNextFileA(ptr ptr)
+@ stdcall InternetFindNextFileW(ptr ptr)
+@ stub InternetFortezzaCommand
+@ stub InternetGetCertByURL
+@ stub InternetGetCertByURLA
+@ stdcall InternetGetConnectedState(ptr long)
+@ stdcall InternetGetConnectedStateEx(ptr ptr long long) InternetGetConnectedStateExA
+@ stdcall InternetGetConnectedStateExA(ptr ptr long long)
+@ stdcall InternetGetConnectedStateExW(ptr ptr long long)
+@ stdcall InternetGetCookieA(str str ptr long)
+@ stdcall InternetGetCookieExA(str str ptr ptr long ptr)
+@ stdcall InternetGetCookieExW(wstr wstr ptr ptr long ptr)
+@ stdcall InternetGetCookieW(wstr wstr ptr long)
+@ stdcall InternetGetLastResponseInfoA(ptr ptr ptr)
+@ stdcall InternetGetLastResponseInfoW(ptr ptr ptr)
+@ stdcall InternetGetPerSiteCookieDecisionA(str ptr)
+@ stdcall InternetGetPerSiteCookieDecisionW(wstr ptr)
+@ stdcall InternetGoOnline(str long long) InternetGoOnlineA
+@ stdcall InternetGoOnlineA(str long long)
+@ stdcall InternetGoOnlineW(wstr long long)
+@ stdcall InternetHangUp(long long)
+@ stdcall InternetInitializeAutoProxyDll(long)
+@ stdcall InternetLockRequestFile(ptr ptr)
+@ stdcall InternetOpenA(str long str str long)
+@ stub InternetOpenServerPushParse
+@ stdcall InternetOpenUrlA(ptr str str long long long)
+@ stdcall InternetOpenUrlW(ptr wstr wstr long long long)
+@ stdcall InternetOpenW(wstr long wstr wstr long)
+@ stdcall InternetQueryDataAvailable(ptr ptr long long)
+@ stub InternetQueryFortezzaStatus
+@ stdcall InternetQueryOptionA(ptr long ptr ptr)
+@ stdcall InternetQueryOptionW(ptr long ptr ptr)
+@ stdcall InternetReadFile(ptr ptr long ptr)
+@ stdcall InternetReadFileExA(ptr ptr long long)
+@ stdcall InternetReadFileExW(ptr ptr long long)
+@ stub InternetSecurityProtocolToStringA
+@ stub InternetSecurityProtocolToStringW
+@ stub InternetServerPushParse
+@ stdcall InternetSetCookieA(str str str)
+@ stdcall InternetSetCookieExA(str str str long ptr)
+@ stdcall InternetSetCookieExW(wstr wstr wstr long ptr)
+@ stdcall InternetSetCookieW(wstr wstr wstr)
+@ stub InternetSetDialState
+@ stub InternetSetDialStateA
+@ stub InternetSetDialStateW
+@ stdcall InternetSetFilePointer(ptr long ptr long long)
+@ stdcall InternetSetOptionA(ptr long ptr long)
+@ stdcall InternetSetOptionExA(ptr long ptr long long)
+@ stdcall InternetSetOptionExW(ptr long ptr long long)
+@ stdcall InternetSetOptionW(ptr long ptr long)
+@ stdcall InternetSetPerSiteCookieDecisionA(str long)
+@ stdcall InternetSetPerSiteCookieDecisionW(wstr long)
+@ stdcall InternetSetStatusCallback(ptr ptr) InternetSetStatusCallbackA
+@ stdcall InternetSetStatusCallbackA(ptr ptr)
+@ stdcall InternetSetStatusCallbackW(ptr ptr)
+@ stub InternetShowSecurityInfoByURL
+@ stub InternetShowSecurityInfoByURLA
+@ stub InternetShowSecurityInfoByURLW
+@ stdcall InternetTimeFromSystemTime(ptr long ptr long) InternetTimeFromSystemTimeA
+@ stdcall InternetTimeFromSystemTimeA(ptr long ptr long)
+@ stdcall InternetTimeFromSystemTimeW(ptr long ptr long)
+@ stdcall InternetTimeToSystemTime(str ptr long) InternetTimeToSystemTimeA
+@ stdcall InternetTimeToSystemTimeA(str ptr long)
+@ stdcall InternetTimeToSystemTimeW(wstr ptr long)
+@ stdcall InternetUnlockRequestFile(ptr)
+@ stdcall InternetWriteFile(ptr ptr long ptr)
+@ stub InternetWriteFileExA
+@ stub InternetWriteFileExW
+@ stdcall IsHostInProxyBypassList(long str long)
+@ stub IsUrlCacheEntryExpiredA
+@ stub IsUrlCacheEntryExpiredW
+@ stub LoadUrlCacheContent
+@ stub ParseX509EncodedCertificateForListBoxEntry
+@ stub PrivacyGetZonePreferenceW # (long long ptr ptr ptr)
+@ stub PrivacySetZonePreferenceW # (long long long wstr)
+@ stdcall ReadUrlCacheEntryStream(ptr long ptr ptr long)
+@ stub RegisterUrlCacheNotification
+@ stdcall ResumeSuspendedDownload(long long)
+@ stdcall RetrieveUrlCacheEntryFileA(str ptr ptr long)
+@ stdcall RetrieveUrlCacheEntryFileW(wstr ptr ptr long)
+@ stdcall RetrieveUrlCacheEntryStreamA(str ptr ptr long long)
+@ stdcall RetrieveUrlCacheEntryStreamW(wstr ptr ptr long long)
+@ stub RunOnceUrlCache
+@ stdcall SetUrlCacheConfigInfoA(ptr long)
+@ stdcall SetUrlCacheConfigInfoW(ptr long)
+@ stdcall SetUrlCacheEntryGroup(str long double ptr long ptr) SetUrlCacheEntryGroupA
+@ stdcall SetUrlCacheEntryGroupA(str long double ptr long ptr)
+@ stdcall SetUrlCacheEntryGroupW(wstr long double ptr long ptr)
+@ stdcall SetUrlCacheEntryInfoA(str ptr long)
+@ stdcall SetUrlCacheEntryInfoW(wstr ptr long)
+@ stdcall SetUrlCacheGroupAttributeA(double long long ptr ptr)
+@ stdcall SetUrlCacheGroupAttributeW(double long long ptr ptr)
+@ stub SetUrlCacheHeaderData
+@ stub ShowCertificate
+@ stub ShowClientAuthCerts
+@ stub ShowSecurityInfo
+@ stub ShowX509EncodedCertificate
+@ stdcall UnlockUrlCacheEntryFile(str long) UnlockUrlCacheEntryFileA
+@ stdcall UnlockUrlCacheEntryFileA(str long)
+@ stdcall UnlockUrlCacheEntryFileW(wstr long)
+@ stdcall UnlockUrlCacheEntryStream(ptr long)
+@ stub UpdateUrlCacheContentPath
+@ stub UrlZonesDetach

reactos/lib/wininet/wininet.xml

@@ -0,0 +1,33 @@
+<module name="wininet" type="win32dll" baseaddress="${BASEADDRESS_WININET}" installbase="system32" installname="wininet.dll" allowwarnings="true">
+	<autoregister infsection="OleControlDlls" type="DllInstall" />
+	<importlibrary definition="wininet.spec.def" />
+	<include base="wininet">.</include>
+	<include base="ReactOS">include/wine</include>
+	<define name="__REACTOS__" />
+	<define name="__USE_W32API" />
+	<define name="_WIN32_IE">0x600</define>
+	<define name="_WIN32_WINNT">0x501</define>
+	<define name="WINVER">0x501</define>
+	<library>wine</library>
+	<library>ntdll</library>
+	<library>kernel32</library>
+	<library>user32</library>
+	<library>advapi32</library>
+	<library>shell32</library>
+	<library>shlwapi</library>
+	<library>mpr</library>
+	<library>ws2_32</library>
+	<file>cookie.c</file>
+	<file>dialogs.c</file>
+	<file>ftp.c</file>
+	<file>gopher.c</file>
+	<file>http.c</file>
+	<file>internet.c</file>
+	<file>netconnection.c</file>
+	<file>urlcache.c</file>
+	<file>utility.c</file>
+	<file>wininet_main.c</file>
+	<file>rsrc.rc</file>
+	<file>version.rc</file>
+	<file>wininet.spec</file>
+</module>

reactos/lib/wininet/wininet_Bg.rc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2005 Milko Krachounov
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+LANGUAGE LANG_BULGARIAN, SUBLANG_DEFAULT
+
+IDD_PROXYDLG DIALOG LOADONCALL MOVEABLE DISCARDABLE 36, 24, 250, 154
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Âúâåäåòå ìðåæîâà ïàðîëà"
+FONT 8, "MS Shell Dlg"
+{       
+ LTEXT "Âúâåäåòå âàøåòî ïîòðåáèòåëñêî èìå è ïàðîëà:", -1, 40, 6, 150, 15
+ LTEXT "Ïðîêñè", -1, 40, 26, 50, 10
+ LTEXT "Îáëàñò", -1, 40, 46, 50, 10
+ LTEXT "Ïîòðåáèòåë", -1, 40, 66, 50, 10
+ LTEXT "Ïàðîëà", -1, 40, 86, 50, 10
+ LTEXT "" IDC_PROXY, 80, 26, 150, 14, 0
+ LTEXT "" IDC_REALM, 80, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ CHECKBOX "&Çàïîìíè ïàðîëàòà (íåáåçîïàñíî)", IDC_SAVEPASSWORD,
+           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "OK", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
+ PUSHBUTTON "Îòìåíè", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+}
+
+STRINGTABLE DISCARDABLE
+{
+  IDS_LANCONNECTION "LAN âðúçêà"
+}

reactos/lib/wininet/wininet_Cs.rc

@@ -0,0 +1,41 @@
+/*
+ * Czech resources for wininet
+ * Copyright 2003 Mike McCormack for CodeWeavers
+ * Copyright 2004 David Kredba
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+LANGUAGE LANG_CZECH, SUBLANG_DEFAULT
+
+IDD_PROXYDLG DIALOG LOADONCALL MOVEABLE DISCARDABLE 36, 24, 250, 154
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Zadání sí»ového hesla"
+FONT 8, "MS Shell Dlg"
+{
+ LTEXT "Prosím zadejte své u¾iv. jméno a heslo:", -1, 40, 6, 150, 15
+ LTEXT "Proxy", -1, 40, 26, 50, 10
+ LTEXT "Plné jméno", -1, 40, 46, 50, 10
+ LTEXT "U¾ivatel", -1, 40, 66, 50, 10
+ LTEXT "Heslo", -1, 40, 86, 50, 10
+ LTEXT "" IDC_PROXY, 80, 26, 150, 14, 0
+ LTEXT "" IDC_REALM, 80, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ CHECKBOX "&Ulo¾it toto heslo (nebezpeèné) ?", IDC_SAVEPASSWORD,
+           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "OK", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
+ PUSHBUTTON "Storno", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+}

reactos/lib/wininet/wininet_De.rc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2004 Henning Gerhardt
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+LANGUAGE LANG_GERMAN, SUBLANG_DEFAULT
+
+IDD_PROXYDLG DIALOG LOADONCALL MOVEABLE DISCARDABLE 36, 24, 250, 154
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Netzwerkkennung eingeben"
+FONT 8, "MS Shell Dlg"
+{
+ LTEXT "Geben Sie Benutzernamen und Kennwort ein:", -1, 40, 6, 150, 15
+ LTEXT "Proxy", -1, 40, 26, 50, 10
+ LTEXT "Realm", -1, 40, 46, 50, 10
+ LTEXT "Ben&utzername", -1, 40, 66, 50, 10
+ LTEXT "Kenn&wort", -1, 40, 86, 50, 10
+ LTEXT "" IDC_PROXY, 80, 26, 150, 14, 0
+ LTEXT "" IDC_REALM, 80, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ CHECKBOX "Dieses &Kennwort speichern (unsicher)", IDC_SAVEPASSWORD,
+           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "OK", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
+ PUSHBUTTON "Abbrechen", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+}
+
+STRINGTABLE DISCARDABLE
+{
+  IDS_LANCONNECTION "LAN Verbindung"
+}

reactos/lib/wininet/wininet_En.rc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2003 Mike McCormack for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+LANGUAGE LANG_ENGLISH, SUBLANG_DEFAULT
+
+IDD_PROXYDLG DIALOG LOADONCALL MOVEABLE DISCARDABLE 36, 24, 250, 154
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Enter Network Password"
+FONT 8, "MS Shell Dlg"
+{
+ LTEXT "Please enter your username and password:", -1, 40, 6, 150, 15
+ LTEXT "Proxy", -1, 40, 26, 50, 10
+ LTEXT "Realm", -1, 40, 46, 50, 10
+ LTEXT "User", -1, 40, 66, 50, 10
+ LTEXT "Password", -1, 40, 86, 50, 10
+ LTEXT "" IDC_PROXY, 80, 26, 150, 14, 0
+ LTEXT "" IDC_REALM, 80, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ CHECKBOX "&Save this password (insecure)", IDC_SAVEPASSWORD,
+           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "OK", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
+ PUSHBUTTON "Cancel", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+}
+
+STRINGTABLE DISCARDABLE
+{
+  IDS_LANCONNECTION "LAN Connection"
+}

reactos/lib/wininet/wininet_Es.rc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2003, 2005 José Manuel Ferrer Ortiz
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+LANGUAGE LANG_SPANISH, SUBLANG_NEUTRAL
+
+IDD_PROXYDLG DIALOG LOADONCALL MOVEABLE DISCARDABLE 36, 24, 250, 154
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Introduzca contraseña de red"
+FONT 8, "MS Shell Dlg"
+{
+ LTEXT "Por favor introduzca su nombre de usuario y contraseña:", -1, 40, 6, 150, 15
+ LTEXT "Proxy", -1, 40, 26, 50, 10
+ LTEXT "Dominio", -1, 40, 46, 50, 10
+ LTEXT "Usuario", -1, 40, 66, 50, 10
+ LTEXT "Contraseña", -1, 40, 86, 50, 10
+ LTEXT "" IDC_PROXY, 80, 26, 150, 14, 0
+ LTEXT "" IDC_REALM, 80, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ CHECKBOX "&Guardar esta contraseña (inseguro)", IDC_SAVEPASSWORD,
+           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "Aceptar", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
+ PUSHBUTTON "Cancelar", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+}
+
+STRINGTABLE DISCARDABLE
+{
+  IDS_LANCONNECTION "Conexión LAN"
+}

reactos/lib/wininet/wininet_Fi.rc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2005 Kimmo Myllyvirta
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+LANGUAGE LANG_FINNISH, SUBLANG_DEFAULT
+
+IDD_PROXYDLG DIALOG LOADONCALL MOVEABLE DISCARDABLE 36, 24, 250, 154
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Anna Verkon Salasana"
+FONT 8, "MS Shell Dlg"
+{
+ LTEXT "Anna käyttäjän nimi ja salasana:", -1, 40, 6, 150, 15
+ LTEXT "Välityspalvelin", -1, 40, 26, 50, 10
+ LTEXT "Alue", -1, 40, 46, 50, 10
+ LTEXT "Käyttäjä", -1, 40, 66, 50, 10
+ LTEXT "Salasana", -1, 40, 86, 50, 10
+ LTEXT "" IDC_PROXY, 80, 26, 150, 14, 0
+ LTEXT "" IDC_REALM, 80, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ CHECKBOX "&Tallenna tämä salasana (epäturvallinen)", IDC_SAVEPASSWORD,
+           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "OK", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
+ PUSHBUTTON "Peruuta", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+}
+
+STRINGTABLE DISCARDABLE
+{
+  IDS_LANCONNECTION "Lähiverkkoyhteys"
+}

reactos/lib/wininet/wininet_Fr.rc

@@ -0,0 +1,49 @@
+/*
+ * Wininet
+ * French language support
+ *
+ * Copyright 2003 Mike McCormack for CodeWeavers
+ * Copyright 2003 Vincent Béron
+ * Copyright 2005 Jonathan Ernst
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+LANGUAGE LANG_FRENCH, SUBLANG_NEUTRAL
+
+IDD_PROXYDLG DIALOG LOADONCALL MOVEABLE DISCARDABLE 36, 24, 250, 154
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Entrez le mot de passe réseau"
+FONT 8, "MS Shell Dlg"
+{
+ LTEXT "Entrez votre nom d'utilisateur et votre mot de passe :", -1, 40, 6, 150, 15
+ LTEXT "Mandataire", -1, 40, 26, 50, 10
+ LTEXT "Domaine", -1, 40, 46, 50, 10
+ LTEXT "Utilisateur", -1, 40, 66, 50, 10
+ LTEXT "Mot de passe", -1, 40, 86, 50, 10
+ LTEXT "" IDC_PROXY, 80, 26, 150, 14, 0
+ LTEXT "" IDC_REALM, 80, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ CHECKBOX "&Enregistrer ce mot de passe (risqué)", IDC_SAVEPASSWORD,
+           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "OK", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
+ PUSHBUTTON "Annuler", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+}
+
+STRINGTABLE DISCARDABLE
+{
+  IDS_LANCONNECTION "Connexion LAN"
+}

reactos/lib/wininet/wininet_It.rc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2003 Mike McCormack for CodeWeavers
+ * Copyright 2003 Ivan Leo Puoti
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+LANGUAGE LANG_ITALIAN, SUBLANG_DEFAULT
+
+IDD_PROXYDLG DIALOG LOADONCALL MOVEABLE DISCARDABLE 36, 24, 250, 154
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Inserire la password di rete"
+FONT 8, "MS Shell Dlg"
+{
+ LTEXT "Inserire il nome utente e la password:", -1, 40, 6, 150, 15
+ LTEXT "Proxy", -1, 40, 26, 50, 10
+ LTEXT "Realm", -1, 40, 46, 50, 10
+ LTEXT "Utente", -1, 40, 66, 50, 10
+ LTEXT "Password", -1, 40, 86, 50, 10
+ LTEXT "" IDC_PROXY, 80, 26, 150, 14, 0
+ LTEXT "" IDC_REALM, 80, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ CHECKBOX "&Salva questa password (insicuro)", IDC_SAVEPASSWORD,
+           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "OK", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
+ PUSHBUTTON "Annulla", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+}

reactos/lib/wininet/wininet_Ja.rc

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2003 Mike McCormack for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+LANGUAGE LANG_JAPANESE, SUBLANG_DEFAULT
+
+IDD_PROXYDLG DIALOG LOADONCALL MOVEABLE DISCARDABLE 36, 24, 250, 154
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "ネットワークパスワードの入力"
+FONT 9, "MS UI Gothic"
+{
+ LTEXT "ユーザ名とパスワードを入力して下さい:", -1, 40, 6, 150, 15
+ LTEXT "プロキシ", -1, 40, 26, 50, 10
+ LTEXT "地域", -1, 40, 46, 50, 10
+ LTEXT "ユーザ名", -1, 40, 66, 50, 10
+ LTEXT "パスワード", -1, 40, 86, 50, 10
+ LTEXT "" IDC_PROXY, 80, 26, 150, 14, 0
+ LTEXT "" IDC_REALM, 80, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ CHECKBOX "パスワードを保存する(&S)(セキュアではありません)", IDC_SAVEPASSWORD,
+           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "OK", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
+ PUSHBUTTON "キャンセル", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+}

reactos/lib/wininet/wininet_Ko.rc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2005 YunSong Hwang
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+LANGUAGE LANG_KOREAN, SUBLANG_DEFAULT
+
+IDD_PROXYDLG DIALOG LOADONCALL MOVEABLE DISCARDABLE 36, 24, 250, 154
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "네트워크 암호 입력"
+FONT 8, "MS Shell Dlg"
+{
+ LTEXT "당신이 사용자이름과 암호를 입력하시오:", -1, 40, 6, 150, 15
+ LTEXT "프록시", -1, 40, 26, 50, 10
+ LTEXT "Realm", -1, 40, 46, 50, 10
+ LTEXT " 사용자", -1, 40, 66, 50, 10
+ LTEXT "암호", -1, 40, 86, 50, 10
+ LTEXT "" IDC_PROXY, 80, 26, 150, 14, 0
+ LTEXT "" IDC_REALM, 80, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ CHECKBOX "암호 입력(&S)(주의하시오)", IDC_SAVEPASSWORD,
+           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "확인", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
+ PUSHBUTTON "취소", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+}
+
+STRINGTABLE DISCARDABLE
+{
+  IDS_LANCONNECTION "랜 연결"
+}

reactos/lib/wininet/wininet_Nl.rc

@@ -0,0 +1,41 @@
+/*
+ * wininet (Dutch resources)
+ *
+ * Copyright 2003 Hans Leidekker
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+LANGUAGE LANG_DUTCH, SUBLANG_DEFAULT
+
+IDD_PROXYDLG DIALOG LOADONCALL MOVEABLE DISCARDABLE 36, 24, 250, 154
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Netwerkwachtwoord invoeren"
+FONT 8, "MS Shell Dlg"
+{
+ LTEXT "Voer uw gebruikersnaam en wachtwoord in:", -1, 40, 6, 150, 15
+ LTEXT "Proxy", -1, 40, 26, 50, 10
+ LTEXT "Realm", -1, 40, 46, 50, 10
+ LTEXT "Gebruikersnaam", -1, 40, 66, 50, 10
+ LTEXT "Wachtwoord", -1, 40, 86, 50, 10
+ LTEXT "" IDC_PROXY, 80, 26, 150, 14, 0
+ LTEXT "" IDC_REALM, 80, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ CHECKBOX "&Wachtwoord opslaan (onveilig)", IDC_SAVEPASSWORD,
+           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "OK", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
+ PUSHBUTTON "Annuleren", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+}

reactos/lib/wininet/wininet_No.rc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2005 Alexander N. Sørnes <alex@thehandofagony.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+LANGUAGE LANG_NORWEGIAN, SUBLANG_NORWEGIAN_BOKMAL
+
+IDD_PROXYDLG DIALOG LOADONCALL MOVEABLE DISCARDABLE 36, 24, 250, 154
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Skriv inn nettverkspassord"
+FONT 8, "MS Shell Dlg"
+{
+ LTEXT "Skriv inn brukernavnet og passordet ditt:", -1, 40, 6, 150, 15
+ LTEXT "Mellomtjener", -1, 40, 26, 50, 10
+ LTEXT "Område", -1, 40, 46, 50, 10
+ LTEXT "Bruker", -1, 40, 66, 50, 10
+ LTEXT "Passord", -1, 40, 86, 50, 10
+ LTEXT "" IDC_PROXY, 80, 26, 150, 14, 0
+ LTEXT "" IDC_REALM, 80, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ CHECKBOX "Lagre dette pa&ssordet (usikkert)", IDC_SAVEPASSWORD,
+           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "OK", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
+ PUSHBUTTON "Avbryt", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+}
+
+STRINGTABLE DISCARDABLE
+{
+  IDS_LANCONNECTION "Lokal nettverksforbindelse"
+}

reactos/lib/wininet/wininet_Pt.rc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2003 Marcelo Duarte
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+LANGUAGE LANG_PORTUGUESE, SUBLANG_DEFAULT
+
+IDD_PROXYDLG DIALOG LOADONCALL MOVEABLE DISCARDABLE 36, 24, 250, 154
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Entrar Senha da Rede"
+FONT 8, "MS Shell Dlg"
+{
+ LTEXT "Por favor, entre com o nome de usuário e a senha:", -1, 40, 6, 150, 15
+ LTEXT "Proxy", -1, 40, 26, 50, 10
+ LTEXT "Realm", -1, 40, 46, 50, 10
+ LTEXT "Usuário", -1, 40, 66, 50, 10
+ LTEXT "Senha", -1, 40, 86, 50, 10
+ LTEXT "" IDC_PROXY, 80, 26, 150, 14, 0
+ LTEXT "" IDC_REALM, 80, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ CHECKBOX "&Salvar esta senha (inseguro)", IDC_SAVEPASSWORD,
+           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "OK", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
+ PUSHBUTTON "Cancelar", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+}
+
+STRINGTABLE DISCARDABLE
+{
+  IDS_LANCONNECTION "Conexão LAN"
+}

reactos/lib/wininet/wininet_Ru.rc

@@ -0,0 +1,41 @@
+/*
+ * wininet.dll (Russian resources)
+ *
+ * Copyright 2003 Igor Stepin
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+LANGUAGE LANG_RUSSIAN, SUBLANG_DEFAULT
+
+IDD_PROXYDLG DIALOG LOADONCALL MOVEABLE DISCARDABLE 36, 24, 250, 154
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Ââîä ñåòåâîãî ïàðîëÿ"
+FONT 8, "MS Shell Dlg"
+{
+ LTEXT "Ââåäèòå èìÿ ïîëüçîâàòåëÿ è ïàðîëü:", -1, 40, 6, 150, 15
+ LTEXT "Ïðîêñè", -1, 40, 26, 50, 10
+ LTEXT "Realm", -1, 40, 46, 50, 10
+ LTEXT "Ïîëüçîâàòåëü", -1, 40, 66, 50, 10
+ LTEXT "Ïàðîëü", -1, 40, 86, 50, 10
+ LTEXT "" IDC_PROXY, 80, 26, 150, 14, 0
+ LTEXT "" IDC_REALM, 80, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ CHECKBOX "&Ñîõðàíèòü ýòîò ïàðîëü (íåáåçîïàñíî)", IDC_SAVEPASSWORD,
+           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "OK", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
+ PUSHBUTTON "Îòìåíà", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+}

reactos/lib/wininet/wininet_Si.rc

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2003 Rok Mandeljc <rok.mandeljc@gimb.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+LANGUAGE LANG_SLOVENIAN, SUBLANG_DEFAULT
+
+IDD_PROXYDLG DIALOG LOADONCALL MOVEABLE DISCARDABLE 36, 24, 250, 154
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Vnos omrežnega gesla"
+FONT 8, "MS Shell Dlg"
+{
+ LTEXT "Vnesite uporabniško ime in geslo:", -1, 40, 6, 150, 15
+ LTEXT "Proxy", -1, 40, 26, 50, 10
+ LTEXT "Realm", -1, 40, 46, 50, 10
+ LTEXT "Uporabniško ime", -1, 40, 66, 50, 10
+ LTEXT "Geslo", -1, 40, 86, 50, 10
+ LTEXT "" IDC_PROXY, 80, 26, 150, 14, 0
+ LTEXT "" IDC_REALM, 80, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ CHECKBOX "&Shrani geslo (nezašèiteno)", IDC_SAVEPASSWORD,
+           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "V redu", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
+ PUSHBUTTON "Preklièi", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+}

reactos/lib/wininet/wininet_main.c

@@ -0,0 +1,40 @@
+/*
+ * WinInet
+ *
+ * Copyright (c) 2000 Patrik Stridvall
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <stdarg.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "winerror.h"
+
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(wininet);
+
+/***********************************************************************
+ *		DllInstall (WININET.@)
+ */
+HRESULT WINAPI DllInstall(BOOL bInstall, LPCWSTR cmdline)
+{
+  FIXME("(%s, %s): stub\n", bInstall?"TRUE":"FALSE",
+	debugstr_w(cmdline));
+
+  return S_OK;
+}

reactos/media/doc/README.WINE

@@ -78,7 +78,7 @@ reactos/lib/twain		# Out of sync
 reactos/lib/urlmon		# Synced to Wine-0_9_5
 reactos/lib/uxtheme		# Synced to Wine-0_9_5
 reactos/lib/version		# Out of sync
-reactos/lib/wininet		# Out of sync
+reactos/lib/wininet		# Synced to Wine-0_9_5
 reactos/lib/wintrust		# Synced to Wine-0_9_5
 reactos/lib/winmm		# Forked at Wine-20050628
 reactos/lib/winmm/midimap       # Forked at Wine-20050628

reactos/w32api/include/wininet.h

@@ -474,11 +474,42 @@ BOOLAPI InternetUnlockRequestFile(HANDLE);
 #define INTERNET_OPTION_HTTP_VERSION            59
 #define INTERNET_OPTION_RESET_URLCACHE_SESSION  60
 #define INTERNET_OPTION_ERROR_MASK              62
+#define INTERNET_OPTION_FROM_CACHE_TIMEOUT      63
+#define INTERNET_OPTION_BYPASS_EDITED_ENTRY     64
+#define INTERNET_OPTION_DIAGNOSTIC_SOCKET_INFO  67
 #define INTERNET_OPTION_CODEPAGE                68
+#define INTERNET_OPTION_CACHE_TIMESTAMPS        69
+#define INTERNET_OPTION_DISABLE_AUTODIAL        70
+#define INTERNET_OPTION_MAX_CONNS_PER_SERVER    73
+#define INTERNET_OPTION_MAX_CONNS_PER_1_0_SERVER 74
+#define INTERNET_OPTION_PER_CONNECTION_OPTION   75
+#define INTERNET_OPTION_DIGEST_AUTH_UNLOAD      76
+#define INTERNET_OPTION_IGNORE_OFFLINE          77
+#define INTERNET_OPTION_IDENTITY                78
+#define INTERNET_OPTION_REMOVE_IDENTITY         79
+#define INTERNET_OPTION_ALTER_IDENTITY          80
+#define INTERNET_OPTION_SUPPRESS_BEHAVIOR       81
+#define INTERNET_OPTION_AUTODIAL_MODE           82
+#define INTERNET_OPTION_AUTODIAL_CONNECTION     83
+#define INTERNET_OPTION_CLIENT_CERT_CONTEXT     84
+#define INTERNET_OPTION_AUTH_FLAGS              85
 #define INTERNET_OPTION_COOKIES_3RD_PARTY       86
+#define INTERNET_OPTION_COOKIES_3RD_PARTY       86
+#define INTERNET_OPTION_DISABLE_PASSPORT_AUTH   87
+#define INTERNET_OPTION_SEND_UTF8_SERVERNAME_TO_PROXY 88
+#define INTERNET_OPTION_EXEMPT_CONNECTION_LIMIT 89
+#define INTERNET_OPTION_ENABLE_PASSPORT_AUTH    90
+
+#define INTERNET_OPTION_HIBERNATE_INACTIVE_WORKER_THREADS 91
+#define INTERNET_OPTION_ACTIVATE_WORKER_THREADS           92
+#define INTERNET_OPTION_RESTORE_WORKER_THREAD_DEFAULTS    93
+#define INTERNET_OPTION_SOCKET_SEND_BUFFER_LENGTH         94
+
 #define INTERNET_OPTION_PROXY_SETTINGS_CHANGED  95
+#define INTERNET_OPTION_DATAFILE_EXT            96
+
 #define INTERNET_FIRST_OPTION                   INTERNET_OPTION_CALLBACK
-#define INTERNET_LAST_OPTION                    INTERNET_OPTION_PROXY_SETTINGS_CHANGED
+#define INTERNET_LAST_OPTION                    INTERNET_OPTION_DATAFILE_EXT
 
 #define INTERNET_PRIORITY_FOREGROUND            1000
 #define INTERNET_HANDLE_TYPE_INTERNET           1