LCOV - code coverage report
Current view: top level - src - assuan-socket.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 4 340 1.2 %
Date: 2016-12-01 18:29:29 Functions: 1 26 3.8 %

          Line data    Source code
       1             : /* assuan-socket.c - Socket wrapper
       2             :    Copyright (C) 2004, 2005, 2009 Free Software Foundation, Inc.
       3             :    Copyright (C) 2001-2015 g10 Code GmbH
       4             : 
       5             :    This file is part of Assuan.
       6             : 
       7             :    Assuan is free software; you can redistribute it and/or modify it
       8             :    under the terms of the GNU Lesser General Public License as
       9             :    published by the Free Software Foundation; either version 2.1 of
      10             :    the License, or (at your option) any later version.
      11             : 
      12             :    Assuan is distributed in the hope that it will be useful, but
      13             :    WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15             :    Lesser General Public License for more details.
      16             : 
      17             :    You should have received a copy of the GNU Lesser General Public
      18             :    License along with this program; if not, see <http://www.gnu.org/licenses/>.
      19             :  */
      20             : 
      21             : #ifdef HAVE_CONFIG_H
      22             : #include <config.h>
      23             : #endif
      24             : 
      25             : #include <stdio.h>
      26             : #include <stdlib.h>
      27             : #ifdef HAVE_W32_SYSTEM
      28             : # define WIN32_LEAN_AND_MEAN
      29             : # include <windows.h>
      30             : # include <wincrypt.h>
      31             : #ifndef HAVE_W32CE_SYSTEM
      32             : # include <io.h>
      33             : #endif
      34             : #else
      35             : # include <sys/types.h>
      36             : # include <sys/socket.h>
      37             : # include <netinet/in.h>
      38             : # include <arpa/inet.h>
      39             : #endif
      40             : #include <errno.h>
      41             : #ifdef HAVE_SYS_STAT_H
      42             : # include <sys/stat.h>
      43             : #endif
      44             : #ifdef HAVE_FCNTL_H
      45             : #include <fcntl.h>
      46             : #endif
      47             : #include <assert.h>
      48             : 
      49             : #include "assuan-defs.h"
      50             : #include "debug.h"
      51             : 
      52             : /* Hacks for Slowaris.  */
      53             : #ifndef PF_LOCAL
      54             : # ifdef PF_UNIX
      55             : #  define PF_LOCAL PF_UNIX
      56             : # else
      57             : #  define PF_LOCAL AF_UNIX
      58             : # endif
      59             : #endif
      60             : #ifndef AF_LOCAL
      61             : # define AF_LOCAL AF_UNIX
      62             : #endif
      63             : 
      64             : #ifdef HAVE_W32_SYSTEM
      65             : #ifndef S_IRUSR
      66             : # define S_IRUSR 0
      67             : # define S_IWUSR 0
      68             : #endif
      69             : #ifndef S_IRGRP
      70             : # define S_IRGRP 0
      71             : # define S_IWGRP 0
      72             : #endif
      73             : #ifndef ENOTSUP
      74             : #define ENOTSUP 129
      75             : #endif
      76             : #ifndef EPROTO
      77             : #define EPROTO 134
      78             : #endif
      79             : #ifndef EPROTONOSUPPORT
      80             : #define EPROTONOSUPPORT 135
      81             : #endif
      82             : #ifndef ENETDOWN
      83             : #define ENETDOWN 116
      84             : #endif
      85             : #ifndef ENETUNREACH
      86             : #define ENETUNREACH 118
      87             : #endif
      88             : #ifndef EHOSTUNREACH
      89             : #define EHOSTUNREACH 110
      90             : #endif
      91             : #ifndef ECONNREFUSED
      92             : #define ECONNREFUSED 107
      93             : #endif
      94             : #ifndef ETIMEDOUT
      95             : #define ETIMEDOUT 138
      96             : #endif
      97             : #endif
      98             : 
      99             : #ifndef ENAMETOOLONG
     100             : # define ENAMETOOLONG EINVAL
     101             : #endif
     102             : 
     103             : 
     104             : #ifndef SUN_LEN
     105             : # define SUN_LEN(ptr) ((size_t) (((struct sockaddr_un *) 0)->sun_path) \
     106             :                        + strlen ((ptr)->sun_path))
     107             : #endif
     108             : 
     109             : 
     110             : /* The standard SOCKS and TOR port.  */
     111             : #define SOCKS_PORT 1080
     112             : #define TOR_PORT   9050
     113             : #define TOR_PORT2  9150   /* The Tor browser is listening there.  */
     114             : 
     115             : /* In the future, we can allow access to sock_ctx, if that context's
     116             :    hook functions need to be overridden.  There can only be one global
     117             :    assuan_sock_* user (one library or one application) with this
     118             :    convenience interface, if non-standard hook functions are
     119             :    needed.  */
     120             : static assuan_context_t sock_ctx;
     121             : 
     122             : /* This global flag can be set using assuan_sock_set_flag to enable
     123             :    TOR or SOCKS mode for all sockets.  It may not be reset.  The value
     124             :    is the port to be used. */
     125             : static unsigned short tor_mode;
     126             : 
     127             : 
     128             : 
     129             : #ifdef HAVE_W32_SYSTEM
     130             : /* A table of active Cygwin connections.  This is only used for
     131             :    listening socket which should be only a few.  We do not enter
     132             :    sockets after a connect into this table.  */
     133             : static assuan_fd_t cygwin_fdtable[16];
     134             : /* A critical section to guard access to the table of Cygwin
     135             :    connections. */
     136             : static CRITICAL_SECTION cygwin_fdtable_cs;
     137             : 
     138             : 
     139             : /* Return true if SOCKFD is listed as Cygwin socket.  */
     140             : static int
     141             : is_cygwin_fd (assuan_fd_t sockfd)
     142             : {
     143             :   int ret = 0;
     144             :   int i;
     145             : 
     146             :   EnterCriticalSection (&cygwin_fdtable_cs);
     147             :   for (i=0; i < DIM(cygwin_fdtable); i++)
     148             :     {
     149             :       if (cygwin_fdtable[i] == sockfd)
     150             :         {
     151             :           ret = 1;
     152             :           break;
     153             :         }
     154             :     }
     155             :   LeaveCriticalSection (&cygwin_fdtable_cs);
     156             :   return ret;
     157             : }
     158             : 
     159             : 
     160             : /* Insert SOCKFD into the table of Cygwin sockets.  Return 0 on
     161             :    success or -1 on error.  */
     162             : static int
     163             : insert_cygwin_fd (assuan_fd_t sockfd)
     164             : {
     165             :   int ret = 0;
     166             :   int mark = -1;
     167             :   int i;
     168             : 
     169             :   EnterCriticalSection (&cygwin_fdtable_cs);
     170             : 
     171             :   for (i=0; i < DIM(cygwin_fdtable); i++)
     172             :     {
     173             :       if (cygwin_fdtable[i] == sockfd)
     174             :         goto leave;  /* Already in table.  */
     175             :       else if (cygwin_fdtable[i] == ASSUAN_INVALID_FD)
     176             :         mark = i;
     177             :     }
     178             :   if (mark == -1)
     179             :     {
     180             :       gpg_err_set_errno (EMFILE);
     181             :       ret = -1;
     182             :     }
     183             :   else
     184             :     cygwin_fdtable[mark] = sockfd;
     185             : 
     186             :  leave:
     187             :   LeaveCriticalSection (&cygwin_fdtable_cs);
     188             :   return ret;
     189             : }
     190             : 
     191             : 
     192             : /* Delete SOCKFD from the table of Cygwin sockets.  */
     193             : static void
     194             : delete_cygwin_fd (assuan_fd_t sockfd)
     195             : {
     196             :   int i;
     197             : 
     198             :   EnterCriticalSection (&cygwin_fdtable_cs);
     199             :   for (i=0; i < DIM(cygwin_fdtable); i++)
     200             :     {
     201             :       if (cygwin_fdtable[i] == sockfd)
     202             :         {
     203             :           cygwin_fdtable[i] = ASSUAN_INVALID_FD;
     204             :           break;
     205             :         }
     206             :     }
     207             :   LeaveCriticalSection (&cygwin_fdtable_cs);
     208             :   return;
     209             : }
     210             : 
     211             : 
     212             : #ifdef HAVE_W32CE_SYSTEM
     213             : static wchar_t *
     214             : utf8_to_wchar (const char *string)
     215             : {
     216             :   int n;
     217             :   size_t nbytes;
     218             :   wchar_t *result;
     219             : 
     220             :   if (!string)
     221             :     return NULL;
     222             : 
     223             :   n = MultiByteToWideChar (CP_UTF8, 0, string, -1, NULL, 0);
     224             :   if (n < 0)
     225             :     return NULL;
     226             : 
     227             :   nbytes = (size_t)(n+1) * sizeof(*result);
     228             :   if (nbytes / sizeof(*result) != (n+1))
     229             :     {
     230             :       SetLastError (ERROR_INVALID_PARAMETER);
     231             :       return NULL;
     232             :     }
     233             :   result = malloc (nbytes);
     234             :   if (!result)
     235             :     return NULL;
     236             : 
     237             :   n = MultiByteToWideChar (CP_UTF8, 0, string, -1, result, n);
     238             :   if (n < 0)
     239             :     {
     240             :       n = GetLastError ();
     241             :       free (result);
     242             :       result = NULL;
     243             :       SetLastError (n);
     244             :     }
     245             :   return result;
     246             : }
     247             : 
     248             : static HANDLE
     249             : MyCreateFile (LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwSharedMode,
     250             :               LPSECURITY_ATTRIBUTES lpSecurityAttributes,
     251             :               DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes,
     252             :               HANDLE hTemplateFile)
     253             : {
     254             :   wchar_t *filename;
     255             :   HANDLE result;
     256             :   int err;
     257             : 
     258             :   filename = utf8_to_wchar (lpFileName);
     259             :   if (!filename)
     260             :     return INVALID_HANDLE_VALUE;
     261             : 
     262             :   result = CreateFileW (filename, dwDesiredAccess, dwSharedMode,
     263             :                         lpSecurityAttributes, dwCreationDisposition,
     264             :                         dwFlagsAndAttributes, hTemplateFile);
     265             :   err = GetLastError ();
     266             :   free (filename);
     267             :   SetLastError (err);
     268             :   return result;
     269             : }
     270             : static int
     271             : MyDeleteFile (LPCSTR lpFileName)
     272             : {
     273             :   wchar_t *filename;
     274             :   int result, err;
     275             : 
     276             :   filename = utf8_to_wchar (lpFileName);
     277             :   if (!filename)
     278             :     return 0;
     279             : 
     280             :   result = DeleteFileW (filename);
     281             :   err = GetLastError ();
     282             :   free (filename);
     283             :   SetLastError (err);
     284             :   return result;
     285             : }
     286             : #else /*!HAVE_W32CE_SYSTEM*/
     287             : #define MyCreateFile CreateFileA
     288             : #define MyDeleteFile DeleteFileA
     289             : #endif /*!HAVE_W32CE_SYSTEM*/
     290             : 
     291             : int
     292             : _assuan_sock_wsa2errno (int err)
     293             : {
     294             :   switch (err)
     295             :     {
     296             :     case WSAENOTSOCK:
     297             :       return EINVAL;
     298             :     case WSAEWOULDBLOCK:
     299             :       return EAGAIN;
     300             :     case ERROR_BROKEN_PIPE:
     301             :       return EPIPE;
     302             :     case WSANOTINITIALISED:
     303             :       return ENOSYS;
     304             :     case WSAECONNREFUSED:
     305             :       return ECONNREFUSED;
     306             :     default:
     307             :       return EIO;
     308             :     }
     309             : }
     310             : 
     311             : 
     312             : /* W32: Fill BUFFER with LENGTH bytes of random.  Returns -1 on
     313             :    failure, 0 on success.  Sets errno on failure.  */
     314             : static int
     315             : get_nonce (char *buffer, size_t nbytes)
     316             : {
     317             :   HCRYPTPROV prov;
     318             :   int ret = -1;
     319             : 
     320             :   if (!CryptAcquireContext (&prov, NULL, NULL, PROV_RSA_FULL,
     321             :                             (CRYPT_VERIFYCONTEXT|CRYPT_SILENT)) )
     322             :     gpg_err_set_errno (ENODEV);
     323             :   else
     324             :     {
     325             :       if (!CryptGenRandom (prov, nbytes, (unsigned char *) buffer))
     326             :         gpg_err_set_errno (ENODEV);
     327             :       else
     328             :         ret = 0;
     329             :       CryptReleaseContext (prov, 0);
     330             :     }
     331             :   return ret;
     332             : }
     333             : 
     334             : 
     335             : /* W32: The buffer for NONCE needs to be at least 16 bytes.  Returns 0
     336             :    on success and sets errno on failure.  If FNAME has a Cygwin socket
     337             :    descriptor True is stored at CYGWIN.  */
     338             : static int
     339             : read_port_and_nonce (const char *fname, unsigned short *port, char *nonce,
     340             :                      int *cygwin)
     341             : {
     342             :   FILE *fp;
     343             :   char buffer[50], *p;
     344             :   size_t nread;
     345             :   int aval;
     346             : 
     347             :   *cygwin = 0;
     348             :   fp = fopen (fname, "rb");
     349             :   if (!fp)
     350             :     return -1;
     351             :   nread = fread (buffer, 1, sizeof buffer - 1, fp);
     352             :   fclose (fp);
     353             :   if (!nread)
     354             :     {
     355             :       gpg_err_set_errno (ENOENT);
     356             :       return -1;
     357             :     }
     358             :   buffer[nread] = 0;
     359             :   if (!strncmp (buffer, "!<socket >", 10))
     360             :     {
     361             :       /* This is the Cygwin compatible socket emulation.  The format
     362             :        * of the file is:
     363             :        *
     364             :        *   "!<socket >%u %c %08x-%08x-%08x-%08x\x00"
     365             :        *
     366             :        * %d for port number, %c for kind of socket (s for STREAM), and
     367             :        * we have 16-byte random bytes for nonce.  We only support
     368             :        * stream mode.
     369             :        */
     370             :       unsigned int u0;
     371             :       int narr[4];
     372             : 
     373             :       if (sscanf (buffer+10, "%u s %08x-%08x-%08x-%08x",
     374             :                   &u0, narr+0, narr+1, narr+2, narr+3) != 5
     375             :           || u0 < 1 || u0 > 65535)
     376             :         {
     377             :           gpg_err_set_errno (EINVAL);
     378             :           return -1;
     379             :         }
     380             :       *port = u0;
     381             :       memcpy (nonce, narr, 16);
     382             :       *cygwin = 1;
     383             :     }
     384             :   else
     385             :     {
     386             :       /* This is our own socket emulation.  */
     387             :       aval = atoi (buffer);
     388             :       if (aval < 1 || aval > 65535)
     389             :         {
     390             :           gpg_err_set_errno (EINVAL);
     391             :           return -1;
     392             :         }
     393             :       *port = (unsigned int)aval;
     394             :       for (p=buffer; nread && *p != '\n'; p++, nread--)
     395             :         ;
     396             :       if (*p != '\n' || nread != 17)
     397             :         {
     398             :           gpg_err_set_errno (EINVAL);
     399             :           return -1;
     400             :         }
     401             :       p++; nread--;
     402             :       memcpy (nonce, p, 16);
     403             :     }
     404             : 
     405             :   return 0;
     406             : }
     407             : #endif /*HAVE_W32_SYSTEM*/
     408             : 
     409             : 
     410             : #ifndef HAVE_W32_SYSTEM
     411             : /* Find a redirected socket name for fname and return a malloced setup
     412             :    filled sockaddr.  If this does not work out NULL is returned and
     413             :    ERRNO is set.  If the file seems to be a redirect True is stored at
     414             :    R_REDIRECT.  Note that this function uses the standard malloc and
     415             :    not the assuan wrapped one.  The format of the file is:
     416             : 
     417             :    %Assuan%
     418             :    socket=NAME
     419             : 
     420             :    where NAME is the actual socket to use.  No white spaces are
     421             :    allowed, both lines must be terminated by a single LF, extra lines
     422             :    are not allowed.  Environment variables are interpreted in NAME if
     423             :    given in "${VAR} notation; no escape characters are defined, if
     424             :    "${" shall be used verbatim, you need to use an environment
     425             :    variable with that content.
     426             : 
     427             :    The use of an absolute NAME is strongly suggested.  The length of
     428             :    the file is limited to 511 bytes which is more than sufficient for
     429             :    that common value of 107 for sun_path.  */
     430             : static struct sockaddr_un *
     431           0 : eval_redirection (const char *fname, int *r_redirect)
     432             : {
     433             :   FILE *fp;
     434             :   char buffer[512], *name;
     435             :   size_t n;
     436             :   struct sockaddr_un *addr;
     437             :   char *p, *pend;
     438             :   const char *s;
     439             : 
     440           0 :   *r_redirect = 0;
     441             : 
     442           0 :   fp = fopen (fname, "rb");
     443           0 :   if (!fp)
     444           0 :     return NULL;
     445           0 :   n = fread (buffer, 1, sizeof buffer - 1, fp);
     446           0 :   fclose (fp);
     447           0 :   if (!n)
     448             :     {
     449           0 :       gpg_err_set_errno (ENOENT);
     450           0 :       return NULL;
     451             :     }
     452           0 :   buffer[n] = 0;
     453             : 
     454             :   /* Check that it is a redirection file.  We also check that the
     455             :      first byte of the name is not a LF because that would lead to an
     456             :      zero length name. */
     457           0 :   if (n < 17 || buffer[n-1] != '\n'
     458           0 :       || memcmp (buffer, "%Assuan%\nsocket=", 16)
     459           0 :       || buffer[16] == '\n')
     460             :     {
     461           0 :       gpg_err_set_errno (EINVAL);
     462           0 :       return NULL;
     463             :     }
     464           0 :   buffer[n-1] = 0;
     465           0 :   name = buffer + 16;
     466             : 
     467           0 :   *r_redirect = 1;
     468             : 
     469           0 :   addr = calloc (1, sizeof *addr);
     470           0 :   if (!addr)
     471           0 :     return NULL;
     472           0 :   addr->sun_family = AF_LOCAL;
     473             : 
     474           0 :   n = 0;
     475           0 :   for (p=name; *p; p++)
     476             :     {
     477           0 :       if (*p == '$' && p[1] == '{')
     478             :         {
     479           0 :           p += 2;
     480           0 :           pend = strchr (p, '}');
     481           0 :           if (!pend)
     482             :             {
     483           0 :               free (addr);
     484           0 :               gpg_err_set_errno (EINVAL);
     485           0 :               return NULL;
     486             :             }
     487           0 :           *pend = 0;
     488           0 :           if (*p && (s = getenv (p)))
     489             :             {
     490           0 :               for (; *s; s++)
     491             :                 {
     492           0 :                   if (n < sizeof addr->sun_path - 1)
     493           0 :                     addr->sun_path[n++] = *s;
     494             :                   else
     495             :                     {
     496           0 :                       free (addr);
     497           0 :                       gpg_err_set_errno (ENAMETOOLONG);
     498           0 :                       return NULL;
     499             :                   }
     500             :                 }
     501             :             }
     502           0 :           p = pend;
     503             :         }
     504           0 :       else if (*p == '\n')
     505           0 :         break; /* Be nice and stop at the first LF.  */
     506           0 :       else if (n < sizeof addr->sun_path - 1)
     507           0 :         addr->sun_path[n++] = *p;
     508             :       else
     509             :         {
     510           0 :           free (addr);
     511           0 :           gpg_err_set_errno (ENAMETOOLONG);
     512           0 :           return NULL;
     513             :         }
     514             :     }
     515             : 
     516           0 :   return addr;
     517             : }
     518             : #endif /*!HAVE_W32_SYSTEM*/
     519             : 
     520             : 
     521             : 
     522             : /* Return a new socket.  Note that under W32 we consider a socket the
     523             :    same as an System Handle; all functions using such a handle know
     524             :    about this dual use and act accordingly. */
     525             : assuan_fd_t
     526           0 : _assuan_sock_new (assuan_context_t ctx, int domain, int type, int proto)
     527             : {
     528             : #ifdef HAVE_W32_SYSTEM
     529             :   assuan_fd_t res;
     530             :   if (domain == AF_UNIX || domain == AF_LOCAL)
     531             :     domain = AF_INET;
     532             :   res = SOCKET2HANDLE(_assuan_socket (ctx, domain, type, proto));
     533             :   return res;
     534             : #else
     535           0 :   return _assuan_socket (ctx, domain, type, proto);
     536             : #endif
     537             : }
     538             : 
     539             : 
     540             : int
     541           0 : _assuan_sock_set_flag (assuan_context_t ctx, assuan_fd_t sockfd,
     542             :                        const char *name, int value)
     543             : {
     544             :   (void)ctx;
     545             : 
     546           0 :   if (!strcmp (name, "cygwin"))
     547             :     {
     548             : #ifdef HAVE_W32_SYSTEM
     549             :       if (!value)
     550             :         delete_cygwin_fd (sockfd);
     551             :       else if (insert_cygwin_fd (sockfd))
     552             :         return -1;
     553             : #else
     554             :       /* Setting the Cygwin flag on non-Windows is ignored.  */
     555             : #endif
     556             :     }
     557           0 :   else if (!strcmp (name, "tor-mode") || !strcmp (name, "socks"))
     558             :     {
     559             :       /* If SOCKFD is ASSUAN_INVALID_FD this controls global flag to
     560             :          switch AF_INET and AF_INET6 into TOR mode by using a SOCKS5
     561             :          proxy on localhost:9050.  It may only be switched on and this
     562             :          needs to be done before any new threads are started.  Once
     563             :          TOR mode has been enabled, TOR mode can be disabled for a
     564             :          specific socket by using SOCKFD with a VALUE of 0.  */
     565           0 :       if (sockfd == ASSUAN_INVALID_FD)
     566             :         {
     567           0 :           if (tor_mode && !value)
     568             :             {
     569           0 :               gpg_err_set_errno (EPERM);
     570           0 :               return -1; /* Clearing the global flag is not allowed.  */
     571             :             }
     572           0 :           else if (value)
     573             :             {
     574           0 :               if (*name == 's')
     575           0 :                 tor_mode = SOCKS_PORT;
     576             :               else
     577           0 :                 tor_mode = TOR_PORT;
     578             :             }
     579             :         }
     580           0 :       else if (tor_mode && sockfd != ASSUAN_INVALID_FD)
     581             :         {
     582             :           /* Fixme: Disable/enable tormode for the given context.  */
     583             :         }
     584             :       else
     585             :         {
     586           0 :           gpg_err_set_errno (EINVAL);
     587           0 :           return -1;
     588             :         }
     589             :     }
     590             :   else
     591             :     {
     592           0 :       gpg_err_set_errno (EINVAL);
     593           0 :       return -1;
     594             :     }
     595             : 
     596           0 :   return 0;
     597             : }
     598             : 
     599             : 
     600             : int
     601           0 : _assuan_sock_get_flag (assuan_context_t ctx, assuan_fd_t sockfd,
     602             :                        const char *name, int *r_value)
     603             : {
     604             :   (void)ctx;
     605             : 
     606           0 :   if (!strcmp (name, "cygwin"))
     607             :     {
     608             : #ifdef HAVE_W32_SYSTEM
     609             :       *r_value = is_cygwin_fd (sockfd);
     610             : #else
     611           0 :       *r_value = 0;
     612             : #endif
     613             :     }
     614           0 :   else if (!strcmp (name, "tor-mode"))
     615             :     {
     616             :       /* FIXME: Find tor-mode for the given socket.  */
     617           0 :       *r_value = tor_mode == TOR_PORT;
     618             :     }
     619           0 :   else if (!strcmp (name, "socks"))
     620             :     {
     621           0 :       *r_value = tor_mode == SOCKS_PORT;
     622             :     }
     623             :   else
     624             :     {
     625           0 :       gpg_err_set_errno (EINVAL);
     626           0 :       return -1;
     627             :     }
     628             : 
     629           0 :   return 0;
     630             : }
     631             : 
     632             : 
     633             : /* Read NBYTES from SOCKFD into BUFFER.  Return 0 on success.  Handle
     634             :    EAGAIN and EINTR.  */
     635             : static int
     636           0 : do_readn (assuan_context_t ctx, assuan_fd_t sockfd,
     637             :           void *buffer, size_t nbytes)
     638             : {
     639           0 :   char *p = buffer;
     640             :   ssize_t n;
     641             : 
     642           0 :   while (nbytes)
     643             :     {
     644           0 :       n = _assuan_read (ctx, sockfd, p, nbytes);
     645           0 :       if (n < 0 && errno == EINTR)
     646             :         ;
     647           0 :       else if (n < 0 && errno == EAGAIN)
     648           0 :         _assuan_usleep (ctx, 100000); /* 100ms */
     649           0 :       else if (n < 0)
     650           0 :         return -1;
     651           0 :       else if (!n)
     652             :         {
     653           0 :           gpg_err_set_errno (EIO);
     654           0 :           return -1;
     655             :         }
     656             :       else
     657             :         {
     658           0 :           p += n;
     659           0 :           nbytes -= n;
     660             :         }
     661             :     }
     662           0 :   return 0;
     663             : }
     664             : 
     665             : 
     666             : /* Write NBYTES from BUFFER to SOCKFD.  Return 0 on success; on error
     667             :    return -1 and set ERRNO.  */
     668             : static int
     669           0 : do_writen (assuan_context_t ctx, assuan_fd_t sockfd,
     670             :            const void *buffer, size_t nbytes)
     671             : {
     672             :   int ret;
     673             : 
     674           0 :   ret = _assuan_write (ctx, sockfd, buffer, nbytes);
     675           0 :   if (ret >= 0 && ret != nbytes)
     676             :     {
     677           0 :       gpg_err_set_errno (EIO);
     678           0 :       ret = -1;
     679             :     }
     680           0 :   else if (ret >= 0)
     681           0 :     ret = 0;
     682             : 
     683           0 :   return ret;
     684             : }
     685             : 
     686             : 
     687             : /* Connect using the SOCKS5 protocol. */
     688             : static int
     689           0 : socks5_connect (assuan_context_t ctx, assuan_fd_t sock,
     690             :                 unsigned short socksport,
     691             :                 const char *credentials,
     692             :                 const char *hostname, unsigned short hostport,
     693             :                 struct sockaddr *addr, socklen_t length)
     694             : {
     695             :   int ret;
     696             :   /* struct sockaddr_in6 proxyaddr_in6; */
     697             :   struct sockaddr_in  proxyaddr_in;
     698             :   struct sockaddr *proxyaddr;
     699             :   size_t proxyaddrlen;
     700             :   struct sockaddr_in6 *addr_in6;
     701             :   struct sockaddr_in  *addr_in;
     702             :   unsigned char buffer[22+512]; /* The extra 512 gives enough space
     703             :                                    for username/password or the
     704             :                                    hostname. */
     705             :   size_t buflen, hostnamelen;
     706             :   int method;
     707             : 
     708             :   /* memset (&proxyaddr_in6, 0, sizeof proxyaddr_in6); */
     709           0 :   memset (&proxyaddr_in, 0, sizeof proxyaddr_in);
     710             : 
     711             :   /* Either HOSTNAME or ADDR may be given.  */
     712           0 :   if (hostname && addr)
     713             :     {
     714           0 :       gpg_err_set_errno (EINVAL);
     715           0 :       return -1;
     716             :     }
     717             : 
     718             :   /* If a hostname is given it must fit into our buffer and it must be
     719             :      less than 256 so that its length can be encoded in one byte.  */
     720           0 :   hostnamelen = hostname? strlen (hostname) : 0;
     721           0 :   if (hostnamelen > 255)
     722             :     {
     723           0 :       gpg_err_set_errno (ENAMETOOLONG);
     724           0 :       return -1;
     725             :     }
     726             : 
     727             :   /* Connect to local host.  */
     728             :   /* Fixme: First try to use IPv6 but note that
     729             :      _assuan_sock_connect_byname created the socket with AF_INET.  */
     730           0 :   proxyaddr_in.sin_family = AF_INET;
     731           0 :   proxyaddr_in.sin_port = htons (socksport);
     732           0 :   proxyaddr_in.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
     733           0 :   proxyaddr = (struct sockaddr *)&proxyaddr_in;
     734           0 :   proxyaddrlen = sizeof proxyaddr_in;
     735           0 :   ret = _assuan_connect (ctx, HANDLE2SOCKET (sock), proxyaddr, proxyaddrlen);
     736           0 :   if (ret && socksport == TOR_PORT && errno == ECONNREFUSED)
     737             :     {
     738             :       /* Standard Tor port failed - try the Tor browser port.  */
     739           0 :       proxyaddr_in.sin_port = htons (TOR_PORT2);
     740           0 :       ret = _assuan_connect (ctx, HANDLE2SOCKET (sock),
     741             :                              proxyaddr, proxyaddrlen);
     742             :     }
     743           0 :   if (ret)
     744           0 :     return ret;
     745           0 :   buffer[0] = 5; /* RFC-1928 VER field.  */
     746           0 :   buffer[1] = 1; /* NMETHODS */
     747           0 :   if (credentials)
     748           0 :     method = 2; /* Method: username/password authentication. */
     749             :   else
     750           0 :     method = 0; /* Method: No authentication required. */
     751           0 :   buffer[2] = method;
     752             : 
     753             :   /* Negotiate method.  */
     754           0 :   ret = do_writen (ctx, sock, buffer, 3);
     755           0 :   if (ret)
     756           0 :     return ret;
     757           0 :   ret = do_readn (ctx, sock, buffer, 2);
     758           0 :   if (ret)
     759           0 :     return ret;
     760           0 :   if (buffer[0] != 5 || buffer[1] != method )
     761             :     {
     762             :       /* Socks server returned wrong version or does not support our
     763             :          requested method.  */
     764           0 :       gpg_err_set_errno (ENOTSUP); /* Fixme: Is there a better errno? */
     765           0 :       return -1;
     766             :     }
     767             : 
     768           0 :   if (credentials)
     769             :     {
     770             :       const char *password;
     771             :       int ulen, plen;
     772             : 
     773           0 :       password = strchr (credentials, ':');
     774           0 :       if (!password)
     775             :         {
     776           0 :           gpg_err_set_errno (EINVAL); /* No password given.  */
     777           0 :           return -1;
     778             :         }
     779           0 :       ulen = password - credentials;
     780           0 :       password++;
     781           0 :       plen = strlen (password);
     782           0 :       if (!ulen || ulen > 255 || !plen || plen > 255)
     783             :         {
     784           0 :           gpg_err_set_errno (EINVAL);
     785           0 :           return -1;
     786             :         }
     787             : 
     788           0 :       buffer[0] = 1; /* VER of the sub-negotiation. */
     789           0 :       buffer[1] = ulen;
     790           0 :       buflen = 2;
     791           0 :       memcpy (buffer+buflen, credentials, ulen);
     792           0 :       buflen += ulen;
     793           0 :       buffer[buflen++] = plen;
     794           0 :       memcpy (buffer+buflen, password, plen);
     795           0 :       buflen += plen;
     796           0 :       ret = do_writen (ctx, sock, buffer, buflen);
     797           0 :       wipememory (buffer, buflen);
     798           0 :       if (ret)
     799           0 :         return ret;
     800           0 :       ret = do_readn (ctx, sock, buffer, 2);
     801           0 :       if (ret)
     802           0 :         return ret;
     803           0 :       if (buffer[0] != 1)
     804             :         {
     805             :           /* SOCKS server returned wrong version.  */
     806           0 :           gpg_err_set_errno (EPROTONOSUPPORT);
     807           0 :           return -1;
     808             :         }
     809           0 :       if (buffer[1])
     810             :         {
     811             :           /* SOCKS server denied access.  */
     812           0 :           gpg_err_set_errno (EACCES);
     813           0 :           return -1;
     814             :         }
     815             :     }
     816             : 
     817           0 :   if (hostname && !*hostname && !hostport)
     818             :     {
     819             :       /* Empty hostname given.  Stop right here to allow the caller to
     820             :          do the actual proxy request.  */
     821           0 :       return 0;
     822             :     }
     823             : 
     824             :   /* Send request details (rfc-1928, 4).  */
     825           0 :   buffer[0] = 5; /* VER  */
     826           0 :   buffer[1] = 1; /* CMD = CONNECT  */
     827           0 :   buffer[2] = 0; /* RSV  */
     828           0 :   if (hostname)
     829             :     {
     830           0 :       buffer[3] = 3; /* ATYP = DOMAINNAME */
     831           0 :       buflen = 4;
     832           0 :       buffer[buflen++] = hostnamelen;
     833           0 :       memcpy (buffer+buflen, hostname, hostnamelen);
     834           0 :       buflen += hostnamelen;
     835           0 :       buffer[buflen++] = (hostport >> 8); /* DST.PORT */
     836           0 :       buffer[buflen++] = hostport;
     837             :     }
     838           0 :   else if (addr->sa_family == AF_INET6)
     839             :     {
     840           0 :       addr_in6 = (struct sockaddr_in6 *)addr;
     841             : 
     842           0 :       buffer[3] = 4; /* ATYP = IPv6 */
     843           0 :       memcpy (buffer+ 4, &addr_in6->sin6_addr.s6_addr, 16); /* DST.ADDR */
     844           0 :       memcpy (buffer+20, &addr_in6->sin6_port, 2);          /* DST.PORT */
     845           0 :       buflen = 22;
     846             :     }
     847             :   else
     848             :     {
     849           0 :       addr_in = (struct sockaddr_in *)addr;
     850             : 
     851           0 :       buffer[3] = 1; /* ATYP = IPv4 */
     852           0 :       memcpy (buffer+4, &addr_in->sin_addr.s_addr, 4); /* DST.ADDR */
     853           0 :       memcpy (buffer+8, &addr_in->sin_port, 2);        /* DST.PORT */
     854           0 :       buflen = 10;
     855             :     }
     856           0 :   ret = do_writen (ctx, sock, buffer, buflen);
     857           0 :   if (ret)
     858           0 :     return ret;
     859           0 :   ret = do_readn (ctx, sock, buffer, 10 /* Length for IPv4 */);
     860           0 :   if (ret)
     861           0 :     return ret;
     862           0 :   if (buffer[0] != 5 || buffer[2] != 0 )
     863             :     {
     864             :       /* Socks server returned wrong version or the reserved field is
     865             :          not zero.  */
     866           0 :       gpg_err_set_errno (EPROTONOSUPPORT);
     867           0 :       return -1;
     868             :     }
     869           0 :   if (buffer[1])
     870             :     {
     871           0 :       switch (buffer[1])
     872             :         {
     873             :         case 0x01: /* General SOCKS server failure.  */
     874           0 :           gpg_err_set_errno (ENETDOWN);
     875           0 :           break;
     876             :         case 0x02: /* Connection not allowed by ruleset.  */
     877           0 :           gpg_err_set_errno (EACCES);
     878           0 :           break;
     879             :         case 0x03: /* Network unreachable */
     880           0 :           gpg_err_set_errno (ENETUNREACH);
     881           0 :           break;
     882             :         case 0x04: /* Host unreachable */
     883           0 :           gpg_err_set_errno (EHOSTUNREACH);
     884           0 :           break;
     885             :         case 0x05: /* Connection refused */
     886           0 :           gpg_err_set_errno (ECONNREFUSED);
     887           0 :           break;
     888             :         case 0x06: /* TTL expired */
     889           0 :           gpg_err_set_errno (ETIMEDOUT);
     890           0 :           break;
     891             :         case 0x08: /* Address type not supported */
     892           0 :           gpg_err_set_errno (EPROTONOSUPPORT);
     893           0 :           break;
     894             :         case 0x07: /* Command not supported */
     895             :         default:
     896           0 :           gpg_err_set_errno (ENOTSUP); /* Fixme: Is there a better errno? */
     897             :         }
     898           0 :       return -1;
     899             :     }
     900           0 :   if (buffer[3] == 4)
     901             :     {
     902             :       /* ATYP indicates a v6 address.  We need to read the remaining
     903             :          12 bytes.  */
     904           0 :       ret = do_readn (ctx, sock, buffer+10, 12);
     905           0 :       if (ret)
     906           0 :         return ret;
     907             :     }
     908             : 
     909             :   /* FIXME: We have not way to store the actual address used by the
     910             :      server.  */
     911             : 
     912             : 
     913           0 :   return 0;
     914             : }
     915             : 
     916             : 
     917             : /* Return true if SOCKS shall be used.  This is the case if tor_mode
     918             :    is enabled and the desired address is not the loopback
     919             :    address.  */
     920             : static int
     921           0 : use_socks (struct sockaddr *addr)
     922             : {
     923           0 :   if (!tor_mode)
     924           0 :     return 0;
     925           0 :   else if (addr->sa_family == AF_INET6)
     926             :     {
     927           0 :       struct sockaddr_in6 *addr_in6 = (struct sockaddr_in6 *)addr;
     928             :       const unsigned char *s;
     929             :       int i;
     930             : 
     931           0 :       s = (unsigned char *)&addr_in6->sin6_addr.s6_addr;
     932           0 :       if (s[15] != 1)
     933           0 :         return 1;   /* Last octet is not 1 - not the loopback address.  */
     934           0 :       for (i=0; i < 15; i++, s++)
     935           0 :         if (*s)
     936           0 :           return 1; /* Non-zero octet found - not the loopback address.  */
     937             : 
     938           0 :       return 0; /* This is the loopback address.  */
     939             :     }
     940           0 :   else if (addr->sa_family == AF_INET)
     941             :     {
     942           0 :       struct sockaddr_in *addr_in = (struct sockaddr_in *)addr;
     943             : 
     944           0 :       if (*(unsigned char*)&addr_in->sin_addr.s_addr == 127)
     945           0 :         return 0; /* Loopback (127.0.0.0/8) */
     946             : 
     947           0 :       return 1;
     948             :     }
     949             :   else
     950           0 :     return 0;
     951             : }
     952             : 
     953             : 
     954             : int
     955           0 : _assuan_sock_connect (assuan_context_t ctx, assuan_fd_t sockfd,
     956             :                       struct sockaddr *addr, int addrlen)
     957             : {
     958             : #ifdef HAVE_W32_SYSTEM
     959             :   if (addr->sa_family == AF_LOCAL || addr->sa_family == AF_UNIX)
     960             :     {
     961             :       struct sockaddr_in myaddr;
     962             :       struct sockaddr_un *unaddr;
     963             :       unsigned short port;
     964             :       char nonce[16];
     965             :       int cygwin;
     966             :       int ret;
     967             : 
     968             :       unaddr = (struct sockaddr_un *)addr;
     969             :       if (read_port_and_nonce (unaddr->sun_path, &port, nonce, &cygwin))
     970             :         return -1;
     971             : 
     972             :       myaddr.sin_family = AF_INET;
     973             :       myaddr.sin_port = htons (port);
     974             :       myaddr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
     975             : 
     976             :       /* Set return values.  */
     977             :       unaddr->sun_family = myaddr.sin_family;
     978             :       unaddr->sun_port = myaddr.sin_port;
     979             :       unaddr->sun_addr.s_addr = myaddr.sin_addr.s_addr;
     980             : 
     981             :       ret = _assuan_connect (ctx, HANDLE2SOCKET(sockfd),
     982             :                             (struct sockaddr *)&myaddr, sizeof myaddr);
     983             :       if (!ret)
     984             :         {
     985             :           /* Send the nonce. */
     986             :           ret = do_writen (ctx, sockfd, nonce, 16);
     987             :           if (!ret && cygwin)
     988             :             {
     989             :               char buffer[16];
     990             : 
     991             :               /* The client sends the nonce back - not useful.  We do
     992             :                  a dummy read.  */
     993             :               ret = do_readn (ctx, sockfd, buffer, 16);
     994             :               if (!ret)
     995             :                 {
     996             :                   /* Send our credentials.  */
     997             :                   int n = getpid ();
     998             :                   memcpy (buffer, &n, 4);
     999             :                   memset (buffer+4, 0, 4); /* uid = gid = 0 */
    1000             :                   ret = do_writen (ctx, sockfd, buffer, 8);
    1001             :                   if (!ret)
    1002             :                     {
    1003             :                       /* Receive credentials.  We don't need them.  */
    1004             :                       ret = do_readn (ctx, sockfd, buffer, 8);
    1005             :                     }
    1006             :                 }
    1007             :             }
    1008             :         }
    1009             :       return ret;
    1010             :     }
    1011             :   else if (use_socks (addr))
    1012             :     {
    1013             :       return socks5_connect (ctx, sockfd, tor_mode,
    1014             :                              NULL, NULL, 0, addr, addrlen);
    1015             :     }
    1016             :   else
    1017             :     {
    1018             :       return _assuan_connect (ctx, HANDLE2SOCKET (sockfd), addr, addrlen);
    1019             :     }
    1020             : #else
    1021             : # if HAVE_STAT
    1022           0 :   if (addr->sa_family == AF_LOCAL || addr->sa_family == AF_UNIX)
    1023             :     {
    1024             :       struct sockaddr_un *unaddr;
    1025             :       struct stat statbuf;
    1026             :       int redirect, res;
    1027             : 
    1028           0 :       unaddr = (struct sockaddr_un *)addr;
    1029           0 :       if (!stat (unaddr->sun_path, &statbuf)
    1030           0 :           && !S_ISSOCK (statbuf.st_mode)
    1031           0 :           && S_ISREG (statbuf.st_mode))
    1032             :         {
    1033             :           /* The given socket file is not a socket but a regular file.
    1034             :              We use the content of that file to redirect to another
    1035             :              socket file.  This can be used to use sockets on file
    1036             :              systems which do not support sockets or if for example a
    1037             :              home directory is shared by several machines.  */
    1038           0 :           unaddr = eval_redirection (unaddr->sun_path, &redirect);
    1039           0 :           if (unaddr)
    1040             :             {
    1041           0 :               res = _assuan_connect (ctx, sockfd, (struct sockaddr *)unaddr,
    1042           0 :                                      SUN_LEN (unaddr));
    1043           0 :               free (unaddr);
    1044           0 :               return res;
    1045             :             }
    1046           0 :           if (redirect)
    1047           0 :             return -1;
    1048             :           /* Continue using the standard connect.  */
    1049             :         }
    1050             : 
    1051             :     }
    1052             : # endif /*HAVE_STAT*/
    1053             : 
    1054           0 :   if (use_socks (addr))
    1055             :     {
    1056           0 :       return socks5_connect (ctx, sockfd, tor_mode,
    1057             :                              NULL, NULL, 0, addr, addrlen);
    1058             :     }
    1059             :   else
    1060             :     {
    1061           0 :       return _assuan_connect (ctx, sockfd, addr, addrlen);
    1062             :     }
    1063             : #endif
    1064             : }
    1065             : 
    1066             : 
    1067             : /* Connect to HOST specified as host name on PORT.  The current
    1068             :    implementation requires that either the flags ASSUAN_SOCK_SOCKS or
    1069             :    ASSUAN_SOCK_TOR are given in FLAGS.  On success a new socket is
    1070             :    returned; on error ASSUAN_INVALID_FD is returned and ERRNO set.  If
    1071             :    CREDENTIALS is not NULL, it is a string used for password based
    1072             :    authentication.  Username and password are separated by a colon.
    1073             :    RESERVED must be 0.  By passing HOST and PORT as 0 the function can
    1074             :    be used to check for proxy availability: If the proxy is available
    1075             :    a socket will be returned which the caller should then close.  */
    1076             : assuan_fd_t
    1077           0 : _assuan_sock_connect_byname (assuan_context_t ctx, const char *host,
    1078             :                              unsigned short port, int reserved,
    1079             :                              const char *credentials, unsigned int flags)
    1080             : {
    1081             :   assuan_fd_t fd;
    1082             :   unsigned short socksport;
    1083             : 
    1084           0 :   if ((flags & ASSUAN_SOCK_TOR))
    1085           0 :     socksport = TOR_PORT;
    1086           0 :   else if ((flags & ASSUAN_SOCK_SOCKS))
    1087           0 :     socksport = SOCKS_PORT;
    1088             :   else
    1089             :     {
    1090           0 :       gpg_err_set_errno (ENOTSUP);
    1091           0 :       return ASSUAN_INVALID_FD;
    1092             :     }
    1093             : 
    1094           0 :   if (host && !*host)
    1095             :     {
    1096             :       /* Error out early on an empty host name.  See below.  */
    1097           0 :       gpg_err_set_errno (EINVAL);
    1098           0 :       return ASSUAN_INVALID_FD;
    1099             :     }
    1100             : 
    1101           0 :   fd = _assuan_sock_new (ctx, AF_INET, SOCK_STREAM, 0);
    1102           0 :   if (fd == ASSUAN_INVALID_FD)
    1103           0 :     return fd;
    1104             : 
    1105             :   /* For HOST being NULL we pass an empty string which indicates to
    1106             :      socks5_connect to stop midway during the proxy negotiation.  Note
    1107             :      that we can't pass NULL directly as this indicates IP address
    1108             :      mode to the called function.  */
    1109           0 :   if (socks5_connect (ctx, fd, socksport,
    1110             :                       credentials, host? host:"", port, NULL, 0))
    1111             :     {
    1112           0 :       int save_errno = errno;
    1113           0 :       assuan_sock_close (fd);
    1114           0 :       gpg_err_set_errno (save_errno);
    1115           0 :       return ASSUAN_INVALID_FD;
    1116             :     }
    1117             : 
    1118           0 :   return fd;
    1119             : }
    1120             : 
    1121             : 
    1122             : int
    1123           0 : _assuan_sock_bind (assuan_context_t ctx, assuan_fd_t sockfd,
    1124             :                    struct sockaddr *addr, int addrlen)
    1125             : {
    1126             : #ifdef HAVE_W32_SYSTEM
    1127             :   if (addr->sa_family == AF_LOCAL || addr->sa_family == AF_UNIX)
    1128             :     {
    1129             :       struct sockaddr_in myaddr;
    1130             :       struct sockaddr_un *unaddr;
    1131             :       HANDLE filehd;
    1132             :       int len = sizeof myaddr;
    1133             :       int rc;
    1134             :       union {
    1135             :         char data[16];
    1136             :         int  aint[4];
    1137             :       } nonce;
    1138             :       char tmpbuf[50+16];
    1139             :       DWORD nwritten;
    1140             : 
    1141             :       if (get_nonce (nonce.data, 16))
    1142             :         return -1;
    1143             : 
    1144             :       unaddr = (struct sockaddr_un *)addr;
    1145             : 
    1146             :       myaddr.sin_port = 0;
    1147             :       myaddr.sin_family = AF_INET;
    1148             :       myaddr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
    1149             : 
    1150             :       filehd = MyCreateFile (unaddr->sun_path,
    1151             :                              GENERIC_WRITE,
    1152             :                              FILE_SHARE_READ,
    1153             :                              NULL,
    1154             :                              CREATE_NEW,
    1155             :                              FILE_ATTRIBUTE_NORMAL,
    1156             :                              NULL);
    1157             :       if (filehd == INVALID_HANDLE_VALUE)
    1158             :         {
    1159             :           if (GetLastError () == ERROR_FILE_EXISTS)
    1160             :             gpg_err_set_errno (EADDRINUSE);
    1161             :           return -1;
    1162             :         }
    1163             : 
    1164             :       rc = bind (HANDLE2SOCKET (sockfd), (struct sockaddr *)&myaddr, len);
    1165             :       if (!rc)
    1166             :         rc = getsockname (HANDLE2SOCKET (sockfd),
    1167             :                           (struct sockaddr *)&myaddr, &len);
    1168             :       if (rc)
    1169             :         {
    1170             :           int save_e = errno;
    1171             :           CloseHandle (filehd);
    1172             :           MyDeleteFile (unaddr->sun_path);
    1173             :           gpg_err_set_errno (save_e);
    1174             :           return rc;
    1175             :         }
    1176             : 
    1177             :       if (is_cygwin_fd (sockfd))
    1178             :         {
    1179             :           snprintf (tmpbuf, sizeof tmpbuf,
    1180             :                     "!<socket >%d s %08x-%08x-%08x-%08x",
    1181             :                     ntohs (myaddr.sin_port),
    1182             :                     nonce.aint[0], nonce.aint[1], nonce.aint[2], nonce.aint[3]);
    1183             :           len = strlen (tmpbuf) + 1;
    1184             :         }
    1185             :       else
    1186             :         {
    1187             :           snprintf (tmpbuf, sizeof tmpbuf-16, "%d\n", ntohs (myaddr.sin_port));
    1188             :           len = strlen (tmpbuf);
    1189             :           memcpy (tmpbuf+len, nonce.data,16);
    1190             :           len += 16;
    1191             :         }
    1192             : 
    1193             :       if (!WriteFile (filehd, tmpbuf, len, &nwritten, NULL))
    1194             :         {
    1195             :           CloseHandle (filehd);
    1196             :           MyDeleteFile (unaddr->sun_path);
    1197             :           gpg_err_set_errno (EIO);
    1198             :           return -1;
    1199             :         }
    1200             :       CloseHandle (filehd);
    1201             :       return 0;
    1202             :     }
    1203             :   else
    1204             :     {
    1205             :       int res = bind (HANDLE2SOCKET(sockfd), addr, addrlen);
    1206             :       if (res < 0)
    1207             :         gpg_err_set_errno ( _assuan_sock_wsa2errno (WSAGetLastError ()));
    1208             :       return res;
    1209             :     }
    1210             : #else
    1211           0 :   return bind (sockfd, addr, addrlen);
    1212             : #endif
    1213             : }
    1214             : 
    1215             : 
    1216             : /* Setup the ADDR structure for a Unix domain socket with the socket
    1217             :    name FNAME.  If this is a redirected socket and R_REDIRECTED is not
    1218             :    NULL, it will be setup for the real socket.  Returns 0 on success
    1219             :    and stores 1 at R_REDIRECTED if it is a redirected socket.  On
    1220             :    error -1 is returned and ERRNO will be set.  */
    1221             : int
    1222           0 : _assuan_sock_set_sockaddr_un (const char *fname, struct sockaddr *addr,
    1223             :                               int *r_redirected)
    1224             : {
    1225           0 :   struct sockaddr_un *unaddr = (struct sockaddr_un *)addr;
    1226             : #if !defined(HAVE_W32_SYSTEM) && defined(HAVE_STAT)
    1227             :   struct stat statbuf;
    1228             : #endif
    1229             : 
    1230           0 :   if (r_redirected)
    1231           0 :     *r_redirected = 0;
    1232             : 
    1233             : #if !defined(HAVE_W32_SYSTEM) && defined(HAVE_STAT)
    1234           0 :   if (r_redirected
    1235           0 :       && !stat (fname, &statbuf)
    1236           0 :       && !S_ISSOCK (statbuf.st_mode)
    1237           0 :       && S_ISREG (statbuf.st_mode))
    1238             :     {
    1239             :       /* The given socket file is not a socket but a regular file.  We
    1240             :          use the content of that file to redirect to another socket
    1241             :          file.  This can be used to use sockets on file systems which
    1242             :          do not support sockets or if for example a home directory is
    1243             :          shared by several machines.  */
    1244             :       struct sockaddr_un *unaddr_new;
    1245             :       int redirect;
    1246             : 
    1247           0 :       unaddr_new = eval_redirection (fname, &redirect);
    1248           0 :       if (unaddr_new)
    1249             :         {
    1250           0 :           memcpy (unaddr, unaddr_new, sizeof *unaddr);
    1251           0 :           free (unaddr_new);
    1252           0 :           *r_redirected = 1;
    1253           0 :           return 0;
    1254             :         }
    1255           0 :       if (redirect)
    1256             :         {
    1257           0 :           *r_redirected = 1;
    1258           0 :           return -1;  /* Error.  */
    1259             :         }
    1260             :       /* Fallback to standard setup.  */
    1261             :     }
    1262             : #endif /*!HAVE_W32_SYSTEM && HAVE_STAT*/
    1263             : 
    1264           0 :   if (strlen (fname)+1 >= sizeof unaddr->sun_path)
    1265             :     {
    1266           0 :       gpg_err_set_errno (ENAMETOOLONG);
    1267           0 :       return -1;
    1268             :     }
    1269             : 
    1270           0 :   memset (unaddr, 0, sizeof *unaddr);
    1271           0 :   unaddr->sun_family = AF_LOCAL;
    1272           0 :   strncpy (unaddr->sun_path, fname, sizeof unaddr->sun_path - 1);
    1273           0 :   unaddr->sun_path[sizeof unaddr->sun_path - 1] = 0;
    1274             : 
    1275           0 :   return 0;
    1276             : }
    1277             : 
    1278             : 
    1279             : int
    1280           0 : _assuan_sock_get_nonce (assuan_context_t ctx, struct sockaddr *addr,
    1281             :                         int addrlen, assuan_sock_nonce_t *nonce)
    1282             : {
    1283             : #ifdef HAVE_W32_SYSTEM
    1284             :   if (addr->sa_family == AF_LOCAL || addr->sa_family == AF_UNIX)
    1285             :     {
    1286             :       struct sockaddr_un *unaddr;
    1287             :       unsigned short port;
    1288             :       int dummy;
    1289             : 
    1290             :       if (sizeof nonce->nonce != 16)
    1291             :         {
    1292             :           gpg_err_set_errno (EINVAL);
    1293             :           return -1;
    1294             :         }
    1295             :       nonce->length = 16;
    1296             :       unaddr = (struct sockaddr_un *)addr;
    1297             :       if (read_port_and_nonce (unaddr->sun_path, &port, nonce->nonce, &dummy))
    1298             :         return -1;
    1299             :     }
    1300             :   else
    1301             :     {
    1302             :       nonce->length = 42; /* Arbitrary value to detect unitialized nonce. */
    1303             :       nonce->nonce[0] = 42;
    1304             :     }
    1305             : #else
    1306             :   (void)addr;
    1307             :   (void)addrlen;
    1308           0 :   nonce->length = 0;
    1309             : #endif
    1310           0 :   return 0;
    1311             : }
    1312             : 
    1313             : 
    1314             : int
    1315           0 : _assuan_sock_check_nonce (assuan_context_t ctx, assuan_fd_t fd,
    1316             :                           assuan_sock_nonce_t *nonce)
    1317             : {
    1318             : #ifdef HAVE_W32_SYSTEM
    1319             :   char buffer[16];
    1320             :   int n;
    1321             : 
    1322             :   if (sizeof nonce->nonce != 16)
    1323             :     {
    1324             :       gpg_err_set_errno (EINVAL);
    1325             :       return -1;
    1326             :     }
    1327             : 
    1328             :   if (nonce->length == 42 && nonce->nonce[0] == 42)
    1329             :     return 0; /* Not a Unix domain socket.  */
    1330             : 
    1331             :   if (nonce->length != 16)
    1332             :     {
    1333             :       gpg_err_set_errno (EINVAL);
    1334             :       return -1;
    1335             :     }
    1336             : 
    1337             :   if (do_readn (ctx, fd, buffer, 16))
    1338             :     return -1;
    1339             :   if (memcmp (buffer, nonce->nonce, 16))
    1340             :     {
    1341             :       gpg_err_set_errno (EACCES);
    1342             :       return -1;
    1343             :     }
    1344             :   if (is_cygwin_fd (fd))
    1345             :     {
    1346             :       /* Send the nonce back to the client.  */
    1347             :       if (do_writen (ctx, fd, buffer, 16))
    1348             :         return -1;
    1349             :       /* Read the credentials.  Cygwin uses the
    1350             :             struct ucred { pid_t pid; uid_t uid; gid_t gid; };
    1351             :          with pid_t being an int (4 bytes) and uid_t and gid_t being
    1352             :          shorts (2 bytes).  Thus we need to read 8 bytes.  However we
    1353             :          we ignore the values because they are not kernel controlled.  */
    1354             :       if (do_readn (ctx, fd, buffer, 8))
    1355             :         return -1;
    1356             :       /* Send our credentials: We use the uid and gid we received but
    1357             :          our own pid.  */
    1358             :       n = getpid ();
    1359             :       memcpy (buffer, &n, 4);
    1360             :       if (do_writen (ctx, fd, buffer, 8))
    1361             :         return -1;
    1362             :     }
    1363             : 
    1364             : #else
    1365             :   (void)fd;
    1366             :   (void)nonce;
    1367             : #endif
    1368           0 :   return 0;
    1369             : }
    1370             : 
    1371             : 
    1372             : /* Public API.  */
    1373             : 
    1374             : gpg_error_t
    1375           2 : assuan_sock_init ()
    1376             : {
    1377             :   gpg_error_t err;
    1378             : #ifdef HAVE_W32_SYSTEM
    1379             :   WSADATA wsadat;
    1380             : #endif
    1381             : 
    1382           2 :   if (sock_ctx != NULL)
    1383           0 :     return 0;
    1384             : 
    1385             : #ifdef HAVE_W32_SYSTEM
    1386             :   InitializeCriticalSection (&cygwin_fdtable_cs);
    1387             : #endif
    1388             : 
    1389           2 :   err = assuan_new (&sock_ctx);
    1390             : 
    1391             : #ifdef HAVE_W32_SYSTEM
    1392             :   if (! err)
    1393             :     WSAStartup (0x202, &wsadat);
    1394             : #endif
    1395             : 
    1396           2 :   return err;
    1397             : }
    1398             : 
    1399             : 
    1400             : void
    1401           0 : assuan_sock_deinit ()
    1402             : {
    1403           0 :   if (sock_ctx == NULL)
    1404           0 :     return;
    1405             : 
    1406             : #ifdef HAVE_W32_SYSTEM
    1407             :   WSACleanup ();
    1408             : #endif
    1409             : 
    1410           0 :   assuan_release (sock_ctx);
    1411           0 :   sock_ctx = NULL;
    1412             : 
    1413             : #ifdef HAVE_W32_SYSTEM
    1414             :   DeleteCriticalSection (&cygwin_fdtable_cs);
    1415             : #endif
    1416             : }
    1417             : 
    1418             : 
    1419             : int
    1420           0 : assuan_sock_close (assuan_fd_t fd)
    1421             : {
    1422             : #ifdef HAVE_W32_SYSTEM
    1423             :   if (fd != ASSUAN_INVALID_FD)
    1424             :     delete_cygwin_fd (fd);
    1425             : #endif
    1426           0 :   return _assuan_close (sock_ctx, fd);
    1427             : }
    1428             : 
    1429             : assuan_fd_t
    1430           0 : assuan_sock_new (int domain, int type, int proto)
    1431             : {
    1432           0 :   return _assuan_sock_new (sock_ctx, domain, type, proto);
    1433             : }
    1434             : 
    1435             : int
    1436           0 : assuan_sock_set_flag (assuan_fd_t sockfd, const char *name, int value)
    1437             : {
    1438           0 :   return _assuan_sock_set_flag (sock_ctx, sockfd, name, value);
    1439             : }
    1440             : 
    1441             : int
    1442           0 : assuan_sock_get_flag (assuan_fd_t sockfd, const char *name, int *r_value)
    1443             : {
    1444           0 :   return _assuan_sock_get_flag (sock_ctx, sockfd, name, r_value);
    1445             : }
    1446             : 
    1447             : int
    1448           0 : assuan_sock_connect (assuan_fd_t sockfd, struct sockaddr *addr, int addrlen)
    1449             : {
    1450           0 :   return _assuan_sock_connect (sock_ctx, sockfd, addr, addrlen);
    1451             : }
    1452             : 
    1453             : assuan_fd_t
    1454           0 : assuan_sock_connect_byname (const char *host, unsigned short port,
    1455             :                             int reserved, const char *credentials,
    1456             :                             unsigned int flags)
    1457             : {
    1458           0 :   return _assuan_sock_connect_byname (sock_ctx,
    1459             :                                       host, port, reserved, credentials, flags);
    1460             : }
    1461             : 
    1462             : int
    1463           0 : assuan_sock_bind (assuan_fd_t sockfd, struct sockaddr *addr, int addrlen)
    1464             : {
    1465           0 :   return _assuan_sock_bind (sock_ctx, sockfd, addr, addrlen);
    1466             : }
    1467             : 
    1468             : int
    1469           0 : assuan_sock_set_sockaddr_un (const char *fname, struct sockaddr *addr,
    1470             :                              int *r_redirected)
    1471             : {
    1472           0 :   return _assuan_sock_set_sockaddr_un (fname, addr, r_redirected);
    1473             : }
    1474             : 
    1475             : int
    1476           0 : assuan_sock_get_nonce (struct sockaddr *addr, int addrlen,
    1477             :                        assuan_sock_nonce_t *nonce)
    1478             : {
    1479           0 :   return _assuan_sock_get_nonce (sock_ctx, addr, addrlen, nonce);
    1480             : }
    1481             : 
    1482             : int
    1483           0 : assuan_sock_check_nonce (assuan_fd_t fd, assuan_sock_nonce_t *nonce)
    1484             : {
    1485           0 :   return _assuan_sock_check_nonce (sock_ctx, fd, nonce);
    1486             : }

Generated by: LCOV version 1.11