--- /dev/null
+/*
+ * 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_atomic *atomic;
+ 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="";
+ atomic=razor_atomic_open("Query packages");
+ set=razor_root_open_read_only(install_root,atomic);
+ 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);
+ }
+ razor_atomic_destroy(atomic);
+ 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 */
git://project.juiblex.co.uk / plover.git / commitdiff