| /* ********************************************************** |
| * Copyright (c) 2011-2014 Google, Inc. All rights reserved. |
| * Copyright (c) 2002-2010 VMware, Inc. All rights reserved. |
| * **********************************************************/ |
| |
| /* |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * |
| * * Redistributions of source code must retain the above copyright notice, |
| * this list of conditions and the following disclaimer. |
| * |
| * * Redistributions in binary form must reproduce the above copyright notice, |
| * this list of conditions and the following disclaimer in the documentation |
| * and/or other materials provided with the distribution. |
| * |
| * * Neither the name of VMware, Inc. nor the names of its contributors may be |
| * used to endorse or promote products derived from this software without |
| * specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL VMWARE, INC. OR CONTRIBUTORS BE LIABLE |
| * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
| * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
| * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
| * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH |
| * DAMAGE. |
| */ |
| |
| /* Copyright (c) 2003-2007 Determina Corp. */ |
| /* Copyright (c) 2002-2003 Massachusetts Institute of Technology */ |
| |
| /* |
| * io.c - routines for i/o to avoid library dependencies |
| */ |
| |
| /* FIXME: failure modes should be more graceful than failing asserts in most places */ |
| |
| #include "globals.h" |
| #include <string.h> |
| #include <stdarg.h> /* for varargs */ |
| |
| #ifdef UNIX |
| # ifdef MACOS |
| /* request extern functions to avoid conflicts with our own tolower() */ |
| # define _EXTERNALIZE_CTYPE_INLINES_TOP_ |
| # define _EXTERNALIZE_CTYPE_INLINES_ |
| # endif |
| # include <wchar.h> |
| #endif |
| |
| #ifdef NOT_DYNAMORIO_CORE_PROPER |
| /* drpreinject doesn't link utils.c. We fail gracefully without the assertion, |
| * so just define it away. |
| */ |
| # undef CLIENT_ASSERT |
| # define CLIENT_ASSERT(cond, msg) |
| # undef ASSERT |
| # define ASSERT(x) |
| #endif /* NOT_DYNAMORIO_CORE_PROPER */ |
| |
| #define VA_ARG_CHAR2INT |
| #define BUF_SIZE 64 |
| |
| #ifdef UNIX |
| const static double pos_inf = 1.0/0.0; |
| const static double neg_inf = -1.0/0.0; |
| #else |
| /* Windows says "error C2099: initializer is not a constant", or |
| * "error C2124: divide or mod by zero", for the above. |
| */ |
| # pragma warning(disable : 4723) /* warning C4723: potential divide by 0 */ |
| const static double zerof = 0.0; |
| # define pos_inf (1.0/zerof) |
| # define neg_inf (-1.0/zerof) |
| #endif |
| |
| /* assumes that d > 0 */ |
| long /* exported to utils.c */ |
| double2int_trunc(double d) |
| { |
| long i = (long)d; |
| double id = (double)i; |
| /* when building with /QIfist casting rounds instead of truncating (i#763) */ |
| if (id > d) |
| return i-1; |
| else |
| return i; |
| } |
| |
| /* assumes that d > 0 */ |
| static long |
| double2int(double d) |
| { |
| long i = (long)d; |
| double id = (double)i; |
| /* when building with /QIfist casting rounds instead of truncating (i#763) */ |
| if (id < d && d - id >= 0.5) |
| return i+1; |
| else if (id > d && id - d >= 0.5) |
| return i-1; |
| else |
| return i; |
| } |
| |
| #ifdef WINDOWS |
| /***************************************************************************** |
| * UTF-8 <-> UTF-16 |
| * |
| * Windows-only b/c it assumes wide chars are 2 bytes (primarily just when |
| * examining input values). |
| */ |
| |
| /* Returns the number of elements written if all of the characters of src, |
| * or if max_chars from src, were successfully encoded into dst. |
| * Passing max_chars==0 means no limit. |
| * If there is room, appends a null terminator (which is not included in the |
| * return value). (This is to match our snprintf semantics.) |
| * Returns -1 on an error, such as src not being valid UTF-8, or on encountering |
| * a character that cannot be encoded with UTF-16. |
| * In *written, returns the number of unicode characters written to dst including |
| * the terminating null. |
| * Will not write a partial multi-byte character. |
| * Does not use a byte-order mark. |
| * |
| * XXX: instead of bailing and returning -1, should we use a particular encoding |
| * for each invalid sequence? MultiByteToWideChar uses U+FFFD. |
| */ |
| static ssize_t |
| utf8_to_utf16(wchar_t *dst, size_t dst_sz/*elements*/, const char *src, |
| size_t max_chars, size_t *written/*unicode chars*/) |
| { |
| /* Be sure to use unsigned for proper comparisons below */ |
| const unsigned char *s = (const unsigned char *) src; |
| wchar_t *d = dst; |
| size_t chars = 0; |
| while (dst_sz > 0 && *s != '\0' && (max_chars == 0 || chars < max_chars)) { |
| if (*s <= 0x7f) { |
| /* through U+007F: 7 bits: bottom 7 of 1st byte */ |
| *d = (wchar_t) *s; |
| chars++; |
| } else if (*s >> 5 == 0x6) { |
| /* through U+07FF: 11 bits: bottom 5 of 1st and bottom 6 of 2nd */ |
| wchar_t first = (((wchar_t)*s) & 0x1f) << 6; |
| s++; |
| if (*s >> 6 != 0x2) |
| return -1; /* malformed UTF-8 */ |
| *d = first | (*s & 0x3f); |
| chars++; |
| } else if (*s >> 4 == 0xe) { |
| /* through U+FFFF: 16 bits: bottom 4 of 1st, bottom 6 of 2nd + 3rd */ |
| wchar_t first = (((wchar_t)*s) & 0xf) << 12; |
| s++; |
| if (*s >> 6 != 0x2) |
| return -1; /* malformed UTF-8 */ |
| first |= ((((wchar_t)*s) & 0x3f) << 6); |
| s++; |
| if (*s >> 6 != 0x2) |
| return -1; /* malformed UTF-8 */ |
| *d = first | (*s & 0x3f); |
| chars++; |
| } else if (*s >> 3 == 0x1e) { |
| /* through U+1FFFFF: 21 bits: bottom 3 of 1st, bottom 6 of 2nd-4th */ |
| uint cp = (((wchar_t)*s) & 0x7) << 18; |
| s++; |
| if (*s >> 6 != 0x2) |
| return -1; /* malformed UTF-8 */ |
| cp |= ((((wchar_t)*s) & 0x3f) << 12); |
| s++; |
| if (*s >> 6 != 0x2) |
| return -1; /* malformed UTF-8 */ |
| cp |= ((((wchar_t)*s) & 0x3f) << 6); |
| s++; |
| if (*s >> 6 != 0x2) |
| return -1; /* malformed UTF-8 */ |
| cp |= (((wchar_t)*s) & 0x3f); |
| /* check limit */ |
| if (cp > 0x10ffff) |
| return -1; /* not encodable with UTF-16 */ |
| /* encode using surrogate pairs */ |
| if ((size_t)(d + 1 - dst) >= dst_sz) /* no partial chars */ |
| break; |
| *d = (wchar_t) (((cp - 0x10000) >> 10) + 0xd800); |
| d++; |
| *d = (wchar_t) (((cp - 0x10000) & 0x3ff) + 0xdc00); |
| chars++; |
| } else if (*s >> 2 == 0x3e) { |
| /* through U+3FFFFFF: 26 bits: bottom 2 of 1st, bottom 6 of 2nd-5th */ |
| return -1; /* not encodable with UTF-16 */ |
| } else if (*s >> 1 == 0x7e) { |
| /* through U+7FFFFFFF: 31 bits: bottom 1 of 1st, bottom 6 of 2nd-6th */ |
| return -1; /* not encodable with UTF-16 */ |
| } |
| d++; |
| if ((size_t)(d - dst) >= dst_sz) |
| break; |
| s++; |
| } |
| if ((size_t)(d - dst) < dst_sz) |
| *d = L'\0'; |
| if (written != NULL) |
| *written = chars; |
| return d - dst; |
| } |
| |
| /* Returns the number of elements written if all of the characters of src, |
| * or if max_chars from src, were successfully encoded into dst. |
| * Passing max_chars==0 means no limit. |
| * If there is room, appends a null terminator (which is not included in the |
| * return value). (This is to match our snprintf semantics.) |
| * Returns -1 on an error, such as src not being valid UTF-16. |
| * In *written, returns the number of unicode characters written to dst including |
| * the terminating null. |
| * Will not write a partial multi-byte character. |
| * Does not handle a byte-order mark. |
| * If dst==NULL, returns the number of elements required to encode max_chars |
| * (or all if max_chars==0) from src. |
| */ |
| static ssize_t |
| utf16_to_utf8(char *dst, size_t dst_sz/*elements*/, const wchar_t *src, |
| size_t max_chars, size_t *written/*unicode chars*/) |
| { |
| const wchar_t *s = src; |
| char *d = dst; |
| ssize_t bytes = 0; |
| size_t chars = 0; |
| while ((dst == NULL || dst_sz > 0) && *s != L'\0' && |
| (max_chars == 0 || chars < max_chars)) { |
| if (*s <= 0x7f) { |
| if (dst != NULL) |
| *d = (char) *s; |
| else |
| bytes++; |
| chars++; |
| } else if (*s <= 0x7ff) { |
| /* 2-byte encoding: 0b110xxxxx 0b10xxxxxx */ |
| if (dst != NULL) { |
| if ((size_t)(d + 1 - dst) >= dst_sz) /* no partial chars */ |
| break; |
| *d = (char) (0xc0 | (*s >> 6)); |
| d++; |
| *d = (char) (0x80 | (*s & 0x3f)); |
| } else |
| bytes += 2; |
| chars++; |
| } else if (*s >= 0xd800 && *s <= 0xdfff) { |
| /* surrogate pairs */ |
| uint cp = (*s - 0xd800) << 10; |
| s++; |
| if (dst != NULL) { |
| if (*s == L'\0' || *s < 0xdc00 || *s > 0xdfff) |
| return -1; /* malformed UTF-16 */ |
| cp |= (*s - 0xdc00); |
| cp += 0x10000; |
| /* 4-byte encoding: 0b1110xxxx 0b10xxxxxx 0b10xxxxxx 0b10xxxxxx */ |
| if ((size_t)(d + 3 - dst) >= dst_sz) /* no partial chars */ |
| break; |
| *d = (char) (0xf0 | (cp >> 18)); |
| d++; |
| *d = (char) (0x80 | ((cp >> 12) & 0x3f)); |
| d++; |
| *d = (char) (0x80 | ((cp >> 6) & 0x3f)); |
| d++; |
| *d = (char) (0x80 | (cp & 0x3f)); |
| } else |
| bytes += 4; |
| chars++; |
| } else { |
| /* 3-byte encoding: 0b1110xxxx 0b10xxxxxx 0b10xxxxxx */ |
| if (dst != NULL) { |
| if ((size_t)(d + 2 - dst) >= dst_sz) /* no partial chars */ |
| break; |
| *d = (char) (0xe0 | (*s >> 12)); |
| d++; |
| *d = (char) (0x80 | ((*s >> 6) & 0x3f)); |
| d++; |
| *d = (char) (0x80 | (*s & 0x3f)); |
| } else |
| bytes += 3; |
| chars++; |
| } |
| if (dst != NULL) { |
| d++; |
| if ((size_t)(d - dst) >= dst_sz) |
| break; |
| } |
| s++; |
| } |
| if (dst != NULL) { |
| if ((size_t)(d - dst) < dst_sz) |
| *d = L'\0'; |
| } |
| if (written != NULL) |
| *written = chars; |
| if (dst != NULL) |
| return d - dst; |
| else |
| return bytes; |
| } |
| |
| ssize_t |
| utf16_to_utf8_size(const wchar_t *src, size_t max_chars, size_t *written/*unicode chars*/) |
| { |
| return utf16_to_utf8(NULL, 0, src, max_chars, NULL); |
| } |
| #endif |
| |
| /***************************************************************************** |
| * snprintf |
| */ |
| |
| /* we generate from a template to get wide and narrow versions */ |
| #undef IOX_WIDE_CHAR |
| #include "iox.h" |
| |
| #define IOX_WIDE_CHAR |
| #include "iox.h" |
| |
| /***************************************************************************** |
| * Stand alone sscanf implementation. |
| */ |
| |
| typedef enum _specifier_t { |
| SPEC_INT, |
| SPEC_CHAR, |
| SPEC_STRING |
| } specifer_t; |
| |
| typedef enum _int_sz_t { |
| SZ_SHORT, |
| SZ_INT, |
| SZ_LONG, |
| SZ_LONGLONG, |
| #if defined(X64) && defined(WINDOWS) |
| SZ_PTR = SZ_LONGLONG |
| #else |
| SZ_PTR = SZ_LONG |
| #endif |
| } int_sz_t; |
| |
| /* The isspace() from ctype.h is actually a macro that calls __ctype_b_loc(), |
| * which tries to look something up in the library TLS. This doesn't work |
| * without the private loader, so we roll our own isspace(). |
| */ |
| static bool inline |
| our_isspace(int c) |
| { |
| return (c == ' ' || c == '\f' || c == '\n' || c == '\r' || c == '\t' || |
| c == '\v'); |
| } |
| |
| const char * |
| parse_int(const char *sp, uint64 *res_out, uint base, uint width, bool is_signed) |
| { |
| bool negative = false; |
| uint64 res = 0; |
| uint i; /* Use an index rather than pointer to compare with width. */ |
| |
| /* Check for invalid base. */ |
| if (base > 36 || base == 1) { |
| *res_out = (uint64) -1LL; |
| return NULL; |
| } |
| |
| /* Check for negative sign if signed. */ |
| if (is_signed) { |
| if (*sp == '-') { |
| negative = true; |
| sp++; |
| } |
| } |
| |
| /* Ignore leading +. */ |
| if (!negative && *sp == '+') |
| sp++; |
| |
| /* 0x prefix for hex is optional. */ |
| if ((base == 0 || base == 16) && sp[0] == '0' && sp[1] == 'x') { |
| sp += 2; |
| if (base == 0) |
| base = 16; |
| } |
| |
| /* Leading '0' with 0 base means octal. */ |
| if (base == 0 && *sp == '0') { |
| base = 8; |
| sp++; |
| } |
| |
| /* If we didn't find leading '0' or "0x", base is 10. */ |
| if (base == 0) |
| base = 10; |
| |
| /* XXX: For efficiency we could do a couple things: |
| * - Specialize the loop on base |
| * - Use a lookup table |
| */ |
| for (i = 0; width == 0 || i < width; i++) { |
| uint d = sp[i]; |
| if (d >= '0' && d <= '9') { |
| d -= '0'; |
| } else if (d >= 'a' && d <= 'z') { |
| d = d - 'a' + 10; |
| } else if (d >= 'A' && d <= 'Z') { |
| d = d - 'A' + 10; |
| } else { |
| break; /* Non-digit character. Could be \0. */ |
| } |
| /* Stop the parse here if this digit was not valid for the current base, |
| * (e.g. 9 for octal of g for hex). |
| */ |
| if (d >= base) |
| break; |
| /* FIXME: Check for overflow. */ |
| /* XXX: int64 multiply is inefficient on 32-bit. */ |
| res = res * base + d; |
| } |
| |
| /* No digits found, return failure. */ |
| if (i == 0) |
| return NULL; |
| |
| if (negative) |
| res = -(int64)res; |
| |
| *res_out = res; |
| return sp + i; |
| } |
| |
| /* Stand alone implementation of sscanf. We used to call libc's vsscanf while |
| * trying to isolate errno (i#238), but these days sscanf calls malloc (i#762). |
| * Therefore, we roll our own. |
| */ |
| int |
| our_vsscanf(const char *str, const char *fmt, va_list ap) |
| { |
| int num_parsed = 0; |
| const char *fp = fmt; |
| const char *sp = str; |
| int c; |
| |
| while (*fp != '\0' && *sp != '\0') { |
| specifer_t spec = SPEC_INT; |
| int_sz_t int_size = SZ_INT; |
| uint base = 10; |
| bool is_signed = false; |
| bool is_ignored = false; |
| uint width = 0; |
| |
| /* Handle literal characters and spaces up front. */ |
| c = *fp++; |
| if (our_isspace(c)) { |
| /* Space means consume any number of spaces. */ |
| while (our_isspace(*sp)) { |
| sp++; |
| } |
| continue; |
| } else if (c != '%') { |
| /* Literal, so check mismatch. */ |
| if (c != *sp) |
| return num_parsed; |
| sp++; |
| continue; |
| } |
| |
| /* Parse the format specifier. */ |
| ASSERT(c == '%'); |
| while (true) { |
| c = *fp++; |
| switch (c) { |
| /* Modifiers, should all continue the loop. */ |
| case 'l': |
| if (int_size == SZ_INT) { |
| int_size = SZ_LONG; |
| } else if (int_size == SZ_LONG) { |
| int_size = SZ_LONGLONG; |
| } else { |
| CLIENT_ASSERT(int_size != SZ_SHORT, |
| "dr_sscanf: can't use %hl modifier"); |
| CLIENT_ASSERT(int_size != SZ_LONGLONG, |
| "dr_sscanf: too many longs (%lll)"); |
| return num_parsed; /* error */ |
| } |
| break; |
| case 'h': |
| CLIENT_ASSERT(int_size == SZ_INT, |
| "dr_sscanf: can't use %lh modifier"); |
| int_size = SZ_SHORT; |
| continue; |
| case '*': |
| is_ignored = true; |
| continue; |
| case '0': case '1': case '2': case '3': case '4': |
| case '5': case '6': case '7': case '8': case '9': |
| /* We honor the specified width for strings to prevent buffer |
| * overruns, but we don't honor it for integers. Honoring the |
| * width for integers would require our own integer parser. |
| */ |
| width = width * 10 + c - '0'; |
| continue; |
| case 'I': |
| /* We support I32 and I64 from Windows sscanf because DR exports |
| * macros that use them. |
| */ |
| if (strncmp("32", fp, 2) == 0) { |
| int_size = SZ_INT; |
| } else if (strncmp("64", fp, 2) == 0) { |
| int_size = SZ_LONGLONG; |
| } else { |
| CLIENT_ASSERT(false, |
| "dr_sscanf: unsupported I<width> modifier"); |
| return num_parsed; |
| } |
| break; |
| /* XXX: Modifiers we could add support for: |
| * - j, z, t: C99 modifiers for intmax_t, size_t, and ptrdiff_t. |
| * - [] scan sets: These are complicated and better to avoid. |
| * - .*: For dynamically sized strings. Not part of C scanf. |
| * - n$: Store the result into the nth pointer arg after fmt. |
| */ |
| |
| /* Specifiers, should all break the loop. */ |
| case 'u': |
| spec = SPEC_INT; |
| is_signed = false; |
| goto spec_done; |
| case 'd': |
| spec = SPEC_INT; |
| is_signed = true; |
| goto spec_done; |
| case 'x': |
| spec = SPEC_INT; |
| is_signed = false; |
| base = 16; |
| goto spec_done; |
| case 'p': |
| int_size = SZ_PTR; |
| spec = SPEC_INT; |
| is_signed = false; |
| base = 16; |
| goto spec_done; |
| case 'c': |
| spec = SPEC_CHAR; |
| goto spec_done; |
| case 's': |
| spec = SPEC_STRING; |
| goto spec_done; |
| /* XXX: Specifiers we could add support for: |
| * - o: octal integer |
| * - g, e, f: floating point |
| * - n: characters consumed so far |
| */ |
| default: |
| CLIENT_ASSERT(false, "dr_sscanf: unknown specifier"); |
| return num_parsed; /* error */ |
| } |
| } |
| spec_done: |
| |
| /* Parse the string. */ |
| switch (spec) { |
| case SPEC_CHAR: |
| /* XXX: We don't support width with %c. */ |
| if (!is_ignored) { |
| *va_arg(ap, char*) = *sp; |
| } |
| sp++; |
| break; |
| case SPEC_STRING: |
| if (is_ignored) { |
| while (*sp != '\0' && !our_isspace(*sp)) { |
| sp++; |
| } |
| } else { |
| char *str_out = va_arg(ap, char*); |
| if (width > 0) { |
| uint i = 0; |
| while (i < width && *sp != '\0' && !our_isspace(*sp)) { |
| *str_out++ = *sp++; |
| i++; |
| } |
| /* Spec says only null terminate if we hit width. */ |
| if (i < width) |
| *str_out = '\0'; |
| } else { |
| while (*sp != '\0' && !our_isspace(*sp)) { |
| *str_out++ = *sp++; |
| } |
| *str_out = '\0'; |
| } |
| } |
| break; |
| case SPEC_INT: { |
| uint64 res; |
| /* C sscanf skips leading whitespace before parsing integers. */ |
| while (*sp != '\0' && our_isspace(*sp)) |
| sp++; |
| sp = parse_int(sp, &res, base, width, is_signed); |
| if (sp == NULL) |
| return num_parsed; |
| |
| if (!is_ignored) { |
| if (int_size == SZ_SHORT) |
| *va_arg(ap, short *) = (short)res; |
| else if (int_size == SZ_INT) |
| *va_arg(ap, int *) = (int)res; |
| else if (int_size == SZ_LONG) |
| *va_arg(ap, long *) = (long)res; |
| else if (int_size == SZ_LONGLONG) |
| *va_arg(ap, long long *) = (long long)res; |
| else { |
| ASSERT_NOT_REACHED(); |
| return num_parsed; |
| } |
| } |
| break; |
| } |
| default: |
| /* Format parsing code above should return an error earlier. */ |
| ASSERT_NOT_REACHED(); |
| return num_parsed; |
| } |
| |
| if (!is_ignored) |
| num_parsed++; |
| } |
| return num_parsed; |
| } |
| |
| int |
| our_sscanf(const char *str, const char *fmt, ...) |
| { |
| /* No need to save errno, we don't call libc anymore. */ |
| int res; |
| va_list ap; |
| va_start(ap, fmt); |
| res = our_vsscanf(str, fmt, ap); |
| va_end(ap); |
| return res; |
| } |
| |
| #ifdef STANDALONE_UNIT_TEST |
| /***************************************************************************** |
| * sscanf() tests |
| */ |
| |
| /* Copied from core/unix/os.c and modified so that they work when run |
| * cross-arch. We need %ll to parse 64-bit ints on 32-bit and drop the %l to |
| * parse 32-bit ints on x64. |
| */ |
| # define MAPS_LINE_FORMAT4 "%08x-%08x %s %08x %*s %llu %4096s" |
| # define MAPS_LINE_FORMAT8 "%016llx-%016llx %s %016llx %*s %llu %4096s" |
| |
| static void |
| test_sscanf_maps_x86(void) |
| { |
| char line_copy[1024]; |
| uint start, end; |
| uint offset; |
| uint64 inode; |
| char perm[16]; |
| char comment[4096]; |
| int len; |
| const char *maps_line = |
| "f75c3000-f75c4000 rw-p 00155000 fc:00 1840387" |
| " /lib32/libc-2.11.1.so"; |
| |
| strcpy(line_copy, maps_line); |
| len = our_sscanf(line_copy, MAPS_LINE_FORMAT4, |
| &start, &end, perm, &offset, &inode, comment); |
| EXPECT(len, 6); |
| /* Do int64 comparisons directly. EXPECT casts to ptr_uint_t. */ |
| EXPECT(start, 0xf75c3000UL); |
| EXPECT(end, 0xf75c4000UL); |
| EXPECT(offset, 0x00155000UL); |
| EXPECT((inode == 1840387ULL), 1); |
| EXPECT(strcmp(perm, "rw-p"), 0); |
| EXPECT(strcmp(comment, "/lib32/libc-2.11.1.so"), 0); |
| /* sscanf should not modify it's input. */ |
| EXPECT(strcmp(line_copy, maps_line), 0); |
| } |
| |
| static void |
| test_sscanf_maps_x64(void) |
| { |
| char line_copy[1024]; |
| uint64 start, end; |
| uint64 offset; |
| uint64 inode; |
| char perm[16]; |
| char comment[4096]; |
| int len; |
| const char *maps_line = |
| "7f94a6757000-7f94a6758000 rw-p 0017d000 fc:00 " |
| "1839331 /lib/libc-2.11.1.so"; |
| |
| strcpy(line_copy, maps_line); |
| len = our_sscanf(line_copy, MAPS_LINE_FORMAT8, |
| &start, &end, perm, &offset, &inode, comment); |
| EXPECT(len, 6); |
| /* Do int64 comparisons directly. EXPECT casts to ptr_uint_t. */ |
| EXPECT((start == 0x7f94a6757000ULL), 1); |
| EXPECT((end == 0x7f94a6758000ULL), 1); |
| EXPECT((offset == 0x00017d000ULL), 1); |
| EXPECT((inode == 1839331ULL), 1); |
| EXPECT(strcmp(perm, "rw-p"), 0); |
| EXPECT(strcmp(comment, "/lib/libc-2.11.1.so"), 0); |
| /* sscanf should not modify it's input. */ |
| EXPECT(strcmp(line_copy, maps_line), 0); |
| } |
| |
| static void |
| test_sscanf_all_specs(void) |
| { |
| int res; |
| char ch; |
| char str[16]; |
| int signed_int; |
| int signed_int_2; |
| uint unsigned_int; |
| uint hex_num; |
| unsigned long long ull_num; |
| |
| /* ULLONG_MAX is a corner case. */ |
| res = our_sscanf("c str -123 +456 0x789 0xffffffffffffffff", |
| "%c %s %d %u %x %llx", &ch, str, &signed_int, |
| &unsigned_int, &hex_num, &ull_num); |
| EXPECT(res, 6); |
| EXPECT(ch, 'c'); |
| EXPECT(strcmp(str, "str"), 0); |
| EXPECT(signed_int, -123); |
| EXPECT(unsigned_int, 456); |
| EXPECT(hex_num, 0x789); |
| EXPECT((ull_num == ULLONG_MAX), true); |
| |
| /* A variety of ways to say negative one. */ |
| res = our_sscanf("-1-1", "%d%d", &signed_int, &signed_int_2); |
| EXPECT(res, 2); |
| EXPECT(signed_int, -1); |
| EXPECT(signed_int_2, -1); |
| |
| /* Test ignores. */ |
| res = our_sscanf("c str -123 +456 0x789 0xffffffffffffffff 1", |
| "%*c %*s %*d %*u %*x %*llx %d", &signed_int); |
| EXPECT(res, 1); |
| EXPECT(signed_int, 1); |
| |
| /* Test width specifications on strings. */ |
| memset(str, '*', sizeof(str)); /* Fill string with garbage. */ |
| res = our_sscanf("abcdefghijklmnopqrstuvwxyz", |
| "%13s", str); |
| EXPECT(res, 1); |
| /* our_sscanf should read 13 chars without null termination. */ |
| EXPECT(memcmp(str, "abcdefghijklm", 13), 0); |
| EXPECT(str[13], '*'); /* Asterisk should still be there. */ |
| |
| /* Test width specifications for integers. */ |
| res = our_sscanf("123456 0x9abc", "%03d%03d %03xc", |
| &signed_int, &signed_int_2, &unsigned_int); |
| EXPECT(res, 3); |
| EXPECT(signed_int, 123); |
| EXPECT(signed_int_2, 456); |
| EXPECT(unsigned_int, 0x9ab); |
| |
| /* Test skipping leading whitespace for integer conversions. */ |
| res = our_sscanf(" \t123456\t\n 0x9abc", "%d%x", |
| &signed_int, &unsigned_int); |
| EXPECT(res, 2); |
| EXPECT(signed_int, 123456); |
| EXPECT(unsigned_int, 0x9abc); |
| |
| /* Test Windows-style integer width specifiers using decimal ULLONG_MAX. */ |
| res = our_sscanf("1234 18446744073709551615", "%I32d %I64d", |
| &signed_int, &ull_num); |
| EXPECT(res, 2); |
| EXPECT(signed_int, 1234); |
| EXPECT((ull_num == ULLONG_MAX), true); |
| |
| /* FIXME: When parse_int has range checking, we should add tests for parsing |
| * integers that overflow their requested integer sizes. |
| */ |
| } |
| |
| /***************************************************************************** |
| * memcpy() and memset() tests |
| */ |
| |
| # ifdef UNIX |
| # include <errno.h> |
| # include <dlfcn.h> /* for dlsym for libc routines */ |
| |
| /* From dlfcn.h, but we'd have to define _GNU_SOURCE 1 before globals.h. */ |
| # define RTLD_NEXT ((void *) -1l) |
| |
| typedef void (*memcpy_t)(void *dst, const void *src, size_t n); |
| |
| static void |
| test_memcpy_offset_size(size_t src_offset, size_t dst_offset, size_t size) |
| { |
| /* These can be aligned to whatever, we'll try a few different offsets. */ |
| byte src[1024]; |
| byte dst[1024]; |
| int i; |
| for (i = 0; i < sizeof(src); i++) { |
| src[i] = 0xcc; |
| dst[i] = 0; |
| } |
| EXPECT(src_offset + size <= sizeof(src), 1); |
| EXPECT(dst_offset + size <= sizeof(dst), 1); |
| memcpy(dst + dst_offset, src + src_offset, size); |
| EXPECT(memcmp(dst + dst_offset, src + src_offset, size), 0); |
| /* Check the bytes just out of bounds, which should still be zero. */ |
| if (dst_offset > 0) |
| EXPECT(dst[dst_offset-1], 0); |
| if (dst_offset+size < sizeof(dst)) |
| EXPECT(dst[dst_offset+size], 0); |
| } |
| |
| static void |
| test_our_memcpy(void) |
| { |
| int i, j; |
| void *ret; |
| /* Basic, copy the whole buffer. */ |
| test_memcpy_offset_size(0, 0, 1024); |
| /* Test misalignment less than copy size. */ |
| test_memcpy_offset_size(1, 1, 2); |
| test_memcpy_offset_size(2, 2, 2); |
| test_memcpy_offset_size(1, 1, 3); |
| test_memcpy_offset_size(2, 2, 3); |
| /* Test a variety of offsets. */ |
| for (i = 0; i < 16; i++) { |
| for (j = 0; j < 16; j++) { |
| test_memcpy_offset_size(i, j, 512); |
| } |
| } |
| /* Check that memcpy returns dst. */ |
| ret = memcpy(&i, &j, sizeof(i)); |
| EXPECT(ret == &i, 1); |
| } |
| |
| static void |
| test_memset_offset_size(int val, int start_offs, int end_offs) |
| { |
| byte buf[512]; |
| int i; |
| int end = sizeof(buf) - start_offs - end_offs; |
| /* Zero without memset. */ |
| for (i = 0; i < sizeof(buf); i++) |
| buf[i] = 0; |
| memset(buf + start_offs, val, end); |
| EXPECT(is_region_memset_to_char(buf + start_offs, end, val), 1); |
| if (start_offs > 0) |
| EXPECT(buf[start_offs-1], 0); |
| if (end_offs > 0) |
| EXPECT(buf[sizeof(buf)-end_offs], 0); |
| } |
| |
| static void |
| test_our_memset(void) |
| { |
| int val; |
| int i, j; |
| void *ret; |
| /* Test a variety of values. */ |
| for (val = 0; val < 0xff; val++) { |
| for (i = 0; i < 16; i++) { |
| for (j = 0; j < 16; j++) { |
| test_memset_offset_size(val, i, j); |
| } |
| } |
| } |
| /* Check that memset returns dst. */ |
| ret = memset(&i, -1, sizeof(i)); |
| EXPECT(ret == &i, 1); |
| } |
| |
| static void |
| our_memcpy_vs_libc(void) |
| { |
| /* Compare our memcpy with libc memcpy. |
| * XXX: Should compare on more sizes, especially small ones. |
| */ |
| size_t alloc_size = 20 * 1024; |
| int loop_count = 100 * 1000; |
| void *src = global_heap_alloc(alloc_size HEAPACCT(ACCT_OTHER)); |
| void *dst = global_heap_alloc(alloc_size HEAPACCT(ACCT_OTHER)); |
| int i; |
| memcpy_t glibc_memcpy = (memcpy_t) dlsym(RTLD_NEXT, "memcpy"); |
| uint64 our_memcpy_start, our_memcpy_end, our_memcpy_time; |
| uint64 libc_memcpy_start, libc_memcpy_end, libc_memcpy_time; |
| memset(src, -1, alloc_size); |
| memset(dst, 0, alloc_size); |
| |
| our_memcpy_start = query_time_millis(); |
| for (i = 0; i < loop_count; i++) { |
| memcpy(src, dst, alloc_size); |
| } |
| our_memcpy_end = query_time_millis(); |
| |
| libc_memcpy_start = query_time_millis(); |
| for (i = 0; i < loop_count; i++) { |
| glibc_memcpy(src, dst, alloc_size); |
| } |
| libc_memcpy_end = query_time_millis(); |
| |
| global_heap_free(src, alloc_size HEAPACCT(ACCT_OTHER)); |
| global_heap_free(dst, alloc_size HEAPACCT(ACCT_OTHER)); |
| our_memcpy_time = our_memcpy_end - our_memcpy_start; |
| libc_memcpy_time = libc_memcpy_end - libc_memcpy_start; |
| print_file(STDERR, "our_memcpy_time: "UINT64_FORMAT_STRING"\n", |
| our_memcpy_time); |
| print_file(STDERR, "libc_memcpy_time: "UINT64_FORMAT_STRING"\n", |
| libc_memcpy_time); |
| /* We could assert that we're not too much slower, but that's a recipe for |
| * flaky failures when the suite is run on shared VMs or in parallel. |
| */ |
| } |
| # endif /* UNIX */ |
| |
| static void |
| test_integer(void) |
| { |
| char buf[512]; |
| ssize_t res; |
| |
| /* test integer codes */ |
| res = our_snprintf(buf, BUFFER_SIZE_ELEMENTS(buf), "%lld", 0x12345678abcdef01LL); |
| EXPECT(res == (ssize_t) strlen("1311768467750121217"), true); |
| EXPECT(strcmp(buf, "1311768467750121217"), 0); |
| |
| res = our_snprintf(buf, BUFFER_SIZE_ELEMENTS(buf), "%lld", 0x82345678abcdef01LL); |
| EXPECT(res == (ssize_t) strlen("-9064525073711501567"), true); |
| EXPECT(strcmp(buf, "-9064525073711501567"), 0); |
| |
| res = our_snprintf(buf, BUFFER_SIZE_ELEMENTS(buf), "%llu", 0x82345678abcdef01LL); |
| EXPECT(res == (ssize_t) strlen("9382218999998050049"), true); |
| EXPECT(strcmp(buf, "9382218999998050049"), 0); |
| |
| /* XXX: add more tests */ |
| } |
| |
| void |
| unit_test_io(void) |
| { |
| char buf[512]; |
| wchar_t wbuf[512]; |
| ssize_t res; |
| |
| /* test wide char conversion */ |
| res = our_snprintf(buf, BUFFER_SIZE_ELEMENTS(buf), "%S", L"wide string"); |
| EXPECT(res == (ssize_t) strlen("wide string"), true); |
| EXPECT(strcmp(buf, "wide string"), 0); |
| res = our_snprintf(buf, BUFFER_SIZE_ELEMENTS(buf), "%ls", L"wide string"); |
| EXPECT(res == (ssize_t) strlen("wide string"), true); |
| EXPECT(strcmp(buf, "wide string"), 0); |
| res = our_snprintf(buf, BUFFER_SIZE_ELEMENTS(buf), "%.3S", L"wide string"); |
| EXPECT(res == (ssize_t) strlen("wid"), true); |
| EXPECT(strcmp(buf, "wid"), 0); |
| res = our_snprintf(buf, 4, "%S", L"wide string"); |
| EXPECT(res == -1, true); |
| EXPECT(buf[4], ' '); /* ' ' from prior calls: no NULL written since hit max */ |
| buf[4] = '\0'; |
| EXPECT(strcmp(buf, "wide"), 0); |
| |
| /* test float */ |
| res = our_snprintf(buf, BUFFER_SIZE_ELEMENTS(buf), "%3.1f", 42.9f); |
| EXPECT(res == (ssize_t) strlen("42.9"), true); |
| EXPECT(strcmp(buf, "42.9"), 0); |
| /* XXX: add more */ |
| |
| /* test all-wide */ |
| res = our_snprintf_wide(wbuf, BUFFER_SIZE_ELEMENTS(wbuf), L"%d%s%3.1f", |
| -42, L"wide string", 42.9f); |
| EXPECT(res == (ssize_t) wcslen(L"-42wide string42.9"), true); |
| EXPECT(wcscmp(wbuf, L"-42wide string42.9"), 0); |
| |
| /* test all-wide conversion */ |
| res = our_snprintf_wide(wbuf, BUFFER_SIZE_ELEMENTS(wbuf), L"%S", "narrow string"); |
| EXPECT(res == (ssize_t) wcslen(L"narrow string"), true); |
| EXPECT(wcscmp(wbuf, L"narrow string"), 0); |
| res = our_snprintf_wide(wbuf, BUFFER_SIZE_ELEMENTS(wbuf), L"%hs", "narrow string"); |
| EXPECT(res == (ssize_t) wcslen(L"narrow string"), true); |
| EXPECT(wcscmp(wbuf, L"narrow string"), 0); |
| res = our_snprintf_wide(wbuf, BUFFER_SIZE_ELEMENTS(wbuf), L"%.3S", "narrow string"); |
| EXPECT(res == (ssize_t) wcslen(L"nar"), true); |
| EXPECT(wcscmp(wbuf, L"nar"), 0); |
| res = our_snprintf_wide(wbuf, 6, L"%S", "narrow string"); |
| EXPECT(res == -1, true); |
| EXPECT(wbuf[6], L' '); /* ' ' from prior calls: no NULL written since hit max */ |
| wbuf[6] = L'\0'; |
| EXPECT(wcscmp(wbuf, L"narrow"), 0); |
| |
| #ifdef WINDOWS |
| /* test UTF-16 to UTF-8 */ |
| res = our_snprintf(buf, BUFFER_SIZE_ELEMENTS(buf), "%S", |
| L"\x0391\x03A9\x20Ac"); /* alpha, omega, euro sign */ |
| EXPECT(res == 7, true); /* 2x 2-char + 1 3-char encodings */ |
| EXPECT((byte)buf[0] == 0xce && (byte)buf[1] == 0x91, true); /* UTF-8 U-0391 */ |
| EXPECT((byte)buf[2] == 0xce && (byte)buf[3] == 0xa9, true); /* UTF-8 U-03A9 */ |
| EXPECT((byte)buf[4] == 0xe2 && (byte)buf[5] == 0x82 && (byte)buf[6] == 0xac, |
| true); /* UTF-8 U-20Ac */ |
| EXPECT((byte)buf[7] == '\0', true); |
| res = our_snprintf(buf, BUFFER_SIZE_ELEMENTS(buf), "%S", |
| L"\xd800"); /* no low surrogate */ |
| EXPECT(res == -1, true); |
| res = our_snprintf(buf, BUFFER_SIZE_ELEMENTS(buf), "%S", |
| L"\xd800\xdc00"); /* surrogate pair */ |
| EXPECT(res == 4, true); /* 4-char encoding */ |
| EXPECT((byte)buf[0] == 0xf0 && (byte)buf[1] == 0x90 && |
| (byte)buf[2] == 0x80 && (byte)buf[3] == 0x80, true); /* UTF-8 U-10000 */ |
| EXPECT((byte)buf[4] == '\0', true); |
| res = our_snprintf(buf, BUFFER_SIZE_ELEMENTS(buf), "%.6S", |
| L"\x0391\x03A9\x20Ac"); /* alpha, omega, euro sign */ |
| EXPECT(res == 4, true); /* 2x 2-char + aborted the 3-char encoding */ |
| EXPECT((byte)buf[0] == 0xce && (byte)buf[1] == 0x91, true); /* UTF-8 U-0391 */ |
| EXPECT((byte)buf[2] == 0xce && (byte)buf[3] == 0xa9, true); /* UTF-8 U-03A9 */ |
| EXPECT((byte)buf[4] == '\0', true); |
| |
| /* test UTF-8 to UTF-16 */ |
| res = our_snprintf_wide(wbuf, BUFFER_SIZE_ELEMENTS(wbuf), L"%S", |
| "\xce\x91\xce\xa9\xe2\x82\xac"); /* alpha, omega, euro sign */ |
| EXPECT(res == 3, true); |
| EXPECT(wbuf[0] == 0x0391 && wbuf[1] == 0x03a9 && wbuf[2] == 0x20ac, true); |
| EXPECT(wbuf[3] == L'\0', true); |
| res = our_snprintf_wide(wbuf, BUFFER_SIZE_ELEMENTS(wbuf), L"%S", |
| "\xff\x91\xce\xa9\xe2\x82"); |
| EXPECT(res == -1, true); /* not encodable in UTF-16 */ |
| res = our_snprintf_wide(wbuf, BUFFER_SIZE_ELEMENTS(wbuf), L"%S", |
| "\xf0\x90\x80\x80"); /* U-1000 */ |
| EXPECT(res == 2, true); |
| EXPECT(wbuf[0] == 0xd800 && wbuf[1] == 0xdc00 && wbuf[2] == L'\0', true); |
| res = our_snprintf_wide(wbuf, BUFFER_SIZE_ELEMENTS(wbuf), L"%.2S", |
| "\xce\x91\xce\xa9\xe2\x82\xac"); /* alpha, omega, euro sign */ |
| EXPECT(res == 2, true); |
| EXPECT(wbuf[0] == 0x0391 && wbuf[1] == 0x03a9 && wbuf[2] == L'\0', true); |
| #endif |
| |
| test_integer(); |
| |
| /* sscanf tests */ |
| test_sscanf_maps_x86(); |
| test_sscanf_maps_x64(); |
| test_sscanf_all_specs(); |
| |
| #ifdef UNIX |
| /* memcpy tests */ |
| test_our_memcpy(); |
| our_memcpy_vs_libc(); |
| |
| /* memset tests */ |
| test_our_memset(); |
| #endif /* UNIX */ |
| |
| /* XXX: add more tests */ |
| |
| print_file(STDERR, "io all done\n"); |
| } |
| |
| #endif /* STANDALONE_UNIT_TEST */ |
