proxy auto-detection and use for Windows

Author: virco

gitcommit.h

@@ -1,8 +1,8 @@
 #ifndef _GITCOMMIT_H
 #define _GITCOMMIT_H
 
-#define GIT_PREV_COMMIT_ID "f7113c6d269d4782c45d6a116faf113e3ea2a110"
-#define GIT_PREV_COMMIT_DATE "2016-12-20 15:50:08 +0200"
-#define GIT_COMMIT_DATE "2016-12-20 16:50:54 +0200"
+#define GIT_PREV_COMMIT_ID "30a21899d4ab26b42c021ec3048881c8d1fa240d"
+#define GIT_PREV_COMMIT_DATE "2016-12-20 16:50:54 +0200"
+#define GIT_COMMIT_DATE "2016-12-21 17:40:55 +0200"
 
 #endif

pcompat.c

@@ -65,6 +65,7 @@
 #include <dirent.h>
 #include <fcntl.h>
 #include <signal.h>
+#include <ctype.h>
 #include <pwd.h>
 #include <grp.h>
 
@@ -80,14 +81,20 @@ extern char **environ;
 
 #include <process.h>
 #include <windows.h>
+#include <winhttp.h>
 #include <ws2tcpip.h>
 #include <wincrypt.h>
 #include <tlhelp32.h>
 #include <iphlpapi.h>
 #include <shlobj.h>
 
+#pragma comment(lib, "winhttp.lib")
+
 #endif
 
