lib/system.c

   1 /*
   2  * Copyright (C) 2010-2012 Free Software Foundation, Inc.
   3  *
   4  * Author: Nikos Mavrogiannopoulos
   5  *
   6  * This file is part of GnuTLS.
   7  *
   8  * The GnuTLS is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public License
  10  * as published by the Free Software Foundation; either version 3 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public License
  19  * along with this program.  If not, see <http://www.gnu.org/licenses/>
  20  *
  21  */
  22
  23 #include <system.h>
  24 #include <gnutls_int.h>
  25 #include <gnutls_errors.h>
  26
  27 #include <errno.h>
  28 #include <sys/stat.h>
  29 #include <sys/types.h>
  30
  31 #ifdef _WIN32
  32 # include <windows.h>
  33
  34 #else
  35 # ifdef HAVE_PTHREAD_LOCKS
  36 #  include <pthread.h>
  37 # endif
  38
  39 # if defined(HAVE_GETPWUID_R)
  40 #  include <pwd.h>
  41 # endif
  42 #endif
  43
  44 /* We need to disable gnulib's replacement wrappers to get native
  45    Windows interfaces. */
  46 #undef recv
  47 #undef send
  48 #undef select
  49
  50 /* System specific function wrappers.
  51  */
  52
  53 /* wrappers for write() and writev()
  54  */
  55 #ifdef _WIN32
  56
  57 int
  58 system_errno (gnutls_transport_ptr p)
  59 {
  60   int tmperr = WSAGetLastError ();
  61   int ret = 0;
  62   switch (tmperr)
  63     {
  64     case WSAEWOULDBLOCK:
  65       ret = EAGAIN;
  66       break;
  67     case NO_ERROR:
  68       ret = 0;
  69       break;
  70     case WSAEINTR:
  71       ret = EINTR;
  72       break;
  73     case WSAEMSGSIZE:
  74       ret = EMSGSIZE;
  75       break;
  76     default:
  77       ret = EIO;
  78       break;
  79     }
  80   WSASetLastError (tmperr);
  81
  82   return ret;
  83 }
  84
  85 ssize_t
  86 system_write (gnutls_transport_ptr ptr, const void *data, size_t data_size)
  87 {
  88   return send (GNUTLS_POINTER_TO_INT (ptr), data, data_size, 0);
  89 }
  90 #else /* POSIX */
  91 int
  92 system_errno (gnutls_transport_ptr_t ptr)
  93 {
  94 #if defined(_AIX) || defined(AIX)
  95   if (errno == 0) errno = EAGAIN;
  96 #endif
  97
  98   return errno;
  99 }
 100
 101 ssize_t
 102 system_writev (gnutls_transport_ptr_t ptr, const giovec_t * iovec,
 103                int iovec_cnt)
 104 {
 105   return writev (GNUTLS_POINTER_TO_INT (ptr), (struct iovec *) iovec,
 106                  iovec_cnt);
 107
 108 }
 109 #endif
 110
 111 ssize_t
 112 system_read (gnutls_transport_ptr_t ptr, void *data, size_t data_size)
 113 {
 114   return recv (GNUTLS_POINTER_TO_INT (ptr), data, data_size, 0);
 115 }
 116
 117 /* Wait for data to be received within a timeout period in milliseconds.
 118  * To catch a termination it will also try to receive 0 bytes from the
 119  * socket if select reports to proceed.
 120  *
 121  * Returns -1 on error, 0 on timeout, positive value if data are available for reading.
 122  */
 123 int system_recv_timeout(gnutls_transport_ptr_t ptr, unsigned int ms)
 124 {
 125 fd_set rfds;
 126 struct timeval tv;
 127 int ret, ret2;
 128 int fd = GNUTLS_POINTER_TO_INT(ptr);
 129
 130   FD_ZERO(&rfds);
 131   FD_SET(fd, &rfds);
 132
 133   tv.tv_sec = 0;
 134   tv.tv_usec = ms * 1000;
 135
 136   while(tv.tv_usec >= 1000000)
 137     {
 138       tv.tv_usec -= 1000000;
 139       tv.tv_sec++;
 140     }
 141
 142   ret = select(fd+1, &rfds, NULL, NULL, &tv);
 143   if (ret <= 0)
 144     return ret;
 145
 146   ret2 = recv(fd, NULL, 0, MSG_PEEK);
 147   if (ret2 == -1)
 148     return ret2;
 149
 150   return ret;
 151 }
 152
 153 /* Thread stuff */
 154
 155 #ifdef HAVE_WIN32_LOCKS
 156
 157
 158 /* FIXME: win32 locks are untested */
 159 static int
 160 gnutls_system_mutex_init (void **priv)
 161 {
 162   CRITICAL_SECTION *lock = malloc (sizeof (CRITICAL_SECTION));
 163
 164   if (lock == NULL)
 165     return GNUTLS_E_MEMORY_ERROR;
 166
 167   InitializeCriticalSection (lock);
 168
 169   *priv = lock;
 170
 171   return 0;
 172 }
 173
 174 static int
 175 gnutls_system_mutex_deinit (void **priv)
 176 {
 177   DeleteCriticalSection ((CRITICAL_SECTION *) * priv);
 178   free (*priv);
 179
 180   return 0;
 181 }
 182
 183 static int
 184 gnutls_system_mutex_lock (void **priv)
 185 {
 186   EnterCriticalSection ((CRITICAL_SECTION *) * priv);
 187   return 0;
 188 }
 189
 190 static int
 191 gnutls_system_mutex_unlock (void **priv)
 192 {
 193   LeaveCriticalSection ((CRITICAL_SECTION *) * priv);
 194   return 0;
 195 }
 196
 197 #endif /* WIN32_LOCKS */
 198
 199 #ifdef HAVE_PTHREAD_LOCKS
 200
 201 static int
 202 gnutls_system_mutex_init (void **priv)
 203 {
 204   pthread_mutex_t *lock = malloc (sizeof (pthread_mutex_t));
 205   int ret;
 206
 207   if (lock == NULL)
 208     return GNUTLS_E_MEMORY_ERROR;
 209
 210   ret = pthread_mutex_init (lock, NULL);
 211   if (ret)
 212     {
 213       free (lock);
 214       gnutls_assert ();
 215       return GNUTLS_E_LOCKING_ERROR;
 216     }
 217
 218   *priv = lock;
 219
 220   return 0;
 221 }
 222
 223 static int
 224 gnutls_system_mutex_deinit (void **priv)
 225 {
 226   pthread_mutex_destroy ((pthread_mutex_t *) * priv);
 227   free (*priv);
 228   return 0;
 229 }
 230
 231 static int
 232 gnutls_system_mutex_lock (void **priv)
 233 {
 234   if (pthread_mutex_lock ((pthread_mutex_t *) * priv))
 235     {
 236       gnutls_assert ();
 237       return GNUTLS_E_LOCKING_ERROR;
 238     }
 239
 240   return 0;
 241 }
 242
 243 static int
 244 gnutls_system_mutex_unlock (void **priv)
 245 {
 246   if (pthread_mutex_unlock ((pthread_mutex_t *) * priv))
 247     {
 248       gnutls_assert ();
 249       return GNUTLS_E_LOCKING_ERROR;
 250     }
 251
 252   return 0;
 253 }
 254
 255 #endif /* PTHREAD_LOCKS */
 256
 257 #ifdef HAVE_NO_LOCKS
 258
 259 static int
 260 gnutls_system_mutex_init (void **priv)
 261 {
 262   return 0;
 263 }
 264
 265 static int
 266 gnutls_system_mutex_deinit (void **priv)
 267 {
 268   return 0;
 269 }
 270
 271 static int
 272 gnutls_system_mutex_lock (void **priv)
 273 {
 274   return 0;
 275 }
 276
 277 static int
 278 gnutls_system_mutex_unlock (void **priv)
 279 {
 280   return 0;
 281 }
 282
 283 #endif /* NO_LOCKS */
 284
 285 gnutls_time_func gnutls_time = time;
 286 mutex_init_func gnutls_mutex_init = gnutls_system_mutex_init;
 287 mutex_deinit_func gnutls_mutex_deinit = gnutls_system_mutex_deinit;
 288 mutex_lock_func gnutls_mutex_lock = gnutls_system_mutex_lock;
 289 mutex_unlock_func gnutls_mutex_unlock = gnutls_system_mutex_unlock;
 290
 291 #define CONFIG_PATH ".gnutls"
 292
 293 /* Returns a path to store user-specific configuration
 294  * data.
 295  */
 296 int _gnutls_find_config_path(char* path, size_t max_size)
 297 {
 298 char tmp_home_dir[1024];
 299 const char *home_dir = getenv ("HOME");
 300
 301 #ifdef _WIN32
 302   if (home_dir == NULL || home_dir[0] == '\0')
 303     {
 304       const char *home_drive = getenv ("HOMEDRIVE");
 305       const char *home_path = getenv ("HOMEPATH");
 306
 307       if (home_drive != NULL && home_path != NULL)
 308         {
 309           snprintf(tmp_home_dir, sizeof(tmp_home_dir), "%s%s", home_drive, home_path);
 310         }
 311       else
 312         {
 313           tmp_home_dir[0] = 0;
 314         }
 315
 316       home_dir = tmp_home_dir;
 317     }
 318 #elif defined(HAVE_GETPWUID_R)
 319   if (home_dir == NULL || home_dir[0] == '\0')
 320     {
 321       struct passwd *pwd;
 322       struct passwd _pwd;
 323       char buf[1024];
 324
 325       getpwuid_r(getuid(), &_pwd, buf, sizeof(buf), &pwd);
 326       if (pwd != NULL)
 327         {
 328           snprintf(tmp_home_dir, sizeof(tmp_home_dir), "%s", pwd->pw_dir);
 329         }
 330       else
 331         {
 332           tmp_home_dir[0] = 0;
 333         }
 334
 335       home_dir = tmp_home_dir;
 336     }
 337 #else
 338   if (home_dir == NULL || home_dir[0] == '\0')
 339     {
 340       tmp_home_dir[0] = 0;
 341       home_dir = tmp_home_dir;
 342     }
 343 #endif
 344
 345   if (home_dir == NULL || home_dir[0] == 0)
 346     path[0] = 0;
 347   else
 348     snprintf(path, max_size, "%s/"CONFIG_PATH, home_dir);
 349
 350   return 0;
 351 }