X-Git-Url: http://www.privoxy.org/gitweb/?p=privoxy.git;a=blobdiff_plain;f=miscutil.c;h=9af7bed3a78aae904a5ea317e4ecb39fca2e5a12;hp=421f2b5c776355b9396ef4b990093ed789461d8c;hb=e7504bc541889af91127fdc6150b72537aac7f52;hpb=7600ab8fcf587195f51d2faf6e92d1d1a2e24fd0 diff --git a/miscutil.c b/miscutil.c index 421f2b5c..9af7bed3 100644 --- a/miscutil.c +++ b/miscutil.c @@ -1,4 +1,3 @@ -const char miscutil_rcs[] = "$Id: miscutil.c,v 1.65 2011/04/19 13:00:47 fabiankeil Exp $"; /********************************************************************* * * File : $Source: /cvsroot/ijbswa/current/miscutil.c,v $ @@ -8,11 +7,11 @@ const char miscutil_rcs[] = "$Id: miscutil.c,v 1.65 2011/04/19 13:00:47 fabianke * to deserve their own file but don't really fit in * any other file. * - * Copyright : Written by and Copyright (C) 2001-2011 the - * Privoxy team. http://www.privoxy.org/ + * Copyright : Written by and Copyright (C) 2001-2018 the + * Privoxy team. https://www.privoxy.org/ * * Based on the Internet Junkbuster originally written - * by and Copyright (C) 1997 Anonymous Coders and + * by and Copyright (C) 1997 Anonymous Coders and * Junkbusters Corporation. http://www.junkbusters.com * * The timegm replacement function was taken from GnuPG, @@ -23,7 +22,7 @@ const char miscutil_rcs[] = "$Id: miscutil.c,v 1.65 2011/04/19 13:00:47 fabianke * used under the terms of the GPL or the terms of the * "Frontier Artistic License". * - * This program is free software; you can redistribute it + * This program is free software; you can redistribute it * and/or modify it under the terms of the GNU General * Public License as published by the Free Software * Foundation; either version 2 of the License, or (at @@ -63,131 +62,211 @@ const char miscutil_rcs[] = "$Id: miscutil.c,v 1.65 2011/04/19 13:00:47 fabianke #include "project.h" #include "miscutil.h" #include "errlog.h" -#include "jcc.h" - -const char miscutil_h_rcs[] = MISCUTIL_H_VERSION; /********************************************************************* * * Function : zalloc * - * Description : Malloc some memory and set it to '\0'. - * The way calloc() ought to be -acjc + * Description : Returns allocated memory that is initialized + * with zeros. * * Parameters : * 1 : size = Size of memory chunk to return. * - * Returns : Pointer to newly malloc'd memory chunk. + * Returns : Pointer to newly alloc'd memory chunk. * *********************************************************************/ void *zalloc(size_t size) { void * ret; +#ifdef HAVE_CALLOC + ret = calloc(1, size); +#else +#warning calloc appears to be unavailable. Your platform will become unsupported in the future if ((ret = (void *)malloc(size)) != NULL) { memset(ret, 0, size); } +#endif return(ret); } -#if defined(unix) /********************************************************************* * - * Function : write_pid_file + * Function : zalloc_or_die * - * Description : Writes a pid file with the pid of the main process + * Description : zalloc wrapper that either succeeds or causes + * program termination. * - * Parameters : None + * Useful in situations were the string length is + * "small" and zalloc() failures couldn't be handled + * better anyway. In case of debug builds, failures + * trigger an assert(). * - * Returns : N/A + * Parameters : + * 1 : size = Size of memory chunk to return. + * + * Returns : Pointer to newly malloc'd memory chunk. * *********************************************************************/ -void write_pid_file(void) +void *zalloc_or_die(size_t size) { - FILE *fp; - - /* - * If no --pidfile option was given, - * we can live without one. - */ - if (pidfile == NULL) return; + void *buffer; - if ((fp = fopen(pidfile, "w")) == NULL) + buffer = zalloc(size); + if (buffer == NULL) { - log_error(LOG_LEVEL_INFO, "can't open pidfile '%s': %E", pidfile); + assert(buffer != NULL); + log_error(LOG_LEVEL_FATAL, "Out of memory in zalloc_or_die()."); + exit(1); } - else + + return(buffer); + +} + +/********************************************************************* + * + * Function : strdup_or_die + * + * Description : strdup wrapper that either succeeds or causes + * program termination. + * + * Useful in situations were the string length is + * "small" and strdup() failures couldn't be handled + * better anyway. In case of debug builds, failures + * trigger an assert(). + * + * Parameters : + * 1 : str = String to duplicate + * + * Returns : Pointer to newly strdup'd copy of the string. + * + *********************************************************************/ +char *strdup_or_die(const char *str) +{ + char *new_str; + + new_str = strdup(str); + + if (new_str == NULL) { - fprintf(fp, "%u\n", (unsigned int) getpid()); - fclose (fp); + assert(new_str != NULL); + log_error(LOG_LEVEL_FATAL, "Out of memory in strdup_or_die()."); + exit(1); } - return; + + return(new_str); } -#endif /* def unix */ /********************************************************************* * - * Function : hash_string + * Function : malloc_or_die * - * Description : Take a string and compute a (hopefuly) unique numeric - * integer value. This has several uses, but being able - * to "switch" a string the one of my favorites. + * Description : malloc wrapper that either succeeds or causes + * program termination. + * + * Useful in situations were the buffer size is "small" + * and malloc() failures couldn't be handled better + * anyway. In case of debug builds, failures trigger + * an assert(). * * Parameters : - * 1 : s : string to be hashed. + * 1 : buffer_size = Size of the space to allocate * - * Returns : an unsigned long variable with the hashed value. + * Returns : Pointer to newly malloc'd memory * *********************************************************************/ -unsigned int hash_string( const char* s ) +void *malloc_or_die(size_t buffer_size) { - unsigned int h = 0; + char *new_buf; - for ( ; *s; ++s ) + if (buffer_size == 0) { - h = 5 * h + (unsigned int)*s; + log_error(LOG_LEVEL_ERROR, + "malloc_or_die() called with buffer size 0"); + assert(buffer_size != 0); + buffer_size = 4096; } - return (h); + new_buf = malloc(buffer_size); + + if (new_buf == NULL) + { + assert(new_buf != NULL); + log_error(LOG_LEVEL_FATAL, "Out of memory in malloc_or_die()."); + exit(1); + } + + return(new_buf); } -#ifdef __MINGW32__ +#if defined(unix) /********************************************************************* * - * Function : strdup + * Function : write_pid_file * - * Description : For some reason (which is beyond me), gcc and WIN32 - * don't like strdup. When a "free" is executed on a - * strdup'd ptr, it can at times freez up! So I just - * replaced it and problem was solved. + * Description : Writes a pid file with the pid of the main process. + * Exits if the file can't be opened * * Parameters : - * 1 : s = string to duplicate + * 1 : pidfile = Path of the pidfile that gets created. * - * Returns : Pointer to newly malloc'ed copy of the string. + * Returns : N/A * *********************************************************************/ -char *strdup( const char *s ) +void write_pid_file(const char *pidfile) { - char * result = (char *)malloc( strlen(s)+1 ); + FILE *fp; - if (result != NULL) + if ((fp = fopen(pidfile, "w")) == NULL) + { + log_error(LOG_LEVEL_FATAL, "can't open pidfile '%s': %E", pidfile); + } + else { - strcpy( result, s ); + fprintf(fp, "%u\n", (unsigned int) getpid()); + fclose (fp); } + return; - return( result ); } +#endif /* def unix */ + + +/********************************************************************* + * + * Function : hash_string + * + * Description : Take a string and compute a (hopefuly) unique numeric + * integer value. This is useful to "switch" a string. + * + * Parameters : + * 1 : s : string to be hashed. + * + * Returns : The string's hash + * + *********************************************************************/ +unsigned int hash_string(const char* s) +{ + unsigned int h = 0; -#endif /* def __MINGW32__ */ + for (; *s; ++s) + { + h = 5 * h + (unsigned int)*s; + } + + return (h); + +} /********************************************************************* @@ -210,13 +289,13 @@ int strcmpic(const char *s1, const char *s2) while (*s1 && *s2) { - if ( ( *s1 != *s2 ) && ( ijb_tolower(*s1) != ijb_tolower(*s2) ) ) + if ((*s1 != *s2) && (privoxy_tolower(*s1) != privoxy_tolower(*s2))) { break; } s1++, s2++; } - return(ijb_tolower(*s1) - ijb_tolower(*s2)); + return(privoxy_tolower(*s1) - privoxy_tolower(*s2)); } @@ -240,10 +319,10 @@ int strncmpic(const char *s1, const char *s2, size_t n) if (n <= (size_t)0) return(0); if (!s1) s1 = ""; if (!s2) s2 = ""; - + while (*s1 && *s2) { - if ( ( *s1 != *s2 ) && ( ijb_tolower(*s1) != ijb_tolower(*s2) ) ) + if ((*s1 != *s2) && (privoxy_tolower(*s1) != privoxy_tolower(*s2))) { break; } @@ -252,7 +331,7 @@ int strncmpic(const char *s1, const char *s2, size_t n) s1++, s2++; } - return(ijb_tolower(*s1) - ijb_tolower(*s2)); + return(privoxy_tolower(*s1) - privoxy_tolower(*s2)); } @@ -274,21 +353,21 @@ char *chomp(char *string) { char *p, *q, *r; - /* + /* * strip trailing whitespace */ p = string + strlen(string); - while (p > string && ijb_isspace(*(p-1))) + while (p > string && privoxy_isspace(*(p-1))) { p--; } *p = '\0'; - /* - * find end of leading whitespace + /* + * find end of leading whitespace */ q = r = string; - while (*q && ijb_isspace(*q)) + while (*q && privoxy_isspace(*q)) { q++; } @@ -313,7 +392,7 @@ char *chomp(char *string) * * Function : string_append * - * Description : Reallocate target_string and append text to it. + * Description : Reallocate target_string and append text to it. * This makes it easier to append to malloc'd strings. * This is similar to the (removed) strsav(), but * running out of memory isn't catastrophic. @@ -458,7 +537,7 @@ jb_err string_join(char **target_string, char *text_to_append) * Parameters : * 1 : string = string to convert * - * Returns : Uppercase copy of string if possible, + * Returns : Uppercase copy of string if possible, * NULL on out-of-memory or if string was NULL. * *********************************************************************/ @@ -471,7 +550,7 @@ char *string_toupper(const char *string) { return NULL; } - + q = string; p = result; @@ -485,6 +564,31 @@ char *string_toupper(const char *string) } +/********************************************************************* + * + * Function : string_move + * + * Description : memmove wrapper to move the last part of a string + * towards the beginning, overwriting the part in + * the middle. strlcpy() can't be used here as the + * strings overlap. + * + * Parameters : + * 1 : dst = Destination to overwrite + * 2 : src = Source to move. + * + * Returns : N/A + * + *********************************************************************/ +void string_move(char *dst, char *src) +{ + assert(dst < src); + + /* +1 to copy the terminating nul as well. */ + memmove(dst, src, strlen(src)+1); +} + + /********************************************************************* * * Function : bindup @@ -503,13 +607,10 @@ char *bindup(const char *string, size_t len) { char *duplicate; - if (NULL == (duplicate = (char *)malloc(len))) + duplicate = (char *)malloc(len); + if (NULL != duplicate) { - return NULL; - } - else - { - memcpy(duplicate, string, len); + memcpy(duplicate, string, len); } return duplicate; @@ -521,11 +622,11 @@ char *bindup(const char *string, size_t len) * * Function : make_path * - * Description : Takes a directory name and a file name, returns + * Description : Takes a directory name and a file name, returns * the complete path. Handles windows/unix differences. * If the file name is already an absolute path, or if - * the directory name is NULL or empty, it returns - * the filename. + * the directory name is NULL or empty, it returns + * the filename. * * Parameters : * 1 : dir: Name of directory or NULL for none. @@ -534,47 +635,11 @@ char *bindup(const char *string, size_t len) * Returns : "dir/file" (Or on windows, "dir\file"). * It allocates the string on the heap. Caller frees. * Returns NULL in error (i.e. NULL file or out of - * memory) + * memory) * *********************************************************************/ char * make_path(const char * dir, const char * file) { -#ifdef AMIGA - char path[512]; - - if(dir) - { - if(dir[0] == '.') - { - if(dir[1] == '/') - { - strncpy(path,dir+2,512); - } - else - { - strncpy(path,dir+1,512); - } - } - else - { - strncpy(path,dir,512); - } - path[511]=0; - } - else - { - path[0]=0; - } - if(AddPart(path,file,512)) - { - return strdup(path); - } - else - { - return NULL; - } -#else /* ndef AMIGA */ - if ((file == NULL) || (*file == '\0')) { return NULL; /* Error */ @@ -596,14 +661,14 @@ char * make_path(const char * dir, const char * file) size_t path_size = strlen(dir) + strlen(file) + 2; /* +2 for trailing (back)slash and \0 */ #if defined(unix) - if ( *dir != '/' && basedir && *basedir ) + if (*dir != '/' && basedir && *basedir) { /* * Relative path, so start with the base directory. */ path_size += strlen(basedir) + 1; /* +1 for the slash */ path = malloc(path_size); - if (!path ) log_error(LOG_LEVEL_FATAL, "malloc failed!"); + if (!path) log_error(LOG_LEVEL_FATAL, "malloc failed!"); strlcpy(path, basedir, path_size); strlcat(path, "/", path_size); strlcat(path, dir, path_size); @@ -612,18 +677,18 @@ char * make_path(const char * dir, const char * file) #endif /* defined unix */ { path = malloc(path_size); - if (!path ) log_error(LOG_LEVEL_FATAL, "malloc failed!"); + if (!path) log_error(LOG_LEVEL_FATAL, "malloc failed!"); strlcpy(path, dir, path_size); } assert(NULL != path); #if defined(_WIN32) || defined(__OS2__) - if(path[strlen(path)-1] != '\\') + if (path[strlen(path)-1] != '\\') { strlcat(path, "\\", path_size); } #else /* ifndef _WIN32 || __OS2__ */ - if(path[strlen(path)-1] != '/') + if (path[strlen(path)-1] != '/') { strlcat(path, "/", path_size); } @@ -632,7 +697,6 @@ char * make_path(const char * dir, const char * file) return path; } -#endif /* ndef AMIGA */ } @@ -647,7 +711,7 @@ char * make_path(const char * dir, const char * file) * Parameters : * 1 : range: Highest possible number to pick. * - * Returns : Picked number. + * Returns : Picked number. * *********************************************************************/ long int pick_from_range(long int range) @@ -662,8 +726,10 @@ long int pick_from_range(long int range) if (range <= 0) return 0; -#ifdef HAVE_RANDOM - number = random() % range + 1; +#ifdef HAVE_ARC4RANDOM + number = arc4random() % range + 1; +#elif defined(HAVE_RANDOM) + number = random() % range + 1; #elif defined(MUTEX_LOCKS_AVAILABLE) privoxy_mutex_lock(&rand_mutex); #ifdef _WIN32 @@ -686,7 +752,7 @@ long int pick_from_range(long int range) "might cause crashes, predictable results or even combine these fine options."); number = rand() % (long int)(range + 1); -#endif /* (def HAVE_RANDOM) */ +#endif /* (def HAVE_ARC4RANDOM) */ return number; } @@ -749,6 +815,45 @@ size_t privoxy_strlcat(char *destination, const char *source, const size_t size) #endif /* ndef HAVE_STRLCAT */ +/********************************************************************* + * + * Function : privoxy_millisleep + * + * Description : Sleep a number of milliseconds + * + * Parameters : + * 1 : delay: Number of milliseconds to sleep + * + * Returns : -1 on error, 0 otherwise + * + *********************************************************************/ +int privoxy_millisleep(unsigned milliseconds) +{ +#ifdef HAVE_NANOSLEEP + struct timespec rqtp = {0}; + struct timespec rmtp = {0}; + + rqtp.tv_sec = milliseconds / 1000; + rqtp.tv_nsec = (milliseconds % 1000) * 1000 * 1000; + + return nanosleep(&rqtp, &rmtp); +#elif defined (_WIN32) + Sleep(milliseconds); + + return 0; +#elif defined(__OS2__) + DosSleep(milliseconds * 10); + + return 0; +#else +#warning Missing privoxy_milisleep() implementation. delay-response{} will not work. + + return -1; +#endif /* def HAVE_NANOSLEEP */ + +} + + #if !defined(HAVE_TIMEGM) && defined(HAVE_TZSET) && defined(HAVE_PUTENV) /********************************************************************* * @@ -767,7 +872,7 @@ size_t privoxy_strlcat(char *destination, const char *source, const size_t size) * Parameters : * 1 : tm: Broken-down time struct. * - * Returns : tm converted into time_t seconds. + * Returns : tm converted into time_t seconds. * *********************************************************************/ time_t timegm(struct tm *tm) @@ -790,6 +895,16 @@ time_t timegm(struct tm *tm) strcat(old_zone, zone); putenv(old_zone); #ifdef _WIN32 + /* http://man7.org/linux/man-pages/man3/putenv.3.html + * int putenv(char *string); + * The string pointed to by string becomes part of the environment, so altering the + * string changes the environment. + * In other words, the memory pointed to by *string is used until + * a) another call to putenv() with the same e-var name + * b) the program exits + * + * Windows e-vars don't work that way, so let's not leak memory. + */ free(old_zone); #endif /* def _WIN32 */ } @@ -819,7 +934,7 @@ time_t timegm(struct tm *tm) snprintf.c - a portable implementation of snprintf, including vsnprintf.c, asnprintf, vasnprintf, asprintf, vasprintf - + snprintf is a routine to convert numeric and string arguments to formatted strings. It is similar to sprintf(3) provided in a system's C library, yet it requires an additional argument - the buffer size - @@ -1461,7 +1576,7 @@ int portable_vsnprintf(char *str, size_t str_m, const char *fmt, va_list ap) { } } /* zero padding to specified precision? */ - if (num_of_digits < precision) + if (num_of_digits < precision) number_of_zeros_to_pad = precision - num_of_digits; } /* zero padding to specified minimal field width? */