src/misc.c

   1 /*
   2     Copyright (C) 2006-2018 Ben Kibbey <bjk@luxsci.net>
   3
   4     This file is part of libpwmd.
   5
   6     This library is free software; you can redistribute it and/or
   7     modify it under the terms of the GNU Lesser General Public
   8     License as published by the Free Software Foundation; either
   9     version 2.1 of the License, or (at your option) any later version.
  10
  11     This library is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14     Lesser General Public License for more details.
  15
  16     You should have received a copy of the GNU Lesser General Public
  17     License along with this library; if not, write to the Free Software
  18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
  19     USA
  20 */
  21 #ifdef HAVE_CONFIG_H
  22 #include <config.h>
  23 #endif
  24
  25 #ifdef HAVE_LIMITS_H
  26 #include <limits.h>
  27 #endif
  28
  29 #ifdef HAVE_STDLIB_H
  30 #include <stdlib.h>
  31 #endif
  32
  33 #include <stdio.h>
  34 #include <unistd.h>
  35 #include <string.h>
  36 #include <errno.h>
  37 #include <ctype.h>
  38 #include <fcntl.h>
  39
  40 #ifndef LINE_MAX
  41 #define LINE_MAX        2048
  42 #endif
  43
  44 #include <libpwmd.h>
  45 #include "misc.h"
  46
  47 #ifndef __MINGW32__
  48 #ifdef HAVE_GETPWUID_R
  49 char *
  50 _expand_homedir (char *str, struct passwd *pw)
  51 {
  52   char *p = str;
  53   char *pwbuf = NULL;
  54   char *result;
  55   struct passwd t;
  56
  57   if (!p)
  58     return NULL;
  59
  60   if (*p != '~' || *(p + 1) != '/')
  61     return pwmd_strdup (p);
  62
  63   if (!pw)
  64     {
  65       pwbuf = _getpwuid (&t);
  66       if (!pwbuf)
  67         return NULL;
  68
  69       pw = &t;
  70     }
  71
  72   p += 2;
  73   result = pwmd_strdup_printf ("%s/%s", pw->pw_dir, p);
  74   pwmd_free (pwbuf);
  75   return result;
  76 }
  77
  78 char *
  79 _getpwuid (struct passwd *pwd)
  80 {
  81   size_t size = sysconf (_SC_GETPW_R_SIZE_MAX);
  82   struct passwd *result;
  83   char *buf;
  84   int n;
  85
  86   if (size == -1)
  87     size = 16384;
  88
  89   buf = pwmd_malloc (size);
  90   if (!buf)
  91     return NULL;
  92
  93   n = getpwuid_r (getuid (), pwd, buf, size, &result);
  94   if (n)
  95     {
  96       pwmd_free (buf);
  97       errno = n;
  98       return NULL;
  99     }
 100
 101   if (!result)
 102     {
 103       pwmd_free (buf);
 104       return NULL;
 105     }
 106
 107   errno = n;
 108   return buf;
 109 }
 110 #else
 111 char *
 112 _expand_homedir (char *str, struct passwd *pw)
 113 {
 114   char *p = str;
 115
 116   if (!p)
 117     return NULL;
 118
 119   if (*p != '~' || *(p + 1) != '/')
 120     return pwmd_strdup (p);
 121
 122   if (!pw)
 123     {
 124       pw = getpwuid (getuid ());
 125       if (!pw)
 126         return NULL;
 127     }
 128
 129   p += 2;
 130   return pwmd_strdup_printf ("%s/%s", pw->pw_dir, p);
 131 }
 132
 133 char *
 134 _getpwuid (struct passwd *pwd)
 135 {
 136   struct passwd *pw = getpwuid (getuid ());
 137
 138   if (!pw)
 139     return NULL;
 140
 141   *pwd = *pw;
 142   return pwmd_strdup ("");
 143 }
 144 #endif
 145 #endif
 146
 147 /*
 148  * Borrowed from libassuan.
 149  */
 150 char *
 151 _percent_escape (const char *atext)
 152 {
 153   const unsigned char *s;
 154   int len;
 155   char *buf, *p;
 156
 157   if (!atext)
 158     return NULL;
 159
 160   len = strlen (atext) * 3 + 1;
 161   buf = (char *) pwmd_malloc (len);
 162
 163   if (!buf)
 164     return NULL;
 165
 166   p = buf;
 167
 168   for (s = (const unsigned char *) atext; *s; s++)
 169     {
 170       if (*s < ' ')
 171         {
 172           sprintf (p, "%%%02X", *s);
 173           p += 3;
 174         }
 175       else
 176         *p++ = *s;
 177     }
 178
 179   *p = 0;
 180   return buf;
 181 }
 182
 183 /* Common hostname parsing for urls. Handles both IPv4 and IPv6 hostname and
 184  * port specification.
 185  */
 186 gpg_error_t
 187 parse_hostname_common (const char *str, char **host, int *port)
 188 {
 189   const char *p = str;
 190   char *t = NULL;
 191
 192   /* IPv6 with optional port. */
 193   if (*p == '[')
 194     {
 195       p++;
 196       t = strchr (p, ']');
 197     }
 198   else
 199     {
 200       int n = 0;
 201       const char *x;
 202
 203       /* Handle IPv6 without proper braces around the IP. */
 204       for (x = p; *x; x++)
 205         {
 206           if (*x == ':')
 207             n++;
 208         }
 209
 210       if (n <= 1)
 211         t = strchr (p, ':');
 212     }
 213
 214   if (t)
 215     {
 216       size_t len = strlen (p) - strlen (t) + 1;
 217
 218       *host = pwmd_malloc (len);
 219       if (!*host)
 220         return gpg_error_from_errno (ENOMEM);
 221
 222       snprintf (*host, len, "%s", p);
 223       t++;
 224
 225       if (*t == ':')
 226         t++;
 227
 228       if (*t)
 229         *port = strtol (t, NULL, 10);
 230
 231       if (*t == '-')
 232         t++;
 233
 234       while (*t && isdigit (*t))
 235         t++;
 236     }
 237   else
 238     {
 239       *host = pwmd_strdup (str);
 240       if (!*host)
 241         return gpg_error_from_errno (ENOMEM);
 242     }
 243
 244   return 0;
 245 }
 246
 247 char *
 248 bin2hex (const unsigned char *data, size_t len)
 249 {
 250   size_t size = len * 2 + 1;
 251   char buf[size]; // C99
 252   size_t n;
 253
 254   buf[0] = 0;
 255
 256   for (n = 0; n < len; n++)
 257     {
 258       char c[3];
 259
 260       sprintf (c, "%02X", data[n]);
 261       strcat (buf, c);
 262     }
 263
 264   return pwmd_strdup (buf);
 265 }
 266
 267 gpg_error_t
 268 set_non_blocking (assuan_fd_t fd, int n)
 269 {
 270 #ifdef __MINGW32__
 271   unsigned long opt = !!n;
 272
 273   if (ioctlsocket (HANDLE2SOCKET (fd), FIONBIO, &opt) != NO_ERROR)
 274     return gpg_error_from_syserror ();
 275 #else
 276   int flags = fcntl (fd, F_GETFL);
 277
 278   if (!n)
 279     flags &= ~O_NONBLOCK;
 280   else
 281     flags |= O_NONBLOCK;
 282
 283   if (fcntl (fd, F_SETFL, flags) == -1)
 284     return gpg_error_from_syserror ();
 285 #endif
 286
 287   return 0;
 288 }