/* * DF-5703 differential harness: DragonFly kernel strtol/strtoul * (sys/libkern/strtol.c, sys/libkern/strtoul.c) vs the same-named libc * API (built from lib/libc/stdlib/_strtol.h / _strtoul.h NetBSD template, * both of which gate the 0x prefix on isxdigit_l(s[1])). * * Compares, per (input, base): * - VALUE (identical saturation values expected everywhere) * - ENDPOFF (endptr - nptr; contract comparison, C99 7.20.1.4) * - ERANGE (errno==ERANGE after libc call; kernel variant has no errno) * Classes: * VALUE-DIFF value desync kernel vs libc (security-relevant; expect 0) * ENDPTR-DIFF endptr contract divergence on VALID bases (DF-5703: * 0x-prefix-without-xdigit class in the int-width twins, * same body as DF-5702's quad twins) * ERANGE-ONLY identical value, libc sets ERANGE, kernel cannot * (known DF-2230 root cause -- counted, not re-reported) * BASE-DIFF invalid-base rows (base 1/37/-1): libc EINVAL, kernel * legacy BSD no-validation behavior (no kernel caller * passes these; counted separately) * Corpus adds the 32-bit-long boundary rows (2147483647/2147483648/ * -2147483648/-2147483649/4294967295/4294967296 + hex forms) on top of * DF-5702's corpus to stress the int-width cutoff math, plus the live * 64-bit-long boundaries (amd64 guest: long==quad_t width). * Fix validation: k_strtol_fix/k_strtoul_fix carry ONLY the proposed * isxdigit((unsigned char)s[1]) guard; residual diffs must be 0 and no * value regressions. */ #include #include #include #include #include #include long k_strtol(const char *, char **, int); unsigned long k_strtoul(const char *, char **, int); long k_strtol_fix(const char *, char **, int); unsigned long k_strtoul_fix(const char *, char **, int); static const char *inputs[] = { "", " ", "0", "1", "-1", "+1", "010", " -12", "\t+9", "0x", "0X", "0xg", "0XG", "0x 1", "0xz1", "0xz", "0x0", "0x1", "0X7f", "0xdeadbeef", "+0x10", "-0x10", "0x1z", " 0xf", /* 32-bit long boundaries (i386 width; ordinary on amd64) */ "2147483647", "2147483648", "-2147483648", "-2147483649", "4294967295", "4294967296", "0x7fffffff", "0x80000000", "0xffffffff", "0x100000000", /* 64-bit long boundaries (amd64 width, the live case) */ "9223372036854775807", "9223372036854775808", "-9223372036854775808", "-9223372036854775809", "18446744073709551615", "18446744073709551616", "0x7fffffffffffffff", "0x8000000000000000", "0xffffffffffffffff", "0x10000000000000000", "-0x8000000000000000", "-0x8000000000000001", "0b101", "1e5", "z", "0y2", "1777777777777777777777", }; static const int bases[] = { 0, 2, 8, 10, 16, 36, 1, 37, -1 }; #define NIN (int)(sizeof(inputs)/sizeof(inputs[0])) #define NB (int)(sizeof(bases)/sizeof(bases[0])) static int value_diffs, endptr_diffs, erange_only, base_sem_diffs; static int fix_endptr_diffs, fix_value_diffs; static const char * esc(const char *s) { static char b[64]; char *o = b; *o++ = '"'; for (; *s && o < b + sizeof(b) - 8; s++) { if (*s == '\t') { *o++ = '\\'; *o++ = 't'; } else if ((unsigned char)*s >= 32) *o++ = *s; else o += snprintf(o, 8, "\\x%02x", (unsigned char)*s); } *o++ = '"'; *o = 0; return b; } static int valid_base(int base) { return (base == 0 || (base >= 2 && base <= 36)); } static void report(const char *tag, const char *fam, const char *in, int base, intmax_t kv, int ko, intmax_t lv, int lo, int lerr) { printf("%s %s=%-28s b=%-3d kernel=%20jd (off %3d) libc=%20jd (off %3d) libc_ERANGE=%d\n", tag, fam, esc(in), base, kv, ko, lv, lo, lerr); } static void one(const char *in, int base, int uns) { char *sentinel = (char *)0x1; /* libc EINVAL leaves *endptr untouched */ char *kp = sentinel, *lp = sentinel, *fp = sentinel; unsigned long kv, lv, fv; int ko, lo, fo, lerr; if (!valid_base(base)) { /* legacy-BSD class: kernel has no base validation; libc * errors out (EINVAL, *endptr untouched). No kernel caller * passes an invalid base (all in-tree callers: 0/8/10/16), * so this class is counted once and excluded from the * value/fix comparisons. */ base_sem_diffs++; return; } errno = 0; if (uns) kv = k_strtoul(in, &kp, base); else kv = (unsigned long)k_strtol(in, &kp, base); ko = (kp == sentinel) ? -99 : (int)(kp - in); errno = 0; if (uns) lv = strtoul(in, &lp, base); else lv = (unsigned long)strtol(in, &lp, base); lo = (lp == sentinel) ? -99 : (int)(lp - in); lerr = (errno == ERANGE); errno = 0; if (uns) fv = k_strtoul_fix(in, &fp, base); else fv = (unsigned long)k_strtol_fix(in, &fp, base); fo = (fp == sentinel) ? -99 : (int)(fp - in); if (!uns && (long)kv != (long)lv) { value_diffs++; report("VALUE-DIFF ", "s", in, base, (intmax_t)(long)kv, ko, (intmax_t)(long)lv, lo, lerr); } else if (uns && kv != lv) { value_diffs++; report("VALUE-DIFF ", "u", in, base, (intmax_t)kv, ko, (intmax_t)lv, lo, lerr); } else if (ko != lo) { endptr_diffs++; report("ENDPTR-DIFF", uns ? "u" : "s", in, base, (intmax_t)kv, ko, (intmax_t)lv, lo, lerr); } else if (lerr) { erange_only++; printf("ERANGE-ONLY %s=%-28s b=%-3d value=%20jd (identical saturation; libc sets ERANGE, kernel cannot)\n", uns ? "u" : "s", esc(in), base, (intmax_t)kv); } if (!uns && ((long)fv != (long)lv)) { fix_value_diffs++; printf("FIX-VALUE-REGRESSION s=%s b=%d\n", esc(in), base); } else if (uns && fv != lv) { fix_value_diffs++; printf("FIX-VALUE-REGRESSION u=%s b=%d\n", esc(in), base); } else if (fo != lo) { fix_endptr_diffs++; printf("FIX-ENDPTR-RESIDUAL %s=%s b=%d fix_off=%d libc_off=%d\n", uns ? "u" : "s", esc(in), base, fo, lo); } } int main(void) { int i, j; printf("== kernel sys/libkern/strtol.c + strtoul.c vs libc strtol/strtoul ==\n"); for (i = 0; i < NIN; i++) for (j = 0; j < NB; j++) { one(inputs[i], bases[j], 0); one(inputs[i], bases[j], 1); } printf("\nSUMMARY:\n"); printf(" kernel-vs-libc VALUE divergences : %d (must be 0)\n", value_diffs); printf(" kernel-vs-libc ENDPTR divergences : %d (DF-5703: 0x-prefix-no-xdigit class, valid bases)\n", endptr_diffs); printf(" invalid-base semantic diffs : %d (legacy BSD behavior; no kernel caller passes these)\n", base_sem_diffs); printf(" saturation w/o ERANGE (DF-2230 class) : %d (known, not re-reported)\n", erange_only); printf(" patched-kernel residual ENDPTR diffs : %d (fix validation; must be 0)\n", fix_endptr_diffs); printf(" patched-kernel VALUE regressions : %d (must be 0)\n", fix_value_diffs); return (value_diffs == 0 && fix_value_diffs == 0 && fix_endptr_diffs == 0) ? 0 : 1; }