int process_verify(char* path, char* hash) { size_t computed_hash_len = 0u; uint8_t computed_hash[EVP_MAX_MD_SIZE]; uint8_t hash_buf[EVP_MAX_MD_SIZE * 2]; if (process_hash(path, computed_hash, &computed_hash_len)) { return 1; } strcpy((char*) hash_buf, hash); for (size_t i = 0; i < computed_hash_len; i++) { if (!isxdigit(hash_buf[2*i]) || !isxdigit(hash_buf[2*i+1])) { printf( "ERROR: invalid hash byte (%c%c)\n", hash_buf[2*i], hash_buf[2*i+1]); return 1; } hash_buf[i] = (digittoint(hash_buf[2*i]) << 4) | digittoint(hash_buf[2*i+1]); } if (!memcmp(computed_hash, hash_buf, computed_hash_len)) { printf("OK\n"); } else { printf("MISMATCH\n"); } return 0; }
/* * Scan a string of hexadecimal digits (the format nan(3) expects) and * make a bit array (using the local endianness). We stop when we * encounter an invalid character, NUL, etc. If we overflow, we do * the same as gcc's __builtin_nan(), namely, discard the high order bits. * * The format this routine accepts needs to be compatible with what is used * in contrib/gdtoa/hexnan.c (for strtod/scanf) and what is used in * __builtin_nan(). In fact, we're only 100% compatible for strings we * consider valid, so we might be violating the C standard. But it's * impossible to use nan(3) portably anyway, so this seems good enough. */ void _scan_nan(uint32_t *words, int num_words, const char *s) { int si; /* index into s */ int bitpos; /* index into words (in bits) */ bzero(words, num_words * sizeof(uint32_t)); /* Allow a leading '0x'. (It's expected, but redundant.) */ if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X')) s += 2; /* Scan forwards in the string, looking for the end of the sequence. */ for (si = 0; isxdigit(s[si]); si++) ; /* Scan backwards, filling in the bits in words[] as we go. */ #if _BYTE_ORDER == _LITTLE_ENDIAN for (bitpos = 0; bitpos < 32 * num_words; bitpos += 4) { #else for (bitpos = 32 * num_words - 4; bitpos >= 0; bitpos -= 4) { #endif if (--si < 0) break; words[bitpos / 32] |= digittoint(s[si]) << (bitpos % 32); } } double nan(const char *s) { union { double d; uint32_t bits[2]; } u; _scan_nan(u.bits, 2, s); #if _BYTE_ORDER == _LITTLE_ENDIAN u.bits[1] |= 0x7ff80000; #else u.bits[0] |= 0x7ff80000; #endif return (u.d); } float nanf(const char *s) { union { float f; uint32_t bits[1]; } u; _scan_nan(u.bits, 1, s); u.bits[0] |= 0x7fc00000; return (u.f); } #if (LDBL_MANT_DIG == 53) __weak_alias(nanl, nan);
static int parseDigits(const char* str, const char* end) { int result = 0; for (; str < end; ++str) { if (!isdigit(*str)) return 0; result = 10*result + digittoint(*str); } return result; }
static void parse_ports(const char *portspec) { const char *p, *q; int port, end; if (ports == NULL) if ((ports = (int *)calloc(65536 / INT_BIT, sizeof(int))) == NULL) err(1, "calloc()"); p = portspec; while (*p != '\0') { if (!isdigit(*p)) errx(1, "syntax error in port range"); for (q = p; *q != '\0' && isdigit(*q); ++q) /* nothing */ ; for (port = 0; p < q; ++p) port = port * 10 + digittoint(*p); if (port < 0 || port > 65535) errx(1, "invalid port number"); SET_PORT(port); switch (*p) { case '-': ++p; break; case ',': ++p; /* fall through */ case '\0': default: continue; } for (q = p; *q != '\0' && isdigit(*q); ++q) /* nothing */ ; for (end = 0; p < q; ++p) end = end * 10 + digittoint(*p); if (end < port || end > 65535) errx(1, "invalid port number"); while (port++ < end) SET_PORT(port); if (*p == ',') ++p; } }
static int getdata(const char *arg, u_int8_t *data, int maxlen) { const char *cp = arg; int len; if (cp[0] == '0' && (cp[1] == 'x' || cp[1] == 'X')) cp += 2; len = 0; while (*cp) { int b0, b1; if (cp[0] == ':' || cp[0] == '-' || cp[0] == '.') { cp++; continue; } if (!isxdigit(cp[0])) { fprintf(stderr, "%s: invalid data value %c (not hex)\n", progname, cp[0]); exit(-1); } b0 = digittoint(cp[0]); if (cp[1] != '\0') { if (!isxdigit(cp[1])) { fprintf(stderr, "%s: invalid data value %c " "(not hex)\n", progname, cp[1]); exit(-1); } b1 = digittoint(cp[1]); cp += 2; } else { /* fake up 0<n> */ b1 = b0, b0 = 0; cp += 1; } if (len > maxlen) { fprintf(stderr, "%s: too much data in %s, max %u bytes\n", progname, arg, maxlen); } data[len++] = (b0<<4) | b1; } return len; }
static char convertEscape(const char **in) { char c = *++(*in); switch (c) { case 'u': { // \u is a Unicode escape; 4 hex digits follow. const char* digits = *in + 1; *in += 4; int uc = (digittoint(digits[0]) << 12) | (digittoint(digits[1]) << 8) | (digittoint(digits[2]) << 4) | (digittoint(digits[3])); if (uc > 127) LOGW("SQLiteJsonCollator can't correctly compare \\u%.4s", digits); return (char)uc; } case 'b': return '\b'; case 'n': return '\n'; case 'r': return '\r'; case 't': return '\t'; default: return c; } }
/** * Convert string into a bitset. Inverse of bitset_to_str(). * */ bitset *str_to_bitset(char *str, char **end) { int nbits = 0; int bytes; int n; int pos; int b; int len; bitset *bp; char dst[1024]; if (!str) return NULL; /* hex string has 0x prefix */ if (str[0] == '0' && str[1] == 'x') str = str + 2; len = strlen(str); if (len % 2) { nbits = (len + 1) << 2; bytes = NUM_BYTES(nbits); pos = (bytes << 3) - 5; } else { nbits = len << 2; bytes = NUM_BYTES(nbits); pos = (bytes << 3) - 1; } if (0) hex2binary(str, dst); bp = bitset_new(nbits); for (; *str != '\0' && isxdigit(*str) && pos >= 0; str++) { b = digittoint(*str); for (n = 3; n >= 0; n--, pos--) { if (b & (1 << n)) { bitset_set(bp, pos); } } } if (end != NULL) *end = str - 1; return bp; }
/* * Convert a hexadecimal string containing len digits into an integer. */ unsigned int hex_str_to_int(char *str, int len, char **end) { int n; unsigned int val = 0; for (n = 0; n < len && *str != '\0' && isxdigit(*str); n++, str++) { val <<= 4; val += digittoint(*str); } if (end != NULL) { *end = str; } return val; }
char *colon_convert( char *source ) { char *result = NULL; int colon_count = 0; char *temp = source; int found = 0; while( *temp != '\0' ) { if( *(temp++) == ':' ) colon_count++; } if( colon_count > 0 ) { result = malloc( strlen(source) + (colon_count*4) + 1 ); char *dest = result; while( *source != '\0' ) { if( *source == ':' ) { if( source[1] != '\0' || source[2] != '\0' ) { if( is_cap_hex(source[1]) && is_cap_hex(source[2]) ) { char in_buffer; in_buffer = (digittoint(source[1]) << 4) + digittoint(source[2]); *(dest++) = in_buffer; found = 1; source += 3; } else { *(dest++) = *(source++); } } else { *(dest++) = *(source++); } } else { *(dest++) = *(source++); } } *dest = '\0'; if( found == 0 ) { free( result ); result = NULL; } } return result; }
JNIEXPORT jint JNICALL Java_com_couchbase_lite_android_SQLiteJsonCollator_testDigitToInt (JNIEnv *env, jclass clazz, jint digit) { int result = digittoint(digit); return result; }
bool parseVersionString(CFStringRef string, struct Version *outVersion) { if (!string) { return false; } bool parsed = true; unsigned myMajor = 0U, myMinor = 0U, myIncremental = 0U, myReleaseType = releaseType_release, myDevelopment = 0U; CFIndex maxAllocation = getpagesize(); CFRange range = { 0, CFStringGetLength(string) }; Boolean canConvert = CFStringGetBytes(string, range, kCFStringEncodingUTF8, /*lossByte*/ 0U, /*isExternalRepresentation*/ false, /*buffer*/ NULL, maxAllocation, &maxAllocation); if (!canConvert) { return false; } char *buf = malloc(maxAllocation); if (!buf) { return false; } CFIndex i = 0; CFIndex length = 0; canConvert = CFStringGetBytes(string, range, kCFStringEncodingUTF8, /*lossByte*/ 0U, /*isExternalRepresentation*/ false, (UInt8 *)buf, maxAllocation, &length); if (canConvert) { //converted to UTF-8 successfully. parse it. while ((i < length) && isspace(buf[i])) { ++i; } if (!isdigit(buf[i])) { parsed = false; goto end; } //major version while (i < length) { if (!isdigit(buf[i])) { break; } myMajor *= 10U; myMajor += digittoint(buf[i++]); } if (i >= length) { goto end; } //separator if (buf[i] != '.') { goto end; } ++i; //minor version while (i < length) { if (!isdigit(buf[i])) { break; } myMinor *= 10U; myMinor += digittoint(buf[i++]); } if (i >= length) { goto end; } //separator if (buf[i] == '.') { ++i; //incremental version while (i < length) { if (!isdigit(buf[i])) { break; } myIncremental *= 10U; myIncremental += digittoint(buf[i++]); } if (i > length) { goto end; } } //release type if (i != length) { while ((i < length) && isspace(buf[i])) ++i; if (i < length) { char releaseTypeChar = tolower(buf[i++]); switch (releaseTypeChar) { case 'b': myReleaseType = releaseType_beta; break; case 'a': myReleaseType = releaseType_alpha; break; case 'd': myReleaseType = releaseType_development; break; case 's': myReleaseType = releaseType_svn; if ((i < length) && (buf[i] == 'v')) { ++i; if ((i < length) && (buf[i] == 'n')) { ++i; } } break; case 'h': myReleaseType = releaseType_svn; if ((i < length) && (buf[i] == 'g')) { ++i; } break; } while ((i < length) && isspace(buf[i])) { ++i; } //for example: "0.6.2 SVN r1558". we want to skip the 'r'. if ((i < length) && (myReleaseType == releaseType_svn) && (tolower(buf[i]) == 'r')) { ++i; } //if there's no development version, // default to 0 for releases and svn versions, // and 1 for development versions, alphas, and betas. if (i == length) { myDevelopment = ((myReleaseType != releaseType_release) && (myReleaseType != releaseType_svn)); } else { //development version while (i < length) { if (!isdigit(buf[i])) { break; } myDevelopment *= 10U; myDevelopment += digittoint(buf[i++]); } //while(i < length) } //if(++i != length) } //if(i < length) } //if(i != length) while ((i < length) && isspace(buf[i])) { ++i; } if (i < length) parsed = false; } //if(canConvert) end: free(buf); if (outVersion) { outVersion->major = myMajor; outVersion->minor = myMinor; outVersion->incremental = myIncremental; outVersion->releaseType = myReleaseType; outVersion->development = myDevelopment; } return parsed; }