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 void
 180 update_pinentry_settings (pwm_t * pwm)
 181 {
 182   FILE *fp;
 183   char buf[LINE_MAX];
 184   char *p;
 185   struct passwd pw;
 186   char *pwbuf = _getpwuid (&pw);
 187
 188   if (!pwbuf)
 189     return;
 190
 191   snprintf (buf, sizeof (buf), "%s/.pwmd/pinentry.conf", pw.pw_dir);
 192
 193   if ((fp = fopen (buf, "r")) == NULL)
 194     {
 195       pwmd_free (pwbuf);
 196       return;
 197     }
 198
 199   while ((p = fgets (buf, sizeof (buf), fp)) != NULL)
 200     {
 201       char name[32] = {0}, val[256] = {0};
 202
 203       if (sscanf (p, " %31[a-zA-Z] = %255s", name, val) != 2)
 204         continue;
 205
 206       if (strcasecmp (name, "TTYNAME") == 0)
 207         {
 208           pwmd_free (pwm->pinentry_tty);
 209           pwm->pinentry_tty = pwmd_strdup (val);
 210           if (!pwm->pinentry_tty)
 211             goto fail;
 212         }
 213       else if (strcasecmp (name, "TTYTYPE") == 0)
 214         {
 215           pwmd_free (pwm->pinentry_term);
 216           pwm->pinentry_term = pwmd_strdup (val);
 217           if (!pwm->pinentry_term)
 218             goto fail;
 219         }
 220       else if (strcasecmp (name, "DISPLAY") == 0)
 221         {
 222           pwmd_free (pwm->pinentry_display);
 223           pwm->pinentry_display = pwmd_strdup (val);
 224           if (!pwm->pinentry_display)
 225             goto fail;
 226         }
 227       else if (strcasecmp (name, "PATH") == 0)
 228         {
 229           pwmd_free (pwm->pinentry_path);
 230           pwm->pinentry_path = _expand_homedir (val, &pw);
 231           if (!pwm->pinentry_path)
 232             goto fail;
 233         }
 234       else if (strcasecmp (name, "LC_MESSAGES") == 0)
 235         {
 236           pwmd_free (pwm->pinentry_lcmessages);
 237           pwm->pinentry_lcmessages = pwmd_strdup (val);
 238           if (!pwm->pinentry_lcmessages)
 239             goto fail;
 240         }
 241       else if (strcasecmp (name, "LC_CTYPE") == 0)
 242         {
 243           pwmd_free (pwm->pinentry_lcctype);
 244           pwm->pinentry_lcctype = pwmd_strdup (val);
 245           if (!pwm->pinentry_lcctype)
 246             goto fail;
 247         }
 248     }
 249
 250 fail:
 251   pwmd_free (pwbuf);
 252   fclose (fp);
 253 }
 254
 255 /* Common hostname parsing for urls. Handles both IPv4 and IPv6 hostname and
 256  * port specification.
 257  */
 258 gpg_error_t
 259 parse_hostname_common (const char *str, char **host, int *port)
 260 {
 261   const char *p = str;
 262   char *t = NULL;
 263
 264   /* IPv6 with optional port. */
 265   if (*p == '[')
 266     {
 267       p++;
 268       t = strchr (p, ']');
 269     }
 270   else
 271     {
 272       int n = 0;
 273       const char *x;
 274
 275       /* Handle IPv6 without proper braces around the IP. */
 276       for (x = p; *x; x++)
 277         {
 278           if (*x == ':')
 279             n++;
 280         }
 281
 282       if (n <= 1)
 283         t = strchr (p, ':');
 284     }
 285
 286   if (t)
 287     {
 288       size_t len = strlen (p) - strlen (t) + 1;
 289
 290       *host = pwmd_malloc (len);
 291       if (!*host)
 292         return gpg_error_from_errno (ENOMEM);
 293
 294       snprintf (*host, len, "%s", p);
 295       t++;
 296
 297       if (*t == ':')
 298         t++;
 299
 300       if (*t)
 301         *port = strtol (t, NULL, 10);
 302
 303       if (*t == '-')
 304         t++;
 305
 306       while (*t && isdigit (*t))
 307         t++;
 308
 309       p = t;
 310     }
 311   else
 312     {
 313       *host = pwmd_strdup (str);
 314       if (!*host)
 315         return gpg_error_from_errno (ENOMEM);
 316     }
 317
 318   return 0;
 319 }
 320
 321 char *
 322 bin2hex (const unsigned char *data, size_t len)
 323 {
 324   size_t size = len * 2 + 1;
 325   char buf[size]; // C99
 326   size_t n;
 327
 328   buf[0] = 0;
 329
 330   for (n = 0; n < len; n++)
 331     {
 332       char c[3];
 333
 334       sprintf (c, "%02X", data[n]);
 335       strcat (buf, c);
 336     }
 337
 338   return pwmd_strdup (buf);
 339 }