src/misc.c

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