X-Git-Url: http://www.privoxy.org/gitweb/?p=privoxy.git;a=blobdiff_plain;f=miscutil.c;h=9af7bed3a78aae904a5ea317e4ecb39fca2e5a12;hp=a002abb7bd18a17673f2ef67d8f170e4929cb093;hb=da6d6e7115b36cd4e03460c9c49a212edacb159a;hpb=50f87c9446b435d47c371f63615260636639f450 diff --git a/miscutil.c b/miscutil.c index a002abb7..9af7bed3 100644 --- a/miscutil.c +++ b/miscutil.c @@ -1,4 +1,3 @@ -const char miscutil_rcs[] = "$Id: miscutil.c,v 1.74 2012/03/09 16:23:50 fabiankeil Exp $"; /********************************************************************* * * File : $Source: /cvsroot/ijbswa/current/miscutil.c,v $ @@ -8,8 +7,8 @@ const char miscutil_rcs[] = "$Id: miscutil.c,v 1.74 2012/03/09 16:23:50 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 @@ -63,36 +62,73 @@ const char miscutil_rcs[] = "$Id: miscutil.c,v 1.74 2012/03/09 16:23:50 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'. + * 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); } +/********************************************************************* + * + * Function : zalloc_or_die + * + * Description : zalloc wrapper that either succeeds or causes + * program termination. + * + * 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(). + * + * Parameters : + * 1 : size = Size of memory chunk to return. + * + * Returns : Pointer to newly malloc'd memory chunk. + * + *********************************************************************/ +void *zalloc_or_die(size_t size) +{ + void *buffer; + + buffer = zalloc(size); + if (buffer == NULL) + { + assert(buffer != NULL); + log_error(LOG_LEVEL_FATAL, "Out of memory in zalloc_or_die()."); + exit(1); + } + + return(buffer); + +} + /********************************************************************* * * Function : strdup_or_die @@ -129,31 +165,71 @@ char *strdup_or_die(const char *str) } +/********************************************************************* + * + * Function : malloc_or_die + * + * 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 : buffer_size = Size of the space to allocate + * + * Returns : Pointer to newly malloc'd memory + * + *********************************************************************/ +void *malloc_or_die(size_t buffer_size) +{ + char *new_buf; + + if (buffer_size == 0) + { + log_error(LOG_LEVEL_ERROR, + "malloc_or_die() called with buffer size 0"); + assert(buffer_size != 0); + buffer_size = 4096; + } + + 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); + +} + + #if defined(unix) /********************************************************************* * * Function : write_pid_file * - * Description : Writes a pid file with the pid of the main process + * Description : Writes a pid file with the pid of the main process. + * Exits if the file can't be opened * - * Parameters : None + * Parameters : + * 1 : pidfile = Path of the pidfile that gets created. * * Returns : N/A * *********************************************************************/ -void write_pid_file(void) +void write_pid_file(const char *pidfile) { FILE *fp; - /* - * If no --pidfile option was given, - * we can live without one. - */ - if (pidfile == NULL) return; - if ((fp = fopen(pidfile, "w")) == NULL) { - log_error(LOG_LEVEL_INFO, "can't open pidfile '%s': %E", pidfile); + log_error(LOG_LEVEL_FATAL, "can't open pidfile '%s': %E", pidfile); } else { @@ -213,7 +289,7 @@ int strcmpic(const char *s1, const char *s2) while (*s1 && *s2) { - if (( *s1 != *s2) && ( privoxy_tolower(*s1) != privoxy_tolower(*s2) ) ) + if ((*s1 != *s2) && (privoxy_tolower(*s1) != privoxy_tolower(*s2))) { break; } @@ -246,7 +322,7 @@ int strncmpic(const char *s1, const char *s2, size_t n) while (*s1 && *s2) { - if (( *s1 != *s2) && ( privoxy_tolower(*s1) != privoxy_tolower(*s2) ) ) + if ((*s1 != *s2) && (privoxy_tolower(*s1) != privoxy_tolower(*s2))) { break; } @@ -488,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 @@ -539,42 +640,6 @@ char *bindup(const char *string, size_t len) *********************************************************************/ 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 */ @@ -586,7 +651,7 @@ char * make_path(const char * dir, const char * file) #else /* ifndef _WIN32 || __OS2__ */ || (*file == '/') /* Absolute path (U*ix) */ #endif /* ifndef _WIN32 || __OS2__ */ - ) + ) { return strdup(file); } @@ -632,7 +697,6 @@ char * make_path(const char * dir, const char * file) return path; } -#endif /* ndef AMIGA */ } @@ -662,7 +726,9 @@ long int pick_from_range(long int range) if (range <= 0) return 0; -#ifdef HAVE_RANDOM +#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); @@ -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) /********************************************************************* * @@ -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 */ } @@ -1374,7 +1489,7 @@ int portable_vsnprintf(char *str, size_t str_m, const char *fmt, va_list ap) { tmp[str_arg_l++] = space_for_positive ? ' ' : '+'; #endif } else if (alternate_form) { - if (arg_sign != 0 && (fmt_spec == 'x' || fmt_spec == 'X')) + if (arg_sign != 0 && (fmt_spec == 'x' || fmt_spec == 'X') ) { tmp[str_arg_l++] = '0'; tmp[str_arg_l++] = fmt_spec; } /* alternate form should have no effect for p conversion, but ... */ #ifdef HPUX_COMPATIBLE @@ -1385,7 +1500,7 @@ int portable_vsnprintf(char *str, size_t str_m, const char *fmt, va_list ap) { /* Actually it uses 0x prefix even for a zero value. */ && arg_sign != 0 #endif - ) { tmp[str_arg_l++] = '0'; tmp[str_arg_l++] = 'x'; } + ) { tmp[str_arg_l++] = '0'; tmp[str_arg_l++] = 'x'; } #endif } zero_padding_insertion_ind = str_arg_l; @@ -1397,7 +1512,7 @@ int portable_vsnprintf(char *str, size_t str_m, const char *fmt, va_list ap) { * converting a zero value with a precision of zero is a null string. * Actually HP returns all zeroes, and Linux returns "(nil)". */ #endif - ) { + ) { /* converted to null string */ /* When zero value is formatted with an explicit precision 0, the resulting formatted string is empty (d, i, u, o, x, X, p). */ @@ -1437,7 +1552,7 @@ int portable_vsnprintf(char *str, size_t str_m, const char *fmt, va_list ap) { if (zero_padding_insertion_ind+1 < str_arg_l && tmp[zero_padding_insertion_ind] == '0' && (tmp[zero_padding_insertion_ind+1] == 'x' || - tmp[zero_padding_insertion_ind+1] == 'X')) { + tmp[zero_padding_insertion_ind+1] == 'X') ) { zero_padding_insertion_ind += 2; } } @@ -1452,7 +1567,7 @@ int portable_vsnprintf(char *str, size_t str_m, const char *fmt, va_list ap) { && !(zero_padding_insertion_ind < str_arg_l && tmp[zero_padding_insertion_ind] == '0') #endif - ) { /* assure leading zero for alternate-form octal numbers */ + ) { /* assure leading zero for alternate-form octal numbers */ if (!precision_specified || precision < num_of_digits+1) { /* precision is increased to force the first character to be zero, except if a zero value is formatted with an explicit precision