| /* |
| * String functions for CUPS. |
| * |
| * Copyright 2007-2014 by Apple Inc. |
| * Copyright 1997-2007 by Easy Software Products. |
| * |
| * These coded instructions, statements, and computer programs are the |
| * property of Apple Inc. and are protected by Federal copyright |
| * law. Distribution and use rights are outlined in the file "LICENSE.txt" |
| * which should have been included with this file. If this file is |
| * missing or damaged, see the license at "http://www.cups.org/". |
| * |
| * This file is subject to the Apple OS-Developed Software exception. |
| */ |
| |
| /* |
| * Include necessary headers... |
| */ |
| |
| #define _CUPS_STRING_C_ |
| #include "cups-private.h" |
| #include <stddef.h> |
| #include <limits.h> |
| |
| |
| /* |
| * Local globals... |
| */ |
| |
| static _cups_mutex_t sp_mutex = _CUPS_MUTEX_INITIALIZER; |
| /* Mutex to control access to pool */ |
| static cups_array_t *stringpool = NULL; |
| /* Global string pool */ |
| |
| |
| /* |
| * Local functions... |
| */ |
| |
| static int compare_sp_items(_cups_sp_item_t *a, _cups_sp_item_t *b); |
| |
| |
| /* |
| * '_cupsStrAlloc()' - Allocate/reference a string. |
| */ |
| |
| char * /* O - String pointer */ |
| _cupsStrAlloc(const char *s) /* I - String */ |
| { |
| size_t slen; /* Length of string */ |
| _cups_sp_item_t *item, /* String pool item */ |
| *key; /* Search key */ |
| |
| |
| /* |
| * Range check input... |
| */ |
| |
| if (!s) |
| return (NULL); |
| |
| /* |
| * Get the string pool... |
| */ |
| |
| _cupsMutexLock(&sp_mutex); |
| |
| if (!stringpool) |
| stringpool = cupsArrayNew((cups_array_func_t)compare_sp_items, NULL); |
| |
| if (!stringpool) |
| { |
| _cupsMutexUnlock(&sp_mutex); |
| |
| return (NULL); |
| } |
| |
| /* |
| * See if the string is already in the pool... |
| */ |
| |
| key = (_cups_sp_item_t *)(s - offsetof(_cups_sp_item_t, str)); |
| |
| if ((item = (_cups_sp_item_t *)cupsArrayFind(stringpool, key)) != NULL) |
| { |
| /* |
| * Found it, return the cached string... |
| */ |
| |
| item->ref_count ++; |
| |
| #ifdef DEBUG_GUARDS |
| DEBUG_printf(("5_cupsStrAlloc: Using string %p(%s) for \"%s\", guard=%08x, " |
| "ref_count=%d", item, item->str, s, item->guard, |
| item->ref_count)); |
| |
| if (item->guard != _CUPS_STR_GUARD) |
| abort(); |
| #endif /* DEBUG_GUARDS */ |
| |
| _cupsMutexUnlock(&sp_mutex); |
| |
| return (item->str); |
| } |
| |
| /* |
| * Not found, so allocate a new one... |
| */ |
| |
| slen = strlen(s); |
| item = (_cups_sp_item_t *)calloc(1, sizeof(_cups_sp_item_t) + slen); |
| if (!item) |
| { |
| _cupsMutexUnlock(&sp_mutex); |
| |
| return (NULL); |
| } |
| |
| item->ref_count = 1; |
| memcpy(item->str, s, slen + 1); |
| |
| #ifdef DEBUG_GUARDS |
| item->guard = _CUPS_STR_GUARD; |
| |
| DEBUG_printf(("5_cupsStrAlloc: Created string %p(%s) for \"%s\", guard=%08x, " |
| "ref_count=%d", item, item->str, s, item->guard, |
| item->ref_count)); |
| #endif /* DEBUG_GUARDS */ |
| |
| /* |
| * Add the string to the pool and return it... |
| */ |
| |
| cupsArrayAdd(stringpool, item); |
| |
| _cupsMutexUnlock(&sp_mutex); |
| |
| return (item->str); |
| } |
| |
| |
| /* |
| * '_cupsStrDate()' - Return a localized date for a given time value. |
| * |
| * This function works around the locale encoding issues of strftime... |
| */ |
| |
| char * /* O - Buffer */ |
| _cupsStrDate(char *buf, /* I - Buffer */ |
| size_t bufsize, /* I - Size of buffer */ |
| time_t timeval) /* I - Time value */ |
| { |
| struct tm *dateval; /* Local date/time */ |
| char temp[1024]; /* Temporary buffer */ |
| _cups_globals_t *cg = _cupsGlobals(); /* Per-thread globals */ |
| |
| |
| if (!cg->lang_default) |
| cg->lang_default = cupsLangDefault(); |
| |
| dateval = localtime(&timeval); |
| |
| if (cg->lang_default->encoding != CUPS_UTF8) |
| { |
| strftime(temp, sizeof(temp), "%c", dateval); |
| cupsCharsetToUTF8((cups_utf8_t *)buf, temp, (int)bufsize, cg->lang_default->encoding); |
| } |
| else |
| strftime(buf, bufsize, "%c", dateval); |
| |
| return (buf); |
| } |
| |
| |
| /* |
| * '_cupsStrFlush()' - Flush the string pool. |
| */ |
| |
| void |
| _cupsStrFlush(void) |
| { |
| _cups_sp_item_t *item; /* Current item */ |
| |
| |
| DEBUG_printf(("4_cupsStrFlush: %d strings in array", |
| cupsArrayCount(stringpool))); |
| |
| _cupsMutexLock(&sp_mutex); |
| |
| for (item = (_cups_sp_item_t *)cupsArrayFirst(stringpool); |
| item; |
| item = (_cups_sp_item_t *)cupsArrayNext(stringpool)) |
| free(item); |
| |
| cupsArrayDelete(stringpool); |
| stringpool = NULL; |
| |
| _cupsMutexUnlock(&sp_mutex); |
| } |
| |
| |
| /* |
| * '_cupsStrFormatd()' - Format a floating-point number. |
| */ |
| |
| char * /* O - Pointer to end of string */ |
| _cupsStrFormatd(char *buf, /* I - String */ |
| char *bufend, /* I - End of string buffer */ |
| double number, /* I - Number to format */ |
| struct lconv *loc) /* I - Locale data */ |
| { |
| char *bufptr, /* Pointer into buffer */ |
| temp[1024], /* Temporary string */ |
| *tempdec, /* Pointer to decimal point */ |
| *tempptr; /* Pointer into temporary string */ |
| const char *dec; /* Decimal point */ |
| int declen; /* Length of decimal point */ |
| |
| |
| /* |
| * Format the number using the "%.12f" format and then eliminate |
| * unnecessary trailing 0's. |
| */ |
| |
| snprintf(temp, sizeof(temp), "%.12f", number); |
| for (tempptr = temp + strlen(temp) - 1; |
| tempptr > temp && *tempptr == '0'; |
| *tempptr-- = '\0'); |
| |
| /* |
| * Next, find the decimal point... |
| */ |
| |
| if (loc && loc->decimal_point) |
| { |
| dec = loc->decimal_point; |
| declen = (int)strlen(dec); |
| } |
| else |
| { |
| dec = "."; |
| declen = 1; |
| } |
| |
| if (declen == 1) |
| tempdec = strchr(temp, *dec); |
| else |
| tempdec = strstr(temp, dec); |
| |
| /* |
| * Copy everything up to the decimal point... |
| */ |
| |
| if (tempdec) |
| { |
| for (tempptr = temp, bufptr = buf; |
| tempptr < tempdec && bufptr < bufend; |
| *bufptr++ = *tempptr++); |
| |
| tempptr += declen; |
| |
| if (*tempptr && bufptr < bufend) |
| { |
| *bufptr++ = '.'; |
| |
| while (*tempptr && bufptr < bufend) |
| *bufptr++ = *tempptr++; |
| } |
| |
| *bufptr = '\0'; |
| } |
| else |
| { |
| strlcpy(buf, temp, (size_t)(bufend - buf + 1)); |
| bufptr = buf + strlen(buf); |
| } |
| |
| return (bufptr); |
| } |
| |
| |
| /* |
| * '_cupsStrFree()' - Free/dereference a string. |
| */ |
| |
| void |
| _cupsStrFree(const char *s) /* I - String to free */ |
| { |
| _cups_sp_item_t *item, /* String pool item */ |
| *key; /* Search key */ |
| |
| |
| /* |
| * Range check input... |
| */ |
| |
| if (!s) |
| return; |
| |
| /* |
| * Check the string pool... |
| * |
| * We don't need to lock the mutex yet, as we only want to know if |
| * the stringpool is initialized. The rest of the code will still |
| * work if it is initialized before we lock... |
| */ |
| |
| if (!stringpool) |
| return; |
| |
| /* |
| * See if the string is already in the pool... |
| */ |
| |
| _cupsMutexLock(&sp_mutex); |
| |
| key = (_cups_sp_item_t *)(s - offsetof(_cups_sp_item_t, str)); |
| |
| #ifdef DEBUG_GUARDS |
| if (key->guard != _CUPS_STR_GUARD) |
| { |
| DEBUG_printf(("5_cupsStrFree: Freeing string %p(%s), guard=%08x, " |
| "ref_count=%d", key, key->str, key->guard, key->ref_count)); |
| abort(); |
| } |
| #endif /* DEBUG_GUARDS */ |
| |
| if ((item = (_cups_sp_item_t *)cupsArrayFind(stringpool, key)) != NULL && |
| item == key) |
| { |
| /* |
| * Found it, dereference... |
| */ |
| |
| item->ref_count --; |
| |
| if (!item->ref_count) |
| { |
| /* |
| * Remove and free... |
| */ |
| |
| cupsArrayRemove(stringpool, item); |
| |
| free(item); |
| } |
| } |
| |
| _cupsMutexUnlock(&sp_mutex); |
| } |
| |
| |
| /* |
| * '_cupsStrRetain()' - Increment the reference count of a string. |
| * |
| * Note: This function does not verify that the passed pointer is in the |
| * string pool, so any calls to it MUST know they are passing in a |
| * good pointer. |
| */ |
| |
| char * /* O - Pointer to string */ |
| _cupsStrRetain(const char *s) /* I - String to retain */ |
| { |
| _cups_sp_item_t *item; /* Pointer to string pool item */ |
| |
| |
| if (s) |
| { |
| item = (_cups_sp_item_t *)(s - offsetof(_cups_sp_item_t, str)); |
| |
| #ifdef DEBUG_GUARDS |
| if (item->guard != _CUPS_STR_GUARD) |
| { |
| DEBUG_printf(("5_cupsStrRetain: Retaining string %p(%s), guard=%08x, " |
| "ref_count=%d", item, s, item->guard, item->ref_count)); |
| abort(); |
| } |
| #endif /* DEBUG_GUARDS */ |
| |
| _cupsMutexLock(&sp_mutex); |
| |
| item->ref_count ++; |
| |
| _cupsMutexUnlock(&sp_mutex); |
| } |
| |
| return ((char *)s); |
| } |
| |
| |
| /* |
| * '_cupsStrScand()' - Scan a string for a floating-point number. |
| * |
| * This function handles the locale-specific BS so that a decimal |
| * point is always the period (".")... |
| */ |
| |
| double /* O - Number */ |
| _cupsStrScand(const char *buf, /* I - Pointer to number */ |
| char **bufptr, /* O - New pointer or NULL on error */ |
| struct lconv *loc) /* I - Locale data */ |
| { |
| char temp[1024], /* Temporary buffer */ |
| *tempptr; /* Pointer into temporary buffer */ |
| |
| |
| /* |
| * Range check input... |
| */ |
| |
| if (!buf) |
| return (0.0); |
| |
| /* |
| * Skip leading whitespace... |
| */ |
| |
| while (_cups_isspace(*buf)) |
| buf ++; |
| |
| /* |
| * Copy leading sign, numbers, period, and then numbers... |
| */ |
| |
| tempptr = temp; |
| if (*buf == '-' || *buf == '+') |
| *tempptr++ = *buf++; |
| |
| while (isdigit(*buf & 255)) |
| if (tempptr < (temp + sizeof(temp) - 1)) |
| *tempptr++ = *buf++; |
| else |
| { |
| if (bufptr) |
| *bufptr = NULL; |
| |
| return (0.0); |
| } |
| |
| if (*buf == '.') |
| { |
| /* |
| * Read fractional portion of number... |
| */ |
| |
| buf ++; |
| |
| if (loc && loc->decimal_point) |
| { |
| strlcpy(tempptr, loc->decimal_point, sizeof(temp) - (size_t)(tempptr - temp)); |
| tempptr += strlen(tempptr); |
| } |
| else if (tempptr < (temp + sizeof(temp) - 1)) |
| *tempptr++ = '.'; |
| else |
| { |
| if (bufptr) |
| *bufptr = NULL; |
| |
| return (0.0); |
| } |
| |
| while (isdigit(*buf & 255)) |
| if (tempptr < (temp + sizeof(temp) - 1)) |
| *tempptr++ = *buf++; |
| else |
| { |
| if (bufptr) |
| *bufptr = NULL; |
| |
| return (0.0); |
| } |
| } |
| |
| if (*buf == 'e' || *buf == 'E') |
| { |
| /* |
| * Read exponent... |
| */ |
| |
| if (tempptr < (temp + sizeof(temp) - 1)) |
| *tempptr++ = *buf++; |
| else |
| { |
| if (bufptr) |
| *bufptr = NULL; |
| |
| return (0.0); |
| } |
| |
| if (*buf == '+' || *buf == '-') |
| { |
| if (tempptr < (temp + sizeof(temp) - 1)) |
| *tempptr++ = *buf++; |
| else |
| { |
| if (bufptr) |
| *bufptr = NULL; |
| |
| return (0.0); |
| } |
| } |
| |
| while (isdigit(*buf & 255)) |
| if (tempptr < (temp + sizeof(temp) - 1)) |
| *tempptr++ = *buf++; |
| else |
| { |
| if (bufptr) |
| *bufptr = NULL; |
| |
| return (0.0); |
| } |
| } |
| |
| /* |
| * Nul-terminate the temporary string and return the value... |
| */ |
| |
| if (bufptr) |
| *bufptr = (char *)buf; |
| |
| *tempptr = '\0'; |
| |
| return (strtod(temp, NULL)); |
| } |
| |
| |
| /* |
| * '_cupsStrStatistics()' - Return allocation statistics for string pool. |
| */ |
| |
| size_t /* O - Number of strings */ |
| _cupsStrStatistics(size_t *alloc_bytes, /* O - Allocated bytes */ |
| size_t *total_bytes) /* O - Total string bytes */ |
| { |
| size_t count, /* Number of strings */ |
| abytes, /* Allocated string bytes */ |
| tbytes, /* Total string bytes */ |
| len; /* Length of string */ |
| _cups_sp_item_t *item; /* Current item */ |
| |
| |
| /* |
| * Loop through strings in pool, counting everything up... |
| */ |
| |
| _cupsMutexLock(&sp_mutex); |
| |
| for (count = 0, abytes = 0, tbytes = 0, |
| item = (_cups_sp_item_t *)cupsArrayFirst(stringpool); |
| item; |
| item = (_cups_sp_item_t *)cupsArrayNext(stringpool)) |
| { |
| /* |
| * Count allocated memory, using a 64-bit aligned buffer as a basis. |
| */ |
| |
| count += item->ref_count; |
| len = (strlen(item->str) + 8) & (size_t)~7; |
| abytes += sizeof(_cups_sp_item_t) + len; |
| tbytes += item->ref_count * len; |
| } |
| |
| _cupsMutexUnlock(&sp_mutex); |
| |
| /* |
| * Return values... |
| */ |
| |
| if (alloc_bytes) |
| *alloc_bytes = abytes; |
| |
| if (total_bytes) |
| *total_bytes = tbytes; |
| |
| return (count); |
| } |
| |
| |
| /* |
| * '_cups_strcpy()' - Copy a string allowing for overlapping strings. |
| */ |
| |
| void |
| _cups_strcpy(char *dst, /* I - Destination string */ |
| const char *src) /* I - Source string */ |
| { |
| while (*src) |
| *dst++ = *src++; |
| |
| *dst = '\0'; |
| } |
| |
| |
| /* |
| * '_cups_strdup()' - Duplicate a string. |
| */ |
| |
| #ifndef HAVE_STRDUP |
| char * /* O - New string pointer */ |
| _cups_strdup(const char *s) /* I - String to duplicate */ |
| { |
| char *t; /* New string pointer */ |
| size_t slen; /* Length of string */ |
| |
| |
| if (!s) |
| return (NULL); |
| |
| slen = strlen(s); |
| if ((t = malloc(slen + 1)) == NULL) |
| return (NULL); |
| |
| return (memcpy(t, s, slen + 1)); |
| } |
| #endif /* !HAVE_STRDUP */ |
| |
| |
| /* |
| * '_cups_strcasecmp()' - Do a case-insensitive comparison. |
| */ |
| |
| int /* O - Result of comparison (-1, 0, or 1) */ |
| _cups_strcasecmp(const char *s, /* I - First string */ |
| const char *t) /* I - Second string */ |
| { |
| while (*s != '\0' && *t != '\0') |
| { |
| if (_cups_tolower(*s) < _cups_tolower(*t)) |
| return (-1); |
| else if (_cups_tolower(*s) > _cups_tolower(*t)) |
| return (1); |
| |
| s ++; |
| t ++; |
| } |
| |
| if (*s == '\0' && *t == '\0') |
| return (0); |
| else if (*s != '\0') |
| return (1); |
| else |
| return (-1); |
| } |
| |
| /* |
| * '_cups_strncasecmp()' - Do a case-insensitive comparison on up to N chars. |
| */ |
| |
| int /* O - Result of comparison (-1, 0, or 1) */ |
| _cups_strncasecmp(const char *s, /* I - First string */ |
| const char *t, /* I - Second string */ |
| size_t n) /* I - Maximum number of characters to compare */ |
| { |
| while (*s != '\0' && *t != '\0' && n > 0) |
| { |
| if (_cups_tolower(*s) < _cups_tolower(*t)) |
| return (-1); |
| else if (_cups_tolower(*s) > _cups_tolower(*t)) |
| return (1); |
| |
| s ++; |
| t ++; |
| n --; |
| } |
| |
| if (n == 0) |
| return (0); |
| else if (*s == '\0' && *t == '\0') |
| return (0); |
| else if (*s != '\0') |
| return (1); |
| else |
| return (-1); |
| } |
| |
| |
| #ifndef HAVE_STRLCAT |
| /* |
| * '_cups_strlcat()' - Safely concatenate two strings. |
| */ |
| |
| size_t /* O - Length of string */ |
| _cups_strlcat(char *dst, /* O - Destination string */ |
| const char *src, /* I - Source string */ |
| size_t size) /* I - Size of destination string buffer */ |
| { |
| size_t srclen; /* Length of source string */ |
| size_t dstlen; /* Length of destination string */ |
| |
| |
| /* |
| * Figure out how much room is left... |
| */ |
| |
| dstlen = strlen(dst); |
| |
| if (size < (dstlen + 1)) |
| return (dstlen); /* No room, return immediately... */ |
| |
| size -= dstlen + 1; |
| |
| /* |
| * Figure out how much room is needed... |
| */ |
| |
| srclen = strlen(src); |
| |
| /* |
| * Copy the appropriate amount... |
| */ |
| |
| if (srclen > size) |
| srclen = size; |
| |
| memmove(dst + dstlen, src, srclen); |
| dst[dstlen + srclen] = '\0'; |
| |
| return (dstlen + srclen); |
| } |
| #endif /* !HAVE_STRLCAT */ |
| |
| |
| #ifndef HAVE_STRLCPY |
| /* |
| * '_cups_strlcpy()' - Safely copy two strings. |
| */ |
| |
| size_t /* O - Length of string */ |
| _cups_strlcpy(char *dst, /* O - Destination string */ |
| const char *src, /* I - Source string */ |
| size_t size) /* I - Size of destination string buffer */ |
| { |
| size_t srclen; /* Length of source string */ |
| |
| |
| /* |
| * Figure out how much room is needed... |
| */ |
| |
| size --; |
| |
| srclen = strlen(src); |
| |
| /* |
| * Copy the appropriate amount... |
| */ |
| |
| if (srclen > size) |
| srclen = size; |
| |
| memmove(dst, src, srclen); |
| dst[srclen] = '\0'; |
| |
| return (srclen); |
| } |
| #endif /* !HAVE_STRLCPY */ |
| |
| |
| /* |
| * 'compare_sp_items()' - Compare two string pool items... |
| */ |
| |
| static int /* O - Result of comparison */ |
| compare_sp_items(_cups_sp_item_t *a, /* I - First item */ |
| _cups_sp_item_t *b) /* I - Second item */ |
| { |
| return (strcmp(a->str, b->str)); |
| } |