+#define PROXY_NONE    0
+#define PROXY_CONNECT 1
+
 typedef struct {
   psync_thread_start0 run;
   const char *name;
@@ -106,6 +113,11 @@ static gid_t *psync_gids;
 static int psync_gids_cnt;
 #endif
 
+static int proxy_type=PROXY_NONE;
+static int proxy_detected=0;
+static char proxy_host[256];
+static char proxy_port[8];
+
 static int psync_page_size;
 
 static const char *psync_software_name="pCloudSync library "PSYNC_LIB_VERSION;
@@ -1188,7 +1200,100 @@ static void resolve_callback(void *h, void *ptr){
   psync_task_complete(h, res);
 }
 
-static psync_socket_t connect_socket(const char *host, const char *port){
+#if defined(P_OS_WINDOWS)
+static void gfree_ptr(HGLOBAL ptr){
+  if (ptr!=NULL)
+    GlobalFree(ptr);
+}
+
+static int try_set_proxy(LPWSTR pstr){
+  char *str, *c;
+  size_t hl, pl;
+  if (!pstr)
+    return 0;
+  str=wchar_to_utf8(pstr);
+  c=strchr(str, ':');
+  if (!c)
+    goto err;
+  hl=c-str;
+  c++;
+  pl=strlen(c);
+  if (pl && hl && hl<sizeof(proxy_host) && pl<sizeof(proxy_port)) {
+    proxy_host[hl]=0;
+    memcpy(proxy_host, str, hl);
+    proxy_port[pl]=0;
+    memcpy(proxy_port, c, pl);
+    psync_free(str);
+    proxy_type=PROXY_CONNECT;
+    debug(D_NOTICE, "auto detected proxy %s:%s", proxy_host, proxy_port);
+    return 1;
+  }
+err:
+  psync_free(str);
+  return 0;
+}
+
+#define PSYNC_HAS_PROXY_CODE
+
+#endif
+
+#if defined(PSYNC_HAS_PROXY_CODE)
+static int recent_detect(){
+  static time_t lastdetect=0;
+  if (psync_timer_time()<lastdetect+60)
+    return 1;
+  else{
+    lastdetect=psync_timer_time();
+    return 0;
+  }
+}
+#endif
+
+static void detect_proxy(){
+#if defined(P_OS_WINDOWS)
+  WINHTTP_CURRENT_USER_IE_PROXY_CONFIG ieconf;
+  WINHTTP_AUTOPROXY_OPTIONS aopt;
+  WINHTTP_PROXY_INFO pinfo;
+  HINTERNET hi;
+  if (recent_detect())
+    return;
+  hi=NULL;
+  pinfo.lpszProxy=NULL;
+  pinfo.lpszProxyBypass=NULL;
+  if (!WinHttpGetIEProxyConfigForCurrentUser(&ieconf))
+    return;
+  if (ieconf.fAutoDetect){
+    hi=WinHttpOpen(L"pCloud", WINHTTP_ACCESS_TYPE_DEFAULT_PROXY, WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0);
+    if (!hi){
+      debug(D_NOTICE, "WinHttpOpen failed");
+      goto manual;
+    }
+    memset(aopt, 0, sizeof(aopt));
+    aopt.dwFlags=WINHTTP_AUTOPROXY_AUTO_DETECT;
+    aopt.dwAutoDetectFlags=WINHTTP_AUTO_DETECT_TYPE_DHCP|WINHTTP_AUTO_DETECT_TYPE_DNS_A;
+    if (ieconf.lpszAutoConfigUrl){
+      aopt.dwFlags|=WINHTTP_AUTOPROXY_CONFIG_URL;
+      aopt.lpszAutoConfigUrl=ieconf.lpszAutoConfigUrl;
+    }
+    aopt.fAutoLogonIfChallenged=TRUE;
+    if (WinHttpGetProxyForUrl(hi, L"https://api.pcloud.com/", &aopt, &pinfo)  && pinfo.dwAccessType==WINHTTP_ACCESS_TYPE_NAMED_PROXY &&
+        try_set_proxy(pinfo.lpszProxy))
+      goto ex;
+  }
+manual:
+  try_set_proxy(pinfo.lpszProxy);
+ex:
+  if (hi)
+    WinHttpCloseHandle(hi);
+  gfree_ptr(pinfo.lpszProxy);
+  gfree_ptr(pinfo.lpszProxyBypass);
+  gfree_ptr(ieconf.lpszProxy);
+  gfree_ptr(ieconf.lpszProxyBypass);
+  gfree_ptr(ieconf.lpszAutoConfigUrl);
+#endif
+}
+
+static psync_socket_t connect_socket_direct(const char *host, const char *port){
   struct addrinfo *res, *dbres;
   struct addrinfo hints;
   psync_socket_t sock;
@@ -1210,6 +1315,7 @@ static psync_socket_t connect_socket(const char *host, const char *port){
     res=(struct addrinfo *)psync_task_get_result(tasks, 1);
     if (unlikely(!res)){
       psync_task_free(tasks);
+      detect_proxy();
       debug(D_WARNING, "failed to resolve %s", host);
       return INVALID_SOCKET;
     }
@@ -1241,6 +1347,7 @@ static psync_socket_t connect_socket(const char *host, const char *port){
 #endif
     if (unlikely(rc!=0)){
       debug(D_WARNING, "failed to resolve %s", host);
+      detect_proxy();
       return INVALID_SOCKET;
     }
     addr_save_to_db(host, port, res);
@@ -1274,11 +1381,111 @@ static psync_socket_t connect_socket(const char *host, const char *port){
 #endif
 #endif
   }
-  else
+  else{
+    detect_proxy();
     debug(D_WARNING, "failed to connect to %s:%s", host, port);
+  }
   return sock;
 }
 
+static int check_http_resp(char *str) {
+  if (memcmp(str, "HTTP", 4)){
+    debug(D_WARNING, "bad proxy response %s", str);
+    return 0;
+  }
+  while (*str && !isspace(*str))
+    str++;
+  while (*str && isspace(*str))
+    str++;
+  if (!isdigit(*str)){
+    debug(D_WARNING, "bad proxy response %s", str);
+    return 0;
+  }
+  if (atoi(str)!=200) {
+    debug(D_NOTICE, "proxy returned HTTP code %d", atoi(str));
+    return 0;
+  }
+  return 1;
+}
+
+static psync_socket_t connect_socket_connect_proxy(const char *host, const char *port){
+  char buff[2048], *str;
+  psync_socket_t sock;
+  int ln, wr, r, rc;
+  sock=connect_socket_direct(proxy_host, proxy_port);
+  if (unlikely(sock==INVALID_SOCKET)){
+    debug(D_NOTICE, "connection to proxy %s:%s failed", proxy_host, proxy_port);
+    goto err0;
+  }
+  ln=psync_slprintf(buff, sizeof(buff), "CONNECT %s:%s HTTP/1.0\015\012User-Agent: %s\015\012\015\012", host, port, psync_software_name);
+  wr=0;
+  while (wr<ln){
+    r=psync_write_socket(sock, buff+wr, ln-wr);
+    if (unlikely(r==SOCKET_ERROR)){
+      if (likely_log((psync_sock_err()==P_WOULDBLOCK || psync_sock_err()==P_AGAIN || psync_sock_err()==P_INTR) && !psync_wait_socket_write_timeout(sock)))
+        continue;
+      else
+        goto err1;
+    }
+    wr+=r;
+  }
+  wr=0;
+  rc=0;
+  while (1){
+    if (unlikely(psync_wait_socket_read_timeout(sock))){
+      debug(D_WARNING, "connection to %s:%s via %s:%s timeouted", host, port, proxy_host, proxy_port);
+      goto err1;
+    }
+    r=psync_read_socket(sock, buff+wr, sizeof(buff)-1-wr);
+    if (unlikely(r==0 || r==SOCKET_ERROR)){
+      if (r==0){
+        debug(D_NOTICE, "proxy server %s:%s closed connection", proxy_host, proxy_port);
+        goto err1;
+      }
+      if (likely_log(psync_sock_err()==P_WOULDBLOCK || psync_sock_err()==P_AGAIN || psync_sock_err()==P_INTR))
+        continue;
+      else
+        goto err1;
+    }
+    wr+=r;
+    buff[wr]=0;
+    str=strstr(buff, "\015\012\015\012");
+    if (str){
+      if (rc || check_http_resp(buff)){
+        debug(D_NOTICE, "connected to %s:%s via %s:%s", host, port, proxy_host, proxy_port);
+        return sock;
+      }else
+        goto err1;
+    }
+    if (wr==sizeof(buff)-1){
+      rc=check_http_resp(buff);
+      if (!rc)
+        goto err1;
+      memcpy(buff, buff+sizeof(buff)-8, 8);
+      wr=7; // yes, 7
+    }
+  }
+err1:
+  psync_close_socket(sock);
+err0:
+  detect_proxy();
+  if (proxy_type!=PROXY_CONNECT)
+    return connect_socket_direct(host, port);
+  else
+    return INVALID_SOCKET;
+}
+
+static psync_socket_t connect_socket(const char *host, const char *port){
+  if (unlikely(!proxy_detected)){
+    proxy_detected=1;
+    detect_proxy();
+  }
+  if (likely(proxy_type!=PROXY_CONNECT))
+    return connect_socket_direct(host, port);
+  else
+    return connect_socket_connect_proxy(host, port);
+}
+
 static int wait_sock_ready_for_ssl(psync_socket_t sock){
   fd_set fds, *rfds, *wfds;
   struct timeval tv;