src/util.c

   1 /*
   2  * Copyright (c) 2006,2009 Charles S. Wilson
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included
  12  * in all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  15  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  17  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20  * OTHER DEALINGS IN THE SOFTWARE.
  21  */
  22
  23 #if HAVE_CONFIG_H
  24 # include <config.h>
  25 #endif
  26
  27 #if STDC_HEADERS
  28 # include <stdlib.h>
  29 # include <stdarg.h>
  30 # include <string.h>
  31 # include <float.h>
  32 #endif
  33
  34 #include <stdio.h>
  35 #include <errno.h>
  36 #include <assert.h>
  37 #include <ctype.h>
  38
  39 #if HAVE_SYS_TYPES_H
  40 # include <sys/types.h>
  41 #endif
  42 #if HAVE_MALLOC_H
  43 # include <malloc.h>
  44 #endif
  45 #if HAVE_SYS_STAT_H
  46 # include <sys/stat.h>
  47 #endif
  48 #if HAVE_PWD_H
  49 # include <pwd.h>
  50 #endif
  51 #if HAVE_UNISTD_H
  52 # include <unistd.h>
  53 #endif
  54 #if HAVE_SYS_CYGWIN_H
  55 # include <sys/cygwin.h>
  56 #endif
  57 #if HAVE_WINDOWS_H && HAVE_OPENCLIPBOARD
  58 # define WIN32_LEAD_AND_MEAN
  59 # define NOMINMAX
  60 # include <windows.h>
  61 #endif
  62
  63 #ifndef ORIGINAL_RUN
  64 #include <ustr.h>
  65 #endif
  66 #include "util.h"
  67
  68 char *program_name = NULL;
  69
  70 static int gui_mode = 1; /* enabled */
  71 static int tty_mode = 1; /* enabled */
  72 static int verbose_level = 0;  /* only FATAL errors, by default */
  73
  74 int run2_gui_is_allowed(void)  { return gui_mode;    }
  75 int run2_tty_is_allowed(void)  { return tty_mode;    }
  76 int run2_get_verbose_level(void) { return verbose_level; }
  77
  78 void run2_set_gui_mode(int mode)    { gui_mode = mode;    }
  79 void run2_set_tty_mode(int mode)    { tty_mode = mode;    }
  80 void run2_set_verbose_level(int level){ verbose_level = level;}
  81
  82 const char *
  83 run2_get_program_name (void)
  84 {
  85   if (!program_name || !*program_name)
  86     return "run2";
  87   return program_name;
  88 }
  89
  90 void
  91 run2_set_program_name (const char *p)
  92 {
  93   if (program_name)
  94     free (program_name);
  95   program_name = run2_strdup (run2_basename (p));
  96 }
  97
  98 const char *
  99 run2_basename (const char *name)
 100 {
 101   const char *base;
 102
 103 #if defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER)
 104   /* Skip over the disk name in MSDOS pathnames. */
 105   if (isalpha ((unsigned char) name[0]) && name[1] == ':')
 106     name += 2;
 107 #endif
 108
 109   for (base = name; *name; name++)
 110     if ((*name == '/')
 111 #if defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER)
 112        || (*name == '\\')
 113 #endif
 114        )
 115       base = name + 1;
 116   return base;
 117 }
 118
 119 int
 120 run2_ends_with(const char* s1, const char* s2)
 121 {
 122   int len1;
 123   int len2;
 124   int retval = 0;
 125   len1 = strlen(s1);
 126   len2 = strlen(s2);
 127   if (len1 - len2 >= 0)
 128     if (strcasecmp(&(s1[len1-len2]),s2) == 0)
 129       retval = 1;
 130   return retval;
 131 }
 132
 133 void
 134 run2_strip_exe(char* s)
 135 {
 136   size_t slen = strlen(s);
 137   if ((slen > 4) && /* long enough to have .exe extension */
 138     /* second part not evaluated (short circuit) if exec_arg too short */
 139     (strcasecmp(&(s[slen-4]),".exe") == 0))
 140   s[slen-4] = '\0';
 141 }
 142
 143 #ifndef ORIGINAL_RUN
 144 /*
 145  * This function attempts to locate a file which may be in any of
 146  * several directories. Unlike the original pfopen, it does not
 147  * return a FILE pointer to the opened file, but rather returns
 148  * the fully-qualified filename of the first match found. Returns
 149  * NULL if not found.
 150  */
 151 Ustr*
 152 run2_pfopen (const Ustr *name, const Ustr *dirs)
 153 {
 154     Ustr *tdirs = NULL;
 155     Ustr *tname = NULL;
 156     Ustr *returnVal = NULL;
 157     Ustr *tok = USTR_NULL;
 158     size_t off = 0;
 159
 160     int foundit = 0;
 161
 162     if (dirs == NULL || ustr_len (dirs) == 0)
 163         return NULL;
 164
 165     tname = USTR_CHECK (ustr_dup (name));
 166     tdirs = USTR_CHECK (ustr_dup (dirs));
 167     while ((tok = ustr_split_cstr (tdirs, &off, SEP_CHARS, USTR_NULL, USTR_FLAG_SPLIT_DEF)) &&
 168            (foundit == 0))
 169     {
 170       foundit = run2_fileExists (&returnVal, tok, tname);
 171       ustr_free(tok); /* have to free to avoid mem leaks */
 172     }
 173
 174     ustr_free(tdirs);
 175     ustr_free(tname);
 176     return returnVal;
 177 }
 178
 179 int
 180 run2_fileExists (Ustr **fullname, const Ustr* path, const Ustr* name)
 181 {
 182   int retval = 0;
 183   FILE* file;
 184   size_t len;
 185   Ustr* worku = NULL;
 186   char* workc = NULL;
 187   if (path != NULL)
 188     {
 189        worku = ustr_dup (path);
 190        len = ustr_len (worku);
 191        workc = ustr_wstr (worku);
 192        if (len && workc[len-1] != '/' && workc[len-1] != '\\')
 193        {
 194           USTR_ADD_OSTR (&worku, PATH_SEP_CHAR_STR);
 195        }
 196     }
 197   else
 198     worku = ustr_dup_empty ();
 199
 200   ustr_add (&worku, name);
 201
 202   workc = (char *) cygwin_create_path (CCP_WIN_A_TO_POSIX | CCP_RELATIVE, ustr_cstr (worku));
 203   if (!workc)
 204     {
 205       errorMsg ("Unable to convert \"%s\" to posix format: %s",
 206                 ustr_cstr (worku), strerror (errno));
 207     }
 208   else
 209     {
 210       debugMsg (3, "(%s) looking for...\t%s", __func__, workc);
 211
 212       file = fopen (workc, "rb");
 213       if (file != NULL)
 214         {
 215           fclose(file);
 216           if (fullname != NULL)
 217             *fullname = USTR_CHECK (ustr_dup_cstr (workc));
 218           retval = TRUE;
 219         }
 220       free (workc);
 221     }
 222   ustr_free (worku);
 223   return retval;
 224 }
 225
 226
 227 Ustr *
 228 ustr_check (Ustr * s, const char * fn, int ln)
 229 {
 230   if (!s)
 231     {
 232       run2_error (EXIT_FAILURE, ENOMEM,
 233                   "Unable to allocate memory for ustr: %s:%d",
 234                   fn, ln);
 235       abort ();
 236     }
 237   if ((ustr_ro (s) == USTR_FALSE) &&
 238       (ustr_enomem (s) == USTR_TRUE))
 239     {
 240       run2_error (EXIT_FAILURE, ENOMEM,
 241                   "Unable to allocate memory for ustr: %s:%d",
 242                   fn, ln);
 243       abort ();
 244     }
 245   return s;
 246 }
 247 #else /* ORIGINAL_RUN */
 248 /*
 249  * This function attempts to locate a file which may be in any of
 250  * several directories. Unlike the original pfopen, it does not
 251  * return a FILE pointer to the opened file, but rather returns
 252  * the fully-qualified filename of the first match found. Returns
 253  * NULL if not found.
 254  */
 255 char*
 256 run2_pfopen (const char *name, const char *dirs)
 257 {
 258     char *tdirs = NULL;
 259     char *tname = NULL;
 260     char *returnVal = NULL;
 261     char *tok = NULL;
 262     size_t off = 0;
 263
 264     int foundit = 0;
 265
 266     if (dirs == NULL || *dirs == '\0')
 267         return NULL;
 268
 269     tname = run2_strdup (name);
 270     tdirs = run2_strdup (dirs);
 271     for (tok = strtok (tdirs, SEP_CHARS);
 272          (foundit == 0) && (tok != NULL);
 273          tok = strtok (NULL, SEP_CHARS))
 274     {
 275       foundit = run2_fileExists (&returnVal, tok, tname);
 276     }
 277
 278     free(tdirs);
 279     free(tname);
 280     return returnVal;
 281 }
 282
 283 int
 284 run2_fileExists (char **fullname, const char* path, const char* name)
 285 {
 286   int retval = 0;
 287   FILE* file;
 288   size_t len;
 289   char* worku = NULL;
 290   char* workc = NULL;
 291   if (path != NULL)
 292     {
 293        worku = run2_strdup (path);
 294        len = strlen (worku);
 295        if (len && worku[len-1] != '/' && worku[len-1] != '\\')
 296        {
 297           workc = run2_extend_str(worku, PATH_SEP_CHAR_STR, 1);
 298           worku = workc;
 299        }
 300     }
 301   else
 302     worku = run2_strdup("");
 303
 304   workc = run2_extend_str(worku, name, 1);
 305   worku = workc;
 306
 307 #ifdef __CYGWIN__
 308   workc = (char *) cygwin_create_path (CCP_WIN_A_TO_POSIX | CCP_RELATIVE, worku);
 309   if (!workc)
 310     {
 311       errorMsg ("Unable to convert \"%s\" to posix format: %s",
 312                 worku, strerror (errno));
 313     }
 314   else
 315     {
 316 #endif
 317       debugMsg (3, "(%s) looking for...\t%s", __func__, workc);
 318
 319       file = fopen (workc, "rb");
 320       if (file != NULL)
 321         {
 322           fclose(file);
 323           if (fullname != NULL)
 324             *fullname = run2_strdup (workc);
 325           retval = TRUE;
 326         }
 327 #ifdef __CYGWIN__
 328       /* on non-cygwin, worku and workc point to the same location */
 329       free (workc);
 330     }
 331 #endif
 332   free (worku);
 333   return retval;
 334 }
 335 #endif /* ORIGINAL_RUN */
 336
 337
 338 void run2_message_(int level, const char* fmt, ...)
 339 {
 340    va_list args;
 341    va_start(args, fmt);
 342    run2_vmessage_(level, fmt, args);
 343    va_end(args);
 344 }
 345
 346 void run2_vmessage_(int level, const char* fmt, va_list args)
 347 {
 348   char buf[10000];
 349   char titlebuf[200];
 350   int i,j;
 351   const char *pn = program_name;
 352   if (!pn || !*pn)
 353     pn = "run2";
 354
 355   j = vsprintf(buf,fmt,args);
 356   buf[j] = '\0'; /* paranoia */
 357   if (ENABLE_TTY && (run2_tty_is_allowed()))
 358     {
 359       if (level >= RUN2_LOG_DEBUG)
 360         fprintf(stderr, "%s DEBUG: %s\n", pn, buf);
 361       else if (level < RUN2_LOG_FATAL)
 362         fprintf (stdout, buf);
 363       else
 364         switch (level)
 365           {
 366             case RUN2_LOG_FATAL: fprintf(stderr, "%s FATAL: %s\n", pn, buf); break;
 367             case RUN2_LOG_ERROR: fprintf(stderr, "%s Error: %s\n", pn, buf); break;
 368             case RUN2_LOG_WARN:  fprintf(stderr, "%s Warning: %s\n", pn, buf); break;
 369             case RUN2_LOG_INFO:  fprintf(stderr, "%s Info: %s\n", pn, buf); break;
 370             default: fprintf(stderr, "%s <unknown criticality>: %s\n", pn, buf); break;
 371           }
 372       return;
 373     }
 374   if (ENABLE_GUI && (run2_gui_is_allowed()))
 375     {
 376       i = 0;
 377       if (level >= RUN2_LOG_DEBUG)
 378         i = sprintf(titlebuf, "%s DEBUG", pn);
 379       else if (level < RUN2_LOG_FATAL)
 380         i = sprintf(titlebuf, "%s", pn);
 381       else
 382         switch (level)
 383           {
 384             case RUN2_LOG_FATAL: i = sprintf(titlebuf, "%s FATAL", pn); break;
 385             case RUN2_LOG_ERROR: i = sprintf(titlebuf, "%s Error", pn); break;
 386             case RUN2_LOG_WARN:  i = sprintf(titlebuf, "%s Warning", pn); break;
 387             case RUN2_LOG_INFO:  i = sprintf(titlebuf, "%s Info", pn); break;
 388             default: i = sprintf(titlebuf, "%s <unknown criticality>", pn); break;
 389           }
 390       titlebuf[i] = '\0'; /* paranoia */
 391
 392       if (level >= RUN2_LOG_DEBUG)
 393         MessageBox(NULL, buf, titlebuf, MB_ICONINFORMATION);
 394       else if (level < RUN2_LOG_FATAL)
 395         MessageBox(NULL, buf, titlebuf, MB_ICONINFORMATION);
 396       else
 397         switch (level)
 398           {
 399             case RUN2_LOG_FATAL: MessageBox(NULL, buf, titlebuf, MB_ICONERROR); break;
 400             case RUN2_LOG_ERROR: MessageBox(NULL, buf, titlebuf, MB_ICONERROR); break;
 401             case RUN2_LOG_WARN:  MessageBox(NULL, buf, titlebuf, MB_ICONWARNING); break;
 402             case RUN2_LOG_INFO:  MessageBox(NULL, buf, titlebuf, MB_ICONINFORMATION); break;
 403             default: MessageBox(NULL, buf, titlebuf, MB_ICONERROR); break;
 404           }
 405       return;
 406     }
 407 }
 408
 409 char**
 410 run2_dupargv (char **vector)
 411 {
 412   int argc;
 413   char **rval;
 414
 415   if (vector == NULL)
 416     return NULL;
 417
 418   for (argc = 0; vector[argc] != NULL; argc++)
 419     ;
 420   rval = (char **) run2_malloc ((argc + 1) * sizeof (char *));
 421
 422   for (argc = 0; vector[argc] != NULL; argc++)
 423   {
 424     int len = strlen (vector[argc]);
 425     rval[argc] = run2_strdup (vector[argc]);
 426   }
 427   rval[argc] = NULL;
 428   return rval;
 429 }
 430
 431 int
 432 run2_countargv (char **vector)
 433 {
 434   char **scan;
 435   int rc = 0;
 436   if (vector != NULL)
 437     for (scan = vector; *scan != NULL; scan++)
 438       rc++;
 439   return rc;
 440 }
 441
 442 void
 443 run2_freeargv (char **vector)
 444 {
 445   char **scan;
 446   if (vector != NULL)
 447     {
 448       for (scan = vector; *scan != NULL; scan++)
 449         {
 450           free (*scan);
 451           *scan = NULL;
 452         }
 453       free (vector);
 454     }
 455 }
 456
 457 static void
 458 run2_verror (int status, int errnum, const char *message, va_list args)
 459 {
 460   if (errnum)
 461   {
 462     /* grow the message to hold error info */
 463     char const *s = strerror (errnum);
 464     char *newmsg;
 465     if (!s) s = "Unknown system error";
 466     newmsg = run2_extend_str (message, ": ", 1);
 467     newmsg = run2_extend_str (newmsg, s, 1);
 468     verrorMsg (newmsg, args);
 469   }
 470   else
 471   {
 472     verrorMsg (message, args);
 473   }
 474   if (status)
 475     exit (status);
 476 }
 477
 478 void
 479 run2_error (int status, int errnum, const char *message, ...)
 480 {
 481   va_list args;
 482   va_start (args, message);
 483   run2_verror (status, errnum, message, args);
 484   va_end (args);
 485 }
 486
 487 void
 488 run2_malloc_exit (void)
 489 {
 490   run2_error (EXIT_FAILURE, 0, "Unable to allocate memory");
 491   abort ();
 492 }
 493
 494 void*
 495 run2_malloc (size_t sz)
 496 {
 497   void *p = malloc (sz);
 498   if (!p && sz != 0)
 499     run2_malloc_exit ();
 500   return p;
 501 }
 502
 503 void*
 504 run2_realloc (void *p, size_t sz)
 505 {
 506   p = realloc (p, sz);
 507   if (!p && sz != 0)
 508     run2_malloc_exit ();
 509   return p;
 510 }
 511
 512 char*
 513 run2_strdup (const char *s)
 514 {
 515   size_t len = strlen (s);
 516   char * d = (char *) run2_malloc (len + 1);
 517
 518   if (s)
 519     strncpy (d, s, len + 1);
 520   else
 521     d[0] = '\0';
 522
 523   return d;
 524 }
 525
 526 char*
 527 run2_quote_strdup (const char *s, int quote)
 528 {
 529   size_t len = strlen (s);
 530   if (len == 0)
 531     return "\"\"";
 532   if (quote && (len > strcspn (s, " \t\v\"\\")))
 533     {
 534       size_t i, j = 0;
 535       char * d = (char *) run2_malloc (2*len + 3);
 536       d[j++] = '"';
 537       for (i=0; i<len; i++)
 538         {
 539           switch (s[i]) {
 540           case '\\':
 541             d[j++] = '\\';
 542             d[j++] = '\\';
 543             break;
 544           case '"':
 545             d[j++] = '\\';
 546             d[j++] = '"';
 547             break;
 548           default:
 549             d[j++] = s[i];
 550           }
 551         }
 552       d[j++] = '"';
 553       d[j++] = '\0';
 554       return d;
 555     }
 556   return run2_strdup (s);
 557 }
 558
 559 char *
 560 run2_extend_str (const char *orig_value, const char *add, int to_end)
 561 {
 562   char *new_value;
 563   if (orig_value && *orig_value)
 564     {
 565       int orig_value_len = strlen (orig_value);
 566       int add_len = strlen (add);
 567       new_value = (char *) run2_malloc (add_len + orig_value_len + 1);
 568       if (to_end)
 569         {
 570           strcpy (new_value, orig_value);
 571           strcpy (new_value + orig_value_len, add);
 572         }
 573       else
 574         {
 575           strcpy (new_value, add);
 576           strcpy (new_value + add_len, orig_value);
 577         }
 578     }
 579   else
 580     {
 581       new_value = run2_strdup (add);
 582     }
 583   return new_value;
 584 }
 585
 586 int
 587 run2_strtol(char *arg, long *value)
 588 {
 589   char *endptr;
 590   int errno_save = errno;
 591
 592   assert(arg!=NULL);
 593   errno = 0;
 594   *value = strtol(arg, &endptr, 0);
 595   if (errno != 0 || *endptr!='\0' || endptr==arg) {
 596     return 1;
 597   }
 598   errno = errno_save;
 599   return 0;
 600 }
 601
 602 #if HAVE_PWD_H
 603 char *
 604 run2_get_homedir (const char *user)
 605 {
 606   char *home;
 607   struct passwd *pwd;
 608
 609   if (!user || !*user)
 610     {
 611       home = getenv("HOME");
 612       if (home && *home)
 613         return run2_strdup (home);
 614       errno = 0;
 615       pwd = getpwuid (getuid());
 616       if (pwd)
 617         return run2_strdup (pwd->pw_dir);
 618       errorMsg ("Could not determine home directory for current user");
 619       return NULL;
 620     }
 621
 622   errno = 0;
 623   pwd = getpwnam (user);
 624   if (pwd)
 625     return run2_strdup (pwd->pw_dir);
 626   errorMsg ("Could not determine home directory for user %s", user);
 627   return NULL;
 628 }
 629 #else
 630 char *
 631 run2_get_homedir (const char *user)
 632 {
 633   char *home;
 634
 635   if (!user || !*user)
 636     {
 637       home = getenv("HOME");
 638       if (home && *home)
 639         return run2_strdup (home);
 640       errorMsg ("Could not determine home directory for current user");
 641       return NULL;
 642     }
 643
 644   errorMsg ("Could not determine home directory for user %s", user);
 645   return NULL;
 646 }
 647 #endif
 648