util.c

   1 /*
   2  * Copyright 2001, 2002, 2003 David Mansfield and Cobite, Inc.
   3  * See COPYING file for license information
   4  */
   5
   6 #include <stdio.h>
   7 #include <string.h>
   8 #include <stdlib.h>
   9 #include <unistd.h>
  10 #include <limits.h>
  11 #include <assert.h>
  12 #ifdef __MINGW32__
  13 #include <tsearch/search.h>
  14 #include <windows.h>
  15 int setenv(const char *name, const char *value, int overwrite);
  16 void unsetenv(const char *name);
  17 #else
  18 #include <search.h>
  19 #endif
  20 #include <time.h>
  21 #include <errno.h>
  22 #include <signal.h>
  23 #include <regex.h>
  24 #include <sys/stat.h>
  25 #include <sys/time.h>
  26 #include <sys/types.h>
  27 #ifndef __MINGW32__
  28 #include <sys/wait.h>
  29 #endif
  30
  31 #include <cbtcommon/debug.h>
  32
  33 #include "util.h"
  34
  35 typedef int (*compare_func)(const void *, const void *);
  36
  37 static void * string_tree;
  38 char *readfile(char const *filename, char *buf, size_t size)
  39 {
  40     FILE *fp;
  41     char *ptr;
  42     size_t len;
  43
  44     fp = fopen(filename, "r");
  45     if (!fp)
  46         return NULL;
  47
  48     ptr = fgets(buf, size, fp);
  49     fclose(fp);
  50
  51     if (!ptr)
  52         return NULL;
  53
  54     len = strlen(buf);
  55     if (buf[len-1] == '\n')
  56         buf[len-1] = '\0';
  57
  58     return buf;
  59 }
  60
  61 char *strrep(char *s, char find, char replace)
  62 {
  63     char * p = s;
  64     while (*p)
  65     {
  66         if (*p == find)
  67             *p = replace;
  68         p++;
  69     }
  70
  71     return s;
  72 }
  73
  74 char *get_cvsps_dir()
  75 {
  76     struct stat sbuf;
  77     static char prefix[PATH_MAX];
  78     const char * home;
  79     const char * home_env;
  80
  81     if (prefix[0])
  82         return prefix;
  83
  84 #ifdef __MINGW32__
  85     home_env = "APPDATA"; /* application data is below user's home dir */
  86 #else
  87     home_env = "HOME";
  88 #endif
  89
  90     if (!(home = getenv(home_env)))
  91     {
  92         debug(DEBUG_APPERROR, "%s environment variable not set", home_env);
  93         exit(1);
  94     }
  95
  96     if (snprintf(prefix, PATH_MAX, "%s/%s", home, CVSPS_PREFIX) >= PATH_MAX)
  97     {
  98         debug(DEBUG_APPERROR, "prefix buffer overflow");
  99         exit(1);
 100     }
 101
 102     /* Make sure the prefix directory exists */
 103     if (stat(prefix, &sbuf) < 0)
 104     {
 105         int ret;
 106         #ifdef __MINGW32__
 107         ret = mkdir(prefix);
 108         #else
 109         ret = mkdir(prefix, 0777);
 110         #endif
 111         if (ret < 0)
 112         {
 113             debug(DEBUG_SYSERROR, "Cannot create the cvsps directory '%s'", CVSPS_PREFIX);
 114             exit(1);
 115         }
 116     }
 117     else
 118     {
 119         if (!(S_ISDIR(sbuf.st_mode)))
 120             debug(DEBUG_APPERROR, "cvsps directory '%s' is not a directory!", CVSPS_PREFIX);
 121     }
 122
 123     return prefix;
 124 }
 125
 126 char *xstrdup(char const *str)
 127 {
 128     char *ret;
 129     assert(str);
 130     ret = strdup(str);
 131     if (!ret)
 132     {
 133         debug(DEBUG_ERROR, "strdup failed");
 134         exit(1);
 135     }
 136
 137     return ret;
 138 }
 139
 140 void strzncpy(char * dst, const char * src, int n)
 141 {
 142     strncpy(dst, src, n);
 143     dst[n - 1] = 0;
 144 }
 145
 146 char *get_string(char const *str)
 147 {
 148     char ** res;
 149
 150     if (!str)
 151         return NULL;
 152
 153     res = (char **)tfind(str, &string_tree, (compare_func)strcmp);
 154     if (!res)
 155     {
 156         char *key = xstrdup(str);
 157         res = (char **)tsearch(key, &string_tree, (compare_func)strcmp);
 158         *res = key;
 159     }
 160
 161     return *res;
 162 }
 163
 164 static int get_int_substr(const char * str, const regmatch_t * p)
 165 {
 166     char buff[256];
 167     memcpy(buff, str + p->rm_so, p->rm_eo - p->rm_so);
 168     buff[p->rm_eo - p->rm_so] = 0;
 169     return atoi(buff);
 170 }
 171
 172 static time_t mktime_utc(struct tm * tm)
 173 {
 174     char * old_tz = getenv("TZ");
 175     time_t ret;
 176
 177     setenv("TZ", "UTC", 1);
 178
 179     tzset();
 180
 181     ret = mktime(tm);
 182
 183     if (old_tz)
 184         setenv("TZ", old_tz, 1);
 185     else
 186         unsetenv("TZ");
 187
 188     tzset();
 189
 190     return ret;
 191 }
 192
 193 void convert_date(time_t * t, const char * dte)
 194 {
 195     static regex_t date_re;
 196     static int init_re;
 197
 198 #define MAX_MATCH 16
 199     size_t nmatch = MAX_MATCH;
 200     regmatch_t match[MAX_MATCH];
 201
 202     if (!init_re)
 203     {
 204         if (regcomp(&date_re, "([0-9]{4})[-/]([0-9]{2})[-/]([0-9]{2}) ([0-9]{2}):([0-9]{2}):([0-9]{2})", REG_EXTENDED))
 205         {
 206             fprintf(stderr, "FATAL: date regex compilation error\n");
 207             exit(1);
 208         }
 209         init_re = 1;
 210     }
 211
 212     if (regexec(&date_re, dte, nmatch, match, 0) == 0)
 213     {
 214         regmatch_t * pm = match;
 215         struct tm tm = {0};
 216
 217         /* first regmatch_t is match location of entire re */
 218         pm++;
 219
 220         tm.tm_year = get_int_substr(dte, pm++);
 221         tm.tm_mon  = get_int_substr(dte, pm++);
 222         tm.tm_mday = get_int_substr(dte, pm++);
 223         tm.tm_hour = get_int_substr(dte, pm++);
 224         tm.tm_min  = get_int_substr(dte, pm++);
 225         tm.tm_sec  = get_int_substr(dte, pm++);
 226
 227         tm.tm_year -= 1900;
 228         tm.tm_mon--;
 229
 230         *t = mktime_utc(&tm);
 231     }
 232     else
 233     {
 234         *t = atoi(dte);
 235     }
 236 }
 237
 238 static struct timeval start_time;
 239
 240 void timing_start()
 241 {
 242     gettimeofday(&start_time, NULL);
 243 }
 244
 245 void timing_stop(const char * msg)
 246 {
 247     struct timeval stop_time;
 248     gettimeofday(&stop_time, NULL);
 249     stop_time.tv_sec -= start_time.tv_sec;
 250     stop_time.tv_usec -= start_time.tv_usec;
 251     if (stop_time.tv_usec < 0)
 252         stop_time.tv_sec--,stop_time.tv_usec += 1000000;
 253
 254     printf("Elapsed time for %s: %d.%06d\n", msg, (int)stop_time.tv_sec, (int)stop_time.tv_usec);
 255 }
 256
 257 extern char ** environ;
 258
 259 /* taken from the linux manual page for system
 260    See http://linux.die.net/man/3/system
 261  */
 262 int my_system (const char *command)
 263 {
 264 #ifdef __MINGW32__
 265     /* Launch child process */
 266     STARTUPINFO si;
 267     ZeroMemory( &si, sizeof( si ) );
 268     si.cb = sizeof( si );
 269     PROCESS_INFORMATION pi;
 270     ZeroMemory( &pi, sizeof( pi ) );
 271     if( !CreateProcess(
 272       0,                    /* module name (0 means use first token in command line) */
 273       (char*)command,       /* command line */
 274       0,                    /* process security attributes */
 275       0,                    /* primary thread security attributes */
 276       TRUE,                 /* handles are inherited */
 277       0,                    /* creation flags (none) */
 278       0,                    /* use parent's environment */
 279       0,                    /* use parent's current directory */
 280       &si,                  /* STARTUPINFO pointer */
 281       &pi                   /* receives PROCESS_INFORMATION */
 282     ) ) {
 283         debug(DEBUG_APPERROR, "CreateProcess failed.\n command line was: %s", command);
 284         return -1;
 285     }
 286
 287     /* Wait for child process to exit */
 288     DWORD timeout = 10*1000; /* milliseconds */
 289     DWORD ret = WaitForSingleObject( pi.hProcess, timeout );
 290     if (ret == WAIT_OBJECT_0) {
 291         /* OK. Child has exited */
 292     }
 293     else if (ret == WAIT_FAILED) {
 294         DWORD last_err = GetLastError();
 295         debug(DEBUG_APPERROR, "WaitForSingleObject failed.\n GetLastError returned : %d", last_err);
 296         return -1;
 297     }
 298     else {
 299         debug(DEBUG_APPERROR, "WaitForSingleObject returned %x", ret);
 300         return -1;
 301     }
 302
 303     /* Retrieve exit code */
 304     DWORD exit_code;
 305     if( !GetExitCodeProcess( pi.hProcess, &exit_code ) ) {
 306         DWORD last_err = GetLastError();
 307         debug(DEBUG_APPERROR, "GetExitCodeProcess failed.\n GetLastError returned : %d", last_err);
 308         return -1;
 309     }
 310
 311     return exit_code;
 312 #else
 313     int pid, status;
 314
 315     if (command == 0)
 316         return 1;
 317     pid = fork();
 318     if (pid == -1)
 319         return -1;
 320     if (pid == 0) {
 321         char *argv[4];
 322         argv[0] = "sh";
 323         argv[1] = "-c";
 324         argv[2] = (char*)command; /* discard const */
 325         argv[3] = 0;
 326         execve("/bin/sh", argv, environ);
 327         exit(127);
 328     }
 329     do {
 330         if (waitpid(pid, &status, 0) == -1) {
 331             if (errno != EINTR)
 332                 return -1;
 333         } else
 334             return status;
 335     } while(1);
 336 #endif
 337 }
 338
 339 int escape_filename(char * dst, int len, const char * src)
 340 {
 341     static char * naughty_chars = " \\\"'@<>=;|&()#$`?*[!:{";
 342
 343     if (len > 0)
 344     {
 345         while (len > 1 && *src)
 346         {
 347             if (strchr(naughty_chars, *src))
 348             {
 349                 if (len == 2)
 350                     break;
 351                 *dst++ = '\\';
 352                 len--;
 353             }
 354
 355             *dst++ = *src++;
 356             len--;
 357         }
 358
 359         *dst = 0;
 360     }
 361
 362     return (*src == 0) ? 0 : -1;
 363 }