src/util-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 pwmd.
   6
   7     Pwmd 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     Pwmd 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 Pwmd.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20 #ifdef HAVE_CONFIG_H
  21 #include <config.h>
  22 #endif
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <errno.h>
  27 #include <unistd.h>
  28 #include <sys/types.h>
  29 #include <sys/stat.h>
  30 #include <fcntl.h>
  31 #include <string.h>
  32 #include <ctype.h>
  33 #include <pwd.h>
  34
  35 #include "pwmd-error.h"
  36 #include <gcrypt.h>
  37 #include "util-misc.h"
  38 #include "util-string.h"
  39 #include "mutex.h"
  40 #include "cache.h"
  41 #include "mem.h"
  42
  43 extern void log_write (const char *fmt, ...);
  44
  45 int
  46 valid_filename (const char *filename)
  47 {
  48   const char *p;
  49
  50   if (!filename || !*filename)
  51     return 0;
  52
  53   if (filename[0] == '-' && filename[1] == 0)
  54     return 0;
  55
  56   for (p = filename; *p; p++)
  57     {
  58       if (*p == '/' || isspace (*p))
  59         return 0;
  60     }
  61
  62   return 1;
  63 }
  64
  65 /* If 'user' is null then lookup entry for 'uid'. Caller must free 'buf'. */
  66 struct passwd *
  67 get_pwd_struct (const char *user, uid_t uid, struct passwd *pw, char **buf)
  68 {
  69 #ifdef HAVE_GETPWNAM_R
  70   struct passwd *result;
  71   size_t len;
  72
  73   len = sysconf (_SC_GETPW_R_SIZE_MAX);
  74   if (len == -1)
  75     len = 16384;
  76
  77   *buf = xmalloc (len);
  78   if (!*buf)
  79     return NULL;
  80
  81   if (user)
  82     {
  83       if (!getpwnam_r (user, pw, *buf, len, &result))
  84         return result;
  85     }
  86   else
  87     {
  88       if (!getpwuid_r (uid, pw, *buf, len, &result))
  89         return result;
  90     }
  91
  92   return NULL;
  93 #else
  94   if (buf)
  95     *buf = NULL;
  96
  97   if (user)
  98     return getpwnam (user);
  99
 100   return getpwuid (uid);
 101 #endif
 102 }
 103
 104 static char *
 105 get_pwd_entry(uid_t uid, int which)
 106 {
 107   char *buf;
 108   struct passwd pw;
 109   struct passwd *result = get_pwd_struct (NULL, uid, &pw, &buf);
 110   char *value = NULL;
 111
 112   if (!result)
 113     return NULL;
 114
 115   if (result)
 116     {
 117       if (!which)
 118         value = str_dup (result->pw_dir);
 119       else
 120         value = str_dup (result->pw_name);
 121     }
 122
 123   xfree (buf);
 124   return value;
 125 }
 126
 127 char *
 128 get_username (uid_t uid)
 129 {
 130   return get_pwd_entry (uid, 1);
 131 }
 132
 133 char *
 134 get_home_dir ()
 135 {
 136   if (home_directory)
 137     return home_directory;
 138
 139   home_directory = get_pwd_entry (getuid(), 0);
 140   return home_directory;
 141 }
 142
 143 char *
 144 expand_homedir (char *str)
 145 {
 146   char *p = str;
 147
 148   if (*p++ == '~')
 149     {
 150       char *dir = get_pwd_entry(getuid(), 0);
 151       char *s = str_asprintf ("%s%s", dir, p);
 152
 153       xfree (dir);
 154       return s;
 155     }
 156
 157   return str_dup (str);
 158 }
 159
 160 gpg_error_t
 161 parse_options (char **line, struct argv_s * args[], void *data)
 162 {
 163   char *p = *line;
 164   gpg_error_t rc = 0;
 165
 166   for (; p && *p; p++)
 167     {
 168       while (*p == ' ')
 169         p++;
 170
 171       if (!*p)
 172         break;
 173
 174       if (*p == '-' && *(p + 1) == '-')
 175         {
 176           p += 2;
 177           char opt[255] = { 0 }, value[255] =
 178           {
 179           0};
 180           char *tp;
 181           unsigned len;
 182
 183           if (!*p || *p == ' ')
 184             {
 185               if (*p)
 186                 p++;
 187
 188               break;
 189             }
 190
 191           for (tp = opt, len = 0; *p; p++, len++)
 192             {
 193               if (len + 1 == 255)
 194                 return GPG_ERR_LINE_TOO_LONG;
 195
 196               if (*p == ' ' || *p == '=')
 197                 {
 198                   *tp = 0;
 199
 200                   if (*p == '=')
 201                     {
 202                       int inquote = 0;
 203
 204                       p++;
 205
 206                       for (tp = value, len = 0; *p; p++, len++)
 207                         {
 208                           if (len + 1 == 255)
 209                             return GPG_ERR_LINE_TOO_LONG;
 210
 211                           if (*p == '\"')
 212                             {
 213                               inquote = !inquote;
 214                               continue;
 215                             }
 216                           else if (*p == ' ' && !inquote)
 217                             break;
 218
 219                           *tp++ = *p;
 220                         }
 221
 222                       *tp = 0;
 223                     }
 224
 225                   break;
 226                 }
 227
 228               *tp++ = *p;
 229             }
 230
 231           *tp = 0;
 232           int match = 0;
 233
 234           for (int i = 0; args[i]; i++)
 235             {
 236               if (!strcmp (args[i]->opt, opt))
 237                 {
 238                   log_write1 ("param: name='%s' value='%s'", opt, value);
 239                   if (args[i]->type == OPTION_TYPE_NOARG && *value)
 240                     return GPG_ERR_SYNTAX;
 241                   else if (args[i]->type == OPTION_TYPE_ARG && !*value)
 242                     return GPG_ERR_SYNTAX;
 243
 244                   rc = args[i]->func (data, value);
 245
 246                   if (rc)
 247                     return rc;
 248
 249                   match = 1;
 250                   break;
 251                 }
 252             }
 253
 254           if (!match)
 255             return GPG_ERR_UNKNOWN_OPTION;
 256
 257           if (!*p)
 258             break;
 259
 260           continue;
 261         }
 262
 263       break;
 264     }
 265
 266   *line = p;
 267   return rc;
 268 }
 269
 270 char *
 271 bin2hex (const unsigned char *data, size_t len)
 272 {
 273   size_t size = len * 2 + 1;
 274   char buf[size];
 275   size_t n;
 276
 277   buf[0] = 0;
 278
 279   for (n = 0; n < len; n++)
 280     {
 281       char c[3];
 282
 283       sprintf (c, "%02X", data[n]);
 284       strcat (buf, c);
 285     }
 286
 287   return str_dup (buf);
 288 }
 289
 290 char *
 291 plus_escape (const char *fmt, ...)
 292 {
 293   va_list ap;
 294   char *str;
 295
 296   va_start (ap, fmt);
 297
 298   if (str_vasprintf (&str, fmt, ap) > 0)
 299     {
 300       char *p;
 301
 302       for (p = str; *p; p++)
 303         {
 304           if (*p == ' ')
 305             *p = '+';
 306         }
 307
 308       va_end (ap);
 309       return str;
 310     }
 311
 312   va_end (ap);
 313   return NULL;
 314 }
 315
 316 static char *
 317 strip_texi (const char *str)
 318 {
 319   const char *p;
 320   char *s = str_dup (str);
 321   int c = 0;
 322
 323   if (!s)
 324     return NULL;
 325
 326   for (p = str; *p; p++)
 327     {
 328       if (*p == '@' && *(p + 1) != '@')
 329         {
 330           if (!strncasecmp (p + 1, "table", 5)
 331               || !strncasecmp (p + 1, "end ", 4))
 332             {
 333               while (*p++ != '\n');
 334               p--;
 335               continue;
 336             }
 337           else if (!strncasecmp (p + 1, "example", 7)
 338                    || !strncasecmp (p + 1, "end ", 4))
 339             {
 340               while (*p++ != '\n');
 341               p--;
 342               continue;
 343             }
 344           else if (!strncasecmp (p + 1, "sp ", 3))
 345             {
 346               p += 3;
 347
 348               while (*p && isdigit (*p++))
 349                 p++;
 350               continue;
 351             }
 352           else if (!strncasecmp (p + 1, "item", 4))
 353             {
 354               p += 5;
 355               while (*p && *p != '\n')
 356                 s[c++] = *p++;
 357
 358               continue;
 359             }
 360           else if (!strncasecmp (p + 1, "pxref", 5))
 361             {
 362               p += 6;
 363               strcat (s, "see ");
 364               c = strlen (s);
 365               goto close;
 366             }
 367           else if (!strncasecmp (p + 1, "xref", 4))
 368             {
 369               p += 5;
 370               strcat (s, "See ");
 371               c = strlen (s);
 372               goto close;
 373             }
 374
 375           while (*p && *p != '{')
 376             {
 377               if (*++p == '*')
 378                 {
 379                   p++;
 380                   goto append;
 381                 }
 382             }
 383
 384         close:
 385           if (*p)
 386             {
 387               p++;
 388               s[c++] = '`';
 389               while (*p && *p != '}')
 390                 s[c++] = *p++;
 391
 392               if (*p)
 393                 p++;
 394
 395               s[c++] = '\'';
 396             }
 397         }
 398       else if (*p == '@' && *(p + 1) == '@')
 399         p++;
 400
 401     append:
 402       if (*p)
 403         s[c++] = *p;
 404
 405       s[c] = 0;
 406     }
 407
 408   s[c] = 0;
 409   return s;
 410 }
 411
 412
 413 char *
 414 strip_texi_and_wrap (const char *str)
 415 {
 416   char *tmp = strip_texi (str);
 417   char *help = xmalloc (strlen (tmp) * 2 + 1);
 418   char *p, *ph;
 419   int i;
 420
 421   for (p = tmp, ph = help, i = 0; *p; p++, i++)
 422     {
 423       if (i == 78 || *p == '\n')
 424         {
 425           if (!isspace (*p))
 426             {
 427               char *t = ph;
 428               int n = 0;
 429
 430               while (!(*--t == ' '))
 431                 n++;
 432
 433               *t++ = '\n';
 434               i = -1;
 435               p -= n;
 436               while (n--)
 437                 {
 438                   *t++ = *p++;
 439                   i++;
 440                 }
 441             }
 442           else
 443             {
 444               *ph++ = '\n';
 445               i = -1;
 446               while (*p != '\n' && *p == ' ')
 447                 p++;
 448             }
 449         }
 450
 451       *ph++ = *p;
 452     }
 453
 454   *ph = 0;
 455   xfree (tmp);
 456   return help;
 457 }
 458
 459 void
 460 free_key (void *data)
 461 {
 462   xfree (data);
 463 }
 464
 465 gpg_error_t
 466 create_thread (void *(*cb) (void *), void *data,
 467                pthread_t * tid, int detached)
 468 {
 469   pthread_attr_t attr;
 470   int n;
 471
 472   pthread_attr_init (&attr);
 473
 474   if (detached)
 475     pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
 476
 477   n = pthread_create (tid, &attr, cb, data);
 478   pthread_attr_destroy (&attr);
 479   return gpg_error_from_errno (n);
 480 }
 481
 482 void
 483 cleanup_mutex_cb (void *arg)
 484 {
 485   pthread_mutex_t *m = (pthread_mutex_t *) arg;
 486
 487   MUTEX_UNLOCK (m);
 488 }
 489
 490 void
 491 cleanup_fd_cb (void *arg)
 492 {
 493   int fd = *(int *) arg;
 494
 495   if (fd != -1)
 496     close (fd);
 497 }
 498
 499 void
 500 cleanup_unlink_cb (void *arg)
 501 {
 502   char *file = arg;
 503
 504   if (file && *file)
 505     unlink (file);
 506 }
 507
 508 void
 509 cleanup_cache_mutex (void *arg)
 510 {
 511   cache_unlock ();
 512 }
 513
 514 int
 515 valid_keygrip (const unsigned char *data, size_t len)
 516 {
 517   for (size_t i = 0; i < len; i++)
 518     {
 519       if (data[i])
 520         return 1;
 521     }
 522
 523   return 0;
 524 }
 525
 526 gpg_error_t
 527 get_checksum (const char *filename, unsigned char **r_crc, size_t * r_crclen)
 528 {
 529   int fd;
 530   unsigned char *buf;
 531   gpg_error_t rc = 0;
 532   struct stat st;
 533
 534   if (stat (filename, &st) == -1)
 535     return gpg_error_from_errno (errno);
 536
 537   fd = open (filename, O_RDONLY);
 538   if (fd == -1)
 539     return gpg_error_from_errno (errno);
 540
 541   pthread_cleanup_push (cleanup_fd_cb, &fd);
 542   buf = xmalloc (st.st_size);
 543   if (buf)
 544     {
 545       pthread_cleanup_push (xfree, buf);
 546
 547       size_t len = read (fd, buf, st.st_size);
 548       if (len == st.st_size)
 549         {
 550           if (buf)
 551             {
 552               unsigned char *crc;
 553
 554               len = gcry_md_get_algo_dlen (GCRY_MD_CRC32);
 555               crc = xmalloc (len);
 556               if (crc)
 557                 {
 558                   pthread_cleanup_push (xfree, crc);
 559                   gcry_md_hash_buffer (GCRY_MD_CRC32, crc, buf, st.st_size);
 560                   *r_crc = crc;
 561                   *r_crclen = len;
 562                   pthread_cleanup_pop (0);
 563                 }
 564               else
 565                 rc = GPG_ERR_ENOMEM;
 566             }
 567         }
 568       else
 569         rc = GPG_ERR_TOO_SHORT;
 570
 571       pthread_cleanup_pop (1);
 572     }
 573   else
 574     rc = GPG_ERR_ENOMEM;
 575
 576   pthread_cleanup_pop (1);
 577   return rc;
 578 }
 579
 580 wchar_t *str_to_wchar (const char *str)
 581 {
 582     wchar_t *wc;
 583     mbstate_t ps;
 584     const char *p = str;
 585     size_t len;
 586
 587     memset (&ps, 0, sizeof(mbstate_t));
 588     len = mbsrtowcs (NULL, &p, 0, &ps);
 589     if (len == -1)
 590       return NULL;
 591
 592     wc = xcalloc (len+1, sizeof(wchar_t));
 593     p = str;
 594     memset (&ps, 0, sizeof(mbstate_t));
 595     len = mbsrtowcs (wc, &p, len, &ps);
 596     return wc;
 597 }