/*

  * A program to explore http support on MS-Windows.

  */

 #include "config.h"

 #include <stdlib.h>

 #include <stdio.h>

 #include <glib.h>

 #include <razor.h>

 #if HAVE_WINHTTP_H

 #include <windows.h>

 #include <winhttp.h>

 #include <wincrypt.h>

 #ifndef PKCS12_NO_PERSIST_KEY

 #define PKCS12_NO_PERSIST_KEY 0x00008000

 #endif

 static gboolean debug=FALSE;

 static GOptionEntry entries[] = 

 {

     { "debug",'d',0,G_OPTION_ARG_NONE,&debug,"Output debugging",NULL },

     { NULL }

 };

 static struct WinHttpFuncs

 {

     WINBOOL (WINAPI *AddRequestHeaders)(HINTERNET,LPCWSTR,DWORD,DWORD);

     WINBOOL (WINAPI *DetectAutoProxyConfigUrl)(DWORD,LPWSTR*);

     WINBOOL (WINAPI *CheckPlatform)(void);

     WINBOOL (WINAPI *CloseHandle)(HINTERNET);

     HINTERNET (WINAPI *Connect)(HINTERNET,LPCWSTR,INTERNET_PORT,DWORD);

     WINBOOL (WINAPI *CrackUrl)(LPCWSTR,DWORD,DWORD,LPURL_COMPONENTS);

     WINBOOL (WINAPI *CreateUrl)(LPURL_COMPONENTS,DWORD,LPWSTR,LPDWORD);

     WINBOOL (WINAPI *GetDefaultProxyConfiguration)(WINHTTP_PROXY_INFO*);

     WINBOOL (WINAPI *GetIEProxyConfigForCurrentUser)(WINHTTP_CURRENT_USER_IE_PROXY_CONFIG*);

     WINBOOL (WINAPI *GetProxyForUrl)(HINTERNET,LPCWSTR,WINHTTP_AUTOPROXY_OPTIONS*,WINHTTP_PROXY_INFO*);

     HINTERNET (WINAPI *Open)(LPCWSTR,DWORD,LPCWSTR,LPCWSTR,DWORD);

     HINTERNET (WINAPI *OpenRequest)(HINTERNET,LPCWSTR,LPCWSTR,LPCWSTR,LPCWSTR,LPCWSTR*,DWORD);

     WINBOOL (WINAPI *QueryAuthParams)(HINTERNET,DWORD,LPVOID*);

     WINBOOL (WINAPI *QueryAuthSchemes)(HINTERNET,LPDWORD,LPDWORD,LPDWORD);

     WINBOOL (WINAPI *QueryDataAvailable)(HINTERNET,LPDWORD);

     WINBOOL (WINAPI *QueryHeaders)(HINTERNET,DWORD,LPCWSTR,LPVOID,LPDWORD,LPDWORD);

     WINBOOL (WINAPI *QueryOption)(HINTERNET,DWORD,LPVOID,LPDWORD);

     WINBOOL (WINAPI *ReadData)(HINTERNET,LPVOID,DWORD,LPDWORD);

     WINBOOL (WINAPI *ReceiveResponse)(HINTERNET,LPVOID);

     WINBOOL (WINAPI *SendRequest)(HINTERNET,LPCWSTR,DWORD,LPVOID,DWORD,DWORD,DWORD_PTR);

     WINBOOL (WINAPI *SetDefaultProxyConfiguration)(WINHTTP_PROXY_INFO*);

     WINBOOL (WINAPI *SetCredentials)(HINTERNET,DWORD,DWORD,LPCWSTR,LPCWSTR,LPVOID);

     WINBOOL (WINAPI *SetOption)(HINTERNET,DWORD,LPVOID,DWORD);

     WINHTTP_STATUS_CALLBACK (WINAPI *SetStatusCallback)(HINTERNET,WINHTTP_STATUS_CALLBACK,DWORD,DWORD_PTR);

     WINBOOL (WINAPI *SetTimeouts)(HINTERNET,int,int,int,int);

     WINBOOL (WINAPI *TimeFromSystemTime)(CONST SYSTEMTIME *,LPWSTR);

     WINBOOL (WINAPI *TimeToSystemTime)(LPCWSTR,SYSTEMTIME*);

     WINBOOL (WINAPI *WriteData)(HINTERNET,LPCVOID,DWORD,LPDWORD);

 } WinHttp;

 static int plover_init_winhttp(void)

 {

     HMODULE module;

     if (WinHttp.Open)

 	return 0;

     module=LoadLibraryA("winhttp.dll");

     if (!module)

 	return -1;

     WinHttp.AddRequestHeaders=

       (WINBOOL (WINAPI *)(HINTERNET,LPCWSTR,DWORD,DWORD))

       GetProcAddress(module,"WinHttpAddRequestHeaders");

     WinHttp.DetectAutoProxyConfigUrl=

       (WINBOOL (WINAPI *)(DWORD,LPWSTR*))

       GetProcAddress(module,"WinHttpDetectAutoProxyConfigUrl");

     WinHttp.CheckPlatform=(WINBOOL (WINAPI *)(void))

       GetProcAddress(module,"WinHttpCheckPlatform");

     WinHttp.CloseHandle=(WINBOOL (WINAPI *)(HINTERNET))

       GetProcAddress(module,"WinHttpCloseHandle");

     WinHttp.Connect=

       (HINTERNET (WINAPI *)(HINTERNET,LPCWSTR,INTERNET_PORT,DWORD))

       GetProcAddress(module,"WinHttpConnect");

     WinHttp.CrackUrl=(WINBOOL (WINAPI *)(LPCWSTR,DWORD,DWORD,LPURL_COMPONENTS))

       GetProcAddress(module,"WinHttpCrackUrl");

     WinHttp.CreateUrl=

       (WINBOOL (WINAPI *)(LPURL_COMPONENTS,DWORD,LPWSTR,LPDWORD))

       GetProcAddress(module,"WinHttpCreateUrl");

     WinHttp.GetDefaultProxyConfiguration=

       (WINBOOL (WINAPI *)(WINHTTP_PROXY_INFO*))

       GetProcAddress(module,"WinHttpGetDefaultProxyConfiguration");

     WinHttp.GetIEProxyConfigForCurrentUser=

       (WINBOOL (WINAPI *)(WINHTTP_CURRENT_USER_IE_PROXY_CONFIG*))

       GetProcAddress(module,"WinHttpGetIEProxyConfigForCurrentUser");

     WinHttp.GetProxyForUrl=

       (WINBOOL (WINAPI *)(HINTERNET,LPCWSTR,WINHTTP_AUTOPROXY_OPTIONS*,WINHTTP_PROXY_INFO*))

       GetProcAddress(module,"WinHttpGetProxyForUrl");

     WinHttp.Open=(HINTERNET (WINAPI *)(LPCWSTR,DWORD,LPCWSTR,LPCWSTR,DWORD))

       GetProcAddress(module,"WinHttpOpen");

     WinHttp.OpenRequest=

       (HINTERNET (WINAPI *)(HINTERNET,LPCWSTR,LPCWSTR,LPCWSTR,LPCWSTR,LPCWSTR*,DWORD))

       GetProcAddress(module,"WinHttpOpenRequest");

     WinHttp.QueryAuthParams=(WINBOOL (WINAPI *)(HINTERNET,DWORD,LPVOID*))

       GetProcAddress(module,"WinHttpQueryAuthParams");

     WinHttp.QueryAuthSchemes=

       (WINBOOL (WINAPI *)(HINTERNET,LPDWORD,LPDWORD,LPDWORD))

       GetProcAddress(module,"WinHttpQueryAuthSchemes");

     WinHttp.QueryDataAvailable=(WINBOOL (WINAPI *)(HINTERNET,LPDWORD))

       GetProcAddress(module,"WinHttpQueryDataAvailable");

     WinHttp.QueryHeaders=

       (WINBOOL (WINAPI *)(HINTERNET,DWORD,LPCWSTR,LPVOID,LPDWORD,LPDWORD))

       GetProcAddress(module,"WinHttpQueryHeaders");

     WinHttp.QueryOption=(WINBOOL (WINAPI *)(HINTERNET,DWORD,LPVOID,LPDWORD))

       GetProcAddress(module,"WinHttpQueryOption");

     WinHttp.ReadData=(WINBOOL (WINAPI *)(HINTERNET,LPVOID,DWORD,LPDWORD))

       GetProcAddress(module,"WinHttpReadData");

     WinHttp.ReceiveResponse=(WINBOOL (WINAPI *)(HINTERNET,LPVOID))

       GetProcAddress(module,"WinHttpReceiveResponse");

     WinHttp.SendRequest=

       (WINBOOL (WINAPI *)(HINTERNET,LPCWSTR,DWORD,LPVOID,DWORD,DWORD,DWORD_PTR))

       GetProcAddress(module,"WinHttpSendRequest");

     WinHttp.SetDefaultProxyConfiguration=

       (WINBOOL (WINAPI *)(WINHTTP_PROXY_INFO*))

       GetProcAddress(module,"WinHttpSetDefaultProxyConfiguration");

     WinHttp.SetCredentials=

       (WINBOOL (WINAPI *)(HINTERNET,DWORD,DWORD,LPCWSTR,LPCWSTR,LPVOID))

       GetProcAddress(module,"WinHttpSetCredentials");

     WinHttp.SetOption=(WINBOOL (WINAPI *)(HINTERNET,DWORD,LPVOID,DWORD))

       GetProcAddress(module,"WinHttpSetOption");

     WinHttp.SetStatusCallback=

       (WINHTTP_STATUS_CALLBACK (WINAPI *)(HINTERNET,WINHTTP_STATUS_CALLBACK,DWORD,DWORD_PTR))

       GetProcAddress(module,"WinHttpSetStatusCallback");

     WinHttp.SetTimeouts=(WINBOOL (WINAPI *)(HINTERNET,int,int,int,int))

       GetProcAddress(module,"WinHttpSetTimeouts");

     WinHttp.TimeFromSystemTime=(WINBOOL (WINAPI *)(CONST SYSTEMTIME *,LPWSTR))

       GetProcAddress(module,"WinHttpTimeFromSystemTime");

     WinHttp.TimeToSystemTime=(WINBOOL (WINAPI *)(LPCWSTR,SYSTEMTIME*))

       GetProcAddress(module,"WinHttpTimeToSystemTime");

     WinHttp.WriteData=(WINBOOL (WINAPI *)(HINTERNET,LPCVOID,DWORD,LPDWORD))

       GetProcAddress(module,"WinHttpWriteData");

     if (!WinHttp.CrackUrl || !WinHttp.Open || !WinHttp.Connect ||

         !WinHttp.OpenRequest || !WinHttp.SendRequest ||

 	!WinHttp.ReceiveResponse || !WinHttp.QueryDataAvailable ||

 	!WinHttp.ReadData || !WinHttp.CloseHandle)

     {

 	FreeLibrary(module);

 	WinHttp.Open=NULL;

 	return -1;

     }

     return 0;

 }

 /*

  * This will find ${PREFIX}/${file} if it exists, but it may also

  * find ${PREFIX}/.../${file} if ${PREFIX}/${file} does not exist.

  * This seems unlikely and won't do any harm should it occur.

  */

 gchar *find_prefixed_file(const char *file)

 {

     int i,len;

     const char *name;

     char *install_root;

     struct razor_set *set;

     struct razor_error *error=NULL;

     struct razor_package *package;

     struct razor_package_iterator *pi;

     struct razor_file_iterator *fi;

     gchar *retval=NULL;

     len=strlen(file);

     install_root=getenv("RAZOR_ROOT");

     if (!install_root)

 	install_root="";

     set=razor_root_open_read_only(install_root,&error);

     if (set)

     {

 	pi=razor_package_iterator_create(set);

 	while (razor_package_iterator_next(pi,&package,RAZOR_DETAIL_LAST))

 	{

 	    fi=razor_file_iterator_create(set,package,0);

 	    while (!retval && razor_file_iterator_next(fi,&name))

 	    {

 		i=strlen(name)-len;

 		if (i>0 && name[i-1]=='/' && !strcmp(name+i,file))

 		{

 		    if (!retval || strlen(retval)>strlen(name))

 		    {

 			g_free(retval);

 			retval=g_strdup(name);

 		    }

 		}

 	    }

 	    razor_file_iterator_destroy(fi);

 	}

 	razor_package_iterator_destroy(pi);

 	razor_set_unref(set);

     }

     if (error)

 	razor_error_free(error);

     return retval;

 }

 static HCERTSTORE plover_p12_import(const char *file,const wchar_t *password)

 {

     GError *error=NULL;

     gchar *p12,*path,*s;

     gsize len;

     CRYPT_DATA_BLOB pfx;

     HCERTSTORE store;

     s=g_build_path("/","etc","pki",file,NULL);

     path=find_prefixed_file(s);

     if (!path)

     {

 	g_printerr("%s: Not installed\n",s);

 	g_free(s);

 	return NULL;

     }

     g_free(s);

     if (!g_file_get_contents(path,&p12,&len,&error))

     {

 	g_printerr("%s: %s\n",path,error->message);

 	g_free(path);

 	g_error_free(error);

 	return NULL;

     }

     g_free(path);

     pfx.pbData=(BYTE *)p12;

     pfx.cbData=len;

     store=PFXImportCertStore(&pfx,password,PKCS12_NO_PERSIST_KEY);

     if (!store)

 	g_printerr("PFXImportCertStore failed. Err: %lu\n",GetLastError());

     g_free(p12);

     return store;

 }

 static const CERT_CONTEXT *plover_get_client_certificate(HCERTSTORE store)

 {

     const CERT_CONTEXT *iter,*cert;

     cert=NULL;

     iter=CertEnumCertificatesInStore(store,NULL);

     while(iter)

     {

 	if (!cert)

 	    cert=CertDuplicateCertificateContext(iter);

 	iter=CertEnumCertificatesInStore(store,iter);

     }

     return cert;

 }

 void CALLBACK plover_status_callback(HINTERNET handle,DWORD_PTR context,

   DWORD status,LPVOID status_information,DWORD status_information_length)

 {

     g_printerr("CB status 0x%lX",status);

     if (status==WINHTTP_CALLBACK_STATUS_SECURE_FAILURE)

 	g_printerr(", flag 0x%lX",*(DWORD *)status_information);

     g_printerr("\n");

 }

 int fetch(HINTERNET session,HCERTSTORE store,const char *url)

 {

     URL_COMPONENTS components={0};

     HINTERNET connection,request;

     DWORD len,nb,options;

     char *buffer;

     wchar_t *ws;

     glong ws_len;

     gchar *hostname,*path;

     const CERT_CONTEXT *client_cert;

     components.dwStructSize=sizeof(components);

     components.dwSchemeLength=(DWORD)-1;

     components.dwHostNameLength=(DWORD)-1;

     components.dwUserNameLength=(DWORD)-1;

     components.dwPasswordLength=(DWORD)-1;

     components.dwUrlPathLength=(DWORD)-1;

     ws=g_utf8_to_utf16(url,-1,NULL,&ws_len,NULL);

     if (!ws || !WinHttp.CrackUrl(ws,ws_len,0,&components))

     {

 	g_printerr("%s: Invalid or unsupported URL\n",url);

 	return -1;

     }

     /* ICU_REJECT_USERPWD is not supported under Windows XP */

     if (components.dwUserNameLength || components.dwPasswordLength)

     {

 	g_printerr("%s: Credentials not supported\n",url);

 	return -1;

     }

     hostname=g_utf16_to_utf8(components.lpszHostName,

       components.dwHostNameLength,NULL,NULL,NULL);

     path=g_utf16_to_utf8(components.lpszUrlPath,components.dwUrlPathLength,NULL,

       NULL,NULL);

     g_free(ws);

     ws=g_utf8_to_utf16(hostname,-1,NULL,NULL,NULL);

     connection=WinHttp.Connect(session,ws,

       components.nPort?components.nPort:INTERNET_DEFAULT_PORT,0);

     g_free(ws);

     if (connection)

     {

 	ws=g_utf8_to_utf16(path,-1,NULL,NULL,NULL);

 	request=WinHttp.OpenRequest(connection,L"GET",ws,NULL,

 	  WINHTTP_NO_REFERER,WINHTTP_DEFAULT_ACCEPT_TYPES,

 	  components.nScheme==INTERNET_SCHEME_HTTPS?WINHTTP_FLAG_SECURE:0);

 	g_free(ws);

 	if (request)

 	{

 	    if (debug)

 		(void)WinHttp.SetStatusCallback(request,plover_status_callback,

 		  WINHTTP_CALLBACK_FLAG_ALL_NOTIFICATIONS,0);

 	    if (components.nScheme==INTERNET_SCHEME_HTTPS && WinHttp.SetOption)

 	    {

 		options=SECURITY_FLAG_IGNORE_UNKNOWN_CA;

 		(void)WinHttp.SetOption(request,WINHTTP_OPTION_SECURITY_FLAGS,

 		  &options,sizeof(options));

 		client_cert=plover_get_client_certificate(store);

 		if (client_cert)

 		{

 		    if (!WinHttp.SetOption(request,

 		      WINHTTP_OPTION_CLIENT_CERT_CONTEXT,(void *)client_cert,

 		      sizeof(*client_cert)))

 			g_printerr("Failed to set client certificate (%lu)\n",

 			  GetLastError());

 		}

 		else

 		    g_printerr("No client certificate found\n");

 	    }

 	    if (!WinHttp.SendRequest(request,WINHTTP_NO_ADDITIONAL_HEADERS,

 	      0,WINHTTP_NO_REQUEST_DATA,0,0,0))

 		g_printerr("Failed to send request (%lu)\n",GetLastError());

 	    else if (!WinHttp.ReceiveResponse(request,NULL))

 		g_printerr("Failed to receive response (%lu)\n",GetLastError());

 	    else

 	    {

 		do

 		{

 		    len=0;

 		    if (!WinHttp.QueryDataAvailable(request,&len))

 			g_printerr(

 			  "Error %lu in WinHttpQueryDataAvailable.\n",

 			  (unsigned long)GetLastError());

 		    buffer=calloc(len+1,1);

 		    if (!buffer)

 			break;

 		    else

 		    {

 			if (!WinHttp.ReadData(request,(void *)buffer,len,&nb))

 			    g_printerr("Error %lu in WinHttpReadData.\n",

 			      (unsigned long)GetLastError());

 			else

 			    printf("%s\n",buffer);

 			free(buffer);

 		    }

 		} while (len>0);

 	    }

 	    WinHttp.CloseHandle(request);

 	}

 	else

 	    g_printerr("Failed to open request for %s (%lu)\n",path,

 	      GetLastError());

 	WinHttp.CloseHandle(connection);

     }

     else

 	g_printerr("Failed to open connection to %s\n",hostname);

     g_free(hostname);

     g_free(path);

     return 0;

 }

 int main(int argc,char **argv)

 {

     GError *error=NULL;

     GOptionContext *context;

     HCERTSTORE store;

     HINTERNET session;

     wchar_t *ws;

     context=g_option_context_new("URL - fetch a URL");

     g_option_context_add_main_entries(context,entries,NULL);

     if (!g_option_context_parse(context,&argc,&argv,&error))

     {

 	g_printerr("Option parsing failed: %s\n",error->message);

 	exit(1);

     }

     if (argc!=2)

     {

 	g_printerr("%s\n",g_option_context_get_help(context,TRUE,NULL));

 	exit(1);

     }

     if (plover_init_winhttp())

     {

 	g_printerr("HTTP is not supported on this machine\n");

 	exit(1);

     }

     store=plover_p12_import("system.p12",L"xyzzy-ylem");

     if (!store)

 	exit(1);

     ws=g_utf8_to_utf16(PACKAGE_NAME "/" PACKAGE_VERSION,-1,NULL,NULL,NULL);

     session=WinHttp.Open(ws,WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,

       WINHTTP_NO_PROXY_NAME,WINHTTP_NO_PROXY_BYPASS,0);

     free(ws);

     if (!session)

     {

 	g_printerr("Failed to open WinHttp session\n");

 	exit(1);

     }

     if (fetch(session,store,argv[1]))

 	exit(1);

     WinHttp.CloseHandle(session);

     CertCloseStore(store,CERT_CLOSE_STORE_FORCE_FLAG);

     exit(0);

 }

 #else	/* !HAVE_WINHTTP_H */

 main()

 {

     g_printerr("HTTP is not supported on this machine\n");

     exit(1);

 }

 #endif	/* HAVE_WINHTTP_H */