src/misc.c

   1 /* vim:tw=78:ts=8:sw=4:set ft=c:  */
   2 /*
   3     Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012
   4     Ben Kibbey <bjk@luxsci.net>
   5
   6     This file is part of libpwmd.
   7
   8     Libpwmd is free software: you can redistribute it and/or modify
   9     it under the terms of the GNU General Public License as published by
  10     the Free Software Foundation, either version 2 of the License, or
  11     (at your option) any later version.
  12
  13     Libpwmd is distributed in the hope that it will be useful,
  14     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16     GNU General Public License for more details.
  17
  18     You should have received a copy of the GNU General Public License
  19     along with Libpwmd.  If not, see <http://www.gnu.org/licenses/>.
  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
  39 #ifndef LINE_MAX
  40 #define LINE_MAX        2048
  41 #endif
  42
  43 #include <libpwmd.h>
  44 #include "misc.h"
  45
  46 #ifdef HAVE_GETPWUID_R
  47 char *_expand_homedir(char *str, struct passwd *pw)
  48 {
  49     char *p = str;
  50     char *pwbuf = NULL;
  51     char *result;
  52
  53     if (!p)
  54         return NULL;
  55
  56     if (*p != '~' || *(p+1) != '/')
  57         return pwmd_strdup(p);
  58
  59     if (!pw) {
  60         struct passwd t;
  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
  72     if (pwbuf)
  73         pwmd_free(pwbuf);
  74
  75     return result;
  76 }
  77
  78 char *_getpwuid(struct passwd *pwd)
  79 {
  80     size_t size = sysconf(_SC_GETPW_R_SIZE_MAX);
  81     struct passwd *result;
  82     char *buf;
  83     int n;
  84
  85     if (size == -1)
  86         size = 16384;
  87
  88     buf = pwmd_malloc(size);
  89     if (!buf)
  90         return NULL;
  91
  92     n = getpwuid_r(getuid(), pwd, buf, size, &result);
  93     if (n) {
  94         pwmd_free(buf);
  95         errno = n;
  96         return NULL;
  97     }
  98
  99     if (!result) {
 100         pwmd_free(buf);
 101         return NULL;
 102     }
 103
 104     errno = n;
 105     return buf;
 106 }
 107 #else
 108 char *_expand_homedir(char *str, struct passwd *pw)
 109 {
 110     char *p = str;
 111
 112     if (!p)
 113         return NULL;
 114
 115     if (*p != '~' || *(p+1) != '/')
 116         return pwmd_strdup(p);
 117
 118     if (!pw) {
 119         pw = getpwuid(getuid());
 120         if (!pw)
 121             return NULL;
 122     }
 123
 124     p += 2;
 125     return pwmd_strdup_printf("%s/%s", pw->pw_dir, p);
 126 }
 127
 128 char *_getpwuid(struct passwd *pwd)
 129 {
 130     struct passwd *pw = getpwuid(getuid());
 131
 132     if (!pw)
 133         return NULL;
 134
 135     *pwd = *pw;
 136     return pwmd_strdup("");
 137 }
 138 #endif
 139
 140 /*
 141  * Borrowed from libassuan.
 142  */
 143 char *_percent_escape(const char *atext)
 144 {
 145     const unsigned char *s;
 146     int len;
 147     char *buf, *p;
 148
 149     if (!atext)
 150         return NULL;
 151
 152     len = strlen(atext) * 3 + 1;
 153     buf = (char *)pwmd_malloc(len);
 154
 155     if (!buf)
 156         return NULL;
 157
 158     p = buf;
 159
 160     for (s=(const unsigned char *)atext; *s; s++) {
 161         if (*s < ' ') {
 162             sprintf (p, "%%%02X", *s);
 163             p += 3;
 164         }
 165         else
 166             *p++ = *s;
 167     }
 168
 169     *p = 0;
 170     return buf;
 171 }
 172
 173 void update_pinentry_settings(pwm_t *pwm)
 174 {
 175     FILE *fp;
 176     char buf[LINE_MAX];
 177     char *p;
 178     struct passwd pw;
 179     char *pwbuf = _getpwuid(&pw);
 180
 181     if (!pwbuf)
 182         return;
 183
 184     snprintf(buf, sizeof(buf), "%s/.pwmd/pinentry.conf", pw.pw_dir);
 185
 186     if ((fp = fopen(buf, "r")) == NULL) {
 187         pwmd_free(pwbuf);
 188         return;
 189     }
 190
 191     while ((p = fgets(buf, sizeof(buf), fp)) != NULL) {
 192         char name[32], val[256];
 193
 194         if (sscanf(p, " %32[a-zA-Z] = %256s", name, val) != 2)
 195             continue;
 196
 197         if (strcasecmp(name, "TTYNAME") == 0) {
 198             pwmd_free(pwm->pinentry_tty);
 199             pwm->pinentry_tty = pwmd_strdup(val);
 200             if (!pwm->pinentry_tty)
 201                 goto fail;
 202         }
 203         else if (strcasecmp(name, "TTYTYPE") == 0) {
 204             pwmd_free(pwm->pinentry_term);
 205             pwm->pinentry_term = pwmd_strdup(val);
 206             if (!pwm->pinentry_term)
 207                 goto fail;
 208         }
 209         else if (strcasecmp(name, "DISPLAY") == 0) {
 210             pwmd_free(pwm->pinentry_display);
 211             pwm->pinentry_display = pwmd_strdup(val);
 212             if (!pwm->pinentry_display)
 213                 goto fail;
 214         }
 215         else if (strcasecmp(name, "PATH") == 0) {
 216             pwmd_free(pwm->pinentry_path);
 217             pwm->pinentry_path = _expand_homedir(val, &pw);
 218             if (!pwm->pinentry_path)
 219                 goto fail;
 220         }
 221         else if (strcasecmp(name, "LC_MESSAGES") == 0) {
 222             pwmd_free(pwm->pinentry_lcmessages);
 223             pwm->pinentry_lcmessages = pwmd_strdup(val);
 224             if (!pwm->pinentry_lcmessages)
 225                 goto fail;
 226         }
 227         else if (strcasecmp(name, "LC_CTYPE") == 0) {
 228             pwmd_free(pwm->pinentry_lcctype);
 229             pwm->pinentry_lcctype = pwmd_strdup(val);
 230             if (!pwm->pinentry_lcctype)
 231                 goto fail;
 232         }
 233     }
 234
 235 fail:
 236     pwmd_free(pwbuf);
 237     fclose(fp);
 238 }
 239
 240 /* Common hostname parsing for urls. Handles both IPv4 and IPv6 hostname and
 241  * port specification.
 242  */
 243 gpg_error_t parse_hostname_common(const char *str, char **host, int *port)
 244 {
 245     const char *p = str;
 246     char *t = NULL;
 247     size_t len;
 248
 249     /* IPv6 with optional port. */
 250     if (*p == '[') {
 251         p++;
 252         t = strchr(p, ']');
 253     }
 254     else {
 255         int n = 0;
 256         const char *x;
 257
 258         /* Handle IPv6 without proper braces around the IP. */
 259         for (x = p; *x; x++) {
 260             if (*x == ':')
 261                 n++;
 262         }
 263
 264         if (n <= 1)
 265             t = strchr(p, ':');
 266     }
 267
 268     if (t) {
 269         len = strlen(p)-strlen(t)+1;
 270         *host = pwmd_malloc(len);
 271         if (!*host)
 272             return gpg_error_from_errno(ENOMEM);
 273
 274         snprintf(*host, len, "%s", p);
 275         t++;
 276
 277         if (*t == ':')
 278             t++;
 279
 280         if (*t)
 281             *port = strtol(t, NULL, 10);
 282
 283         if (*t == '-')
 284             t++;
 285
 286         while (*t && isdigit(*t))
 287             t++;
 288
 289         p = t;
 290     }
 291     else {
 292         *host = pwmd_strdup(str);
 293         if (!*host)
 294             return gpg_error_from_errno(ENOMEM);
 295     }
 296
 297     return 0;
 298 }