1 // RUN: %clang_dfsan %s -o %t && DFSAN_OPTIONS="strict_data_dependencies=0" %run %t 2 // RUN: %clang_dfsan -mllvm -dfsan-args-abi %s -o %t && DFSAN_OPTIONS="strict_data_dependencies=0" %run %t 3 // RUN: %clang_dfsan -DFAST_16_LABELS -mllvm -dfsan-fast-16-labels %s -o %t && DFSAN_OPTIONS="strict_data_dependencies=0" %run %t 4 // RUN: %clang_dfsan -DSTRICT_DATA_DEPENDENCIES %s -o %t && %run %t 5 // RUN: %clang_dfsan -DSTRICT_DATA_DEPENDENCIES -mllvm -dfsan-args-abi %s -o %t && %run %t 6 // RUN: %clang_dfsan -DFAST_16_LABELS -DORIGIN_TRACKING -mllvm -dfsan-fast-16-labels -mllvm -dfsan-track-origins=1 -mllvm -dfsan-combine-pointer-labels-on-load=false -DSTRICT_DATA_DEPENDENCIES %s -o %t && %run %t 7 // RUN: %clang_dfsan -DFAST_16_LABELS -DORIGIN_TRACKING -mllvm -dfsan-fast-16-labels -mllvm -dfsan-track-origins=1 -mllvm -dfsan-combine-pointer-labels-on-load=false %s -o %t && DFSAN_OPTIONS="strict_data_dependencies=0" %run %t 8 // 9 // Tests custom implementations of various glibc functions. 10 // 11 // REQUIRES: x86_64-target-arch 12 13 #include <sanitizer/dfsan_interface.h> 14 15 #include <arpa/inet.h> 16 #include <assert.h> 17 #include <fcntl.h> 18 #include <link.h> 19 #include <poll.h> 20 #include <pthread.h> 21 #include <pwd.h> 22 #include <sched.h> 23 #include <signal.h> 24 #include <stdint.h> 25 #include <stdio.h> 26 #include <stdlib.h> 27 #include <string.h> 28 #include <strings.h> 29 #include <sys/epoll.h> 30 #include <sys/resource.h> 31 #include <sys/select.h> 32 #include <sys/socket.h> 33 #include <sys/stat.h> 34 #include <sys/time.h> 35 #include <sys/types.h> 36 #include <time.h> 37 #include <unistd.h> 38 39 dfsan_label i_label = 0; 40 dfsan_label j_label = 0; 41 dfsan_label k_label = 0; 42 dfsan_label m_label = 0; 43 dfsan_label n_label = 0; 44 dfsan_label i_j_label = 0; 45 46 #define ASSERT_ZERO_LABEL(data) \ 47 assert(0 == dfsan_get_label((long) (data))) 48 49 #define ASSERT_READ_ZERO_LABEL(ptr, size) \ 50 assert(0 == dfsan_read_label(ptr, size)) 51 52 #define ASSERT_LABEL(data, label) \ 53 assert(label == dfsan_get_label((long) (data))) 54 55 #define ASSERT_READ_LABEL(ptr, size, label) \ 56 assert(label == dfsan_read_label(ptr, size)) 57 58 #ifdef ORIGIN_TRACKING 59 #define ASSERT_ZERO_ORIGIN(data) \ 60 assert(0 == dfsan_get_origin((long)(data))) 61 #else 62 #define ASSERT_ZERO_ORIGIN(data) 63 #endif 64 65 #ifdef ORIGIN_TRACKING 66 #define ASSERT_ZERO_ORIGINS(ptr, size) \ 67 for (int i = 0; i < size; ++i) { \ 68 assert(0 == dfsan_get_origin((long)(((char *)ptr)[i]))); \ 69 } 70 #else 71 #define ASSERT_ZERO_ORIGINS(ptr, size) 72 #endif 73 74 #ifdef ORIGIN_TRACKING 75 #define ASSERT_ORIGIN(data, origin) \ 76 assert(origin == dfsan_get_origin((long)(data))) 77 #else 78 #define ASSERT_ORIGIN(data, origin) 79 #endif 80 81 #ifdef ORIGIN_TRACKING 82 #define ASSERT_ORIGINS(ptr, size, origin) \ 83 for (int i = 0; i < size; ++i) { \ 84 assert(origin == dfsan_get_origin((long)(((char *)ptr)[i]))); \ 85 } 86 #else 87 #define ASSERT_ORIGINS(ptr, size, origin) 88 #endif 89 90 #ifdef ORIGIN_TRACKING 91 #define ASSERT_INIT_ORIGIN(ptr, origin) \ 92 assert(origin == dfsan_get_init_origin(ptr)) 93 #else 94 #define ASSERT_INIT_ORIGIN(ptr, origin) 95 #endif 96 97 #ifdef ORIGIN_TRACKING 98 #define ASSERT_INIT_ORIGIN_EQ_ORIGIN(ptr, data) \ 99 assert(dfsan_get_origin((long)(data)) == dfsan_get_init_origin(ptr)) 100 #else 101 #define ASSERT_INIT_ORIGIN_EQ_ORIGIN(ptr, data) 102 #endif 103 104 #ifdef ORIGIN_TRACKING 105 #define ASSERT_INIT_ORIGINS(ptr, size, origin) \ 106 for (int i = 0; i < size; ++i) { \ 107 assert(origin == dfsan_get_init_origin(&((char *)ptr)[i])); \ 108 } 109 #else 110 #define ASSERT_INIT_ORIGINS(ptr, size, origin) 111 #endif 112 113 #ifdef ORIGIN_TRACKING 114 #define ASSERT_EQ_ORIGIN(data1, data2) \ 115 assert(dfsan_get_origin((long)(data1)) == dfsan_get_origin((long)(data2))) 116 #else 117 #define ASSERT_EQ_ORIGIN(data1, data2) 118 #endif 119 120 #ifdef ORIGIN_TRACKING 121 #define DEFINE_AND_SAVE_ORIGINS(val) \ 122 dfsan_origin val##_o[sizeof(val)]; \ 123 for (int i = 0; i < sizeof(val); ++i) \ 124 val##_o[i] = dfsan_get_origin((long)(((char *)(&val))[i])); 125 #else 126 #define DEFINE_AND_SAVE_ORIGINS(val) 127 #endif 128 129 #ifdef ORIGIN_TRACKING 130 #define SAVE_ORIGINS(val) \ 131 for (int i = 0; i < sizeof(val); ++i) \ 132 val##_o[i] = dfsan_get_origin((long)(((char *)(&val))[i])); 133 #else 134 #define SAVE_ORIGINS(val) 135 #endif 136 137 #ifdef ORIGIN_TRACKING 138 #define ASSERT_SAVED_ORIGINS(val) \ 139 for (int i = 0; i < sizeof(val); ++i) \ 140 ASSERT_ORIGIN(((char *)(&val))[i], val##_o[i]); 141 #else 142 #define ASSERT_SAVED_ORIGINS(val) 143 #endif 144 145 void test_stat() { 146 int i = 1; 147 dfsan_set_label(i_label, &i, sizeof(i)); 148 149 struct stat s; 150 s.st_dev = i; 151 DEFINE_AND_SAVE_ORIGINS(s) 152 int ret = stat("/", &s); 153 assert(0 == ret); 154 ASSERT_ZERO_LABEL(ret); 155 ASSERT_ZERO_LABEL(s.st_dev); 156 ASSERT_SAVED_ORIGINS(s) 157 158 s.st_dev = i; 159 SAVE_ORIGINS(s) 160 ret = stat("/nonexistent", &s); 161 assert(-1 == ret); 162 ASSERT_ZERO_LABEL(ret); 163 ASSERT_LABEL(s.st_dev, i_label); 164 ASSERT_SAVED_ORIGINS(s) 165 } 166 167 void test_fstat() { 168 int i = 1; 169 dfsan_set_label(i_label, &i, sizeof(i)); 170 171 struct stat s; 172 int fd = open("/dev/zero", O_RDONLY); 173 s.st_dev = i; 174 DEFINE_AND_SAVE_ORIGINS(s) 175 int rv = fstat(fd, &s); 176 assert(0 == rv); 177 ASSERT_ZERO_LABEL(rv); 178 ASSERT_ZERO_LABEL(s.st_dev); 179 ASSERT_SAVED_ORIGINS(s) 180 } 181 182 void test_memcmp() { 183 char str1[] = "str1", str2[] = "str2"; 184 dfsan_set_label(i_label, &str1[3], 1); 185 dfsan_set_label(j_label, &str2[3], 1); 186 187 int rv = memcmp(str1, str2, sizeof(str1)); 188 assert(rv < 0); 189 #ifdef STRICT_DATA_DEPENDENCIES 190 ASSERT_ZERO_LABEL(rv); 191 #else 192 ASSERT_LABEL(rv, i_j_label); 193 ASSERT_EQ_ORIGIN(rv, str1[3]); 194 #endif 195 196 rv = memcmp(str1, str2, sizeof(str1) - 2); 197 assert(rv == 0); 198 ASSERT_ZERO_LABEL(rv); 199 } 200 201 void test_bcmp() { 202 char str1[] = "str1", str2[] = "str2"; 203 dfsan_set_label(i_label, &str1[3], 1); 204 dfsan_set_label(j_label, &str2[3], 1); 205 206 int rv = bcmp(str1, str2, sizeof(str1)); 207 assert(rv != 0); 208 #ifdef STRICT_DATA_DEPENDENCIES 209 ASSERT_ZERO_LABEL(rv); 210 #else 211 ASSERT_LABEL(rv, i_j_label); 212 ASSERT_EQ_ORIGIN(rv, str1[3]); 213 #endif 214 215 rv = bcmp(str1, str2, sizeof(str1) - 2); 216 assert(rv == 0); 217 ASSERT_ZERO_LABEL(rv); 218 } 219 220 void test_memcpy() { 221 char str1[] = "str1"; 222 char str2[sizeof(str1)]; 223 dfsan_set_label(i_label, &str1[3], 1); 224 225 DEFINE_AND_SAVE_ORIGINS(str1) 226 227 char *ptr2 = str2; 228 dfsan_set_label(j_label, &ptr2, sizeof(ptr2)); 229 230 void *r = memcpy(ptr2, str1, sizeof(str1)); 231 ASSERT_LABEL(r, j_label); 232 ASSERT_EQ_ORIGIN(r, ptr2); 233 assert(0 == memcmp(str2, str1, sizeof(str1))); 234 ASSERT_ZERO_LABEL(str2[0]); 235 ASSERT_LABEL(str2[3], i_label); 236 237 for (int i = 0; i < sizeof(str2); ++i) { 238 if (!dfsan_get_label(str2[i])) 239 continue; 240 ASSERT_INIT_ORIGIN(&(str2[i]), str1_o[i]); 241 } 242 } 243 244 void test_memmove() { 245 char str[] = "str1xx"; 246 dfsan_set_label(i_label, &str[3], 1); 247 248 DEFINE_AND_SAVE_ORIGINS(str) 249 250 char *ptr = str + 2; 251 dfsan_set_label(j_label, &ptr, sizeof(ptr)); 252 253 void *r = memmove(ptr, str, 4); 254 ASSERT_LABEL(r, j_label); 255 ASSERT_EQ_ORIGIN(r, ptr); 256 assert(0 == memcmp(str + 2, "str1", 4)); 257 ASSERT_ZERO_LABEL(str[4]); 258 ASSERT_LABEL(str[5], i_label); 259 260 for (int i = 0; i < 4; ++i) { 261 if (!dfsan_get_label(ptr[i])) 262 continue; 263 ASSERT_INIT_ORIGIN(&(ptr[i]), str_o[i]); 264 } 265 } 266 267 void test_memset() { 268 char buf[8]; 269 int j = 'a'; 270 char *ptr = buf; 271 dfsan_set_label(j_label, &j, sizeof(j)); 272 dfsan_set_label(k_label, &ptr, sizeof(ptr)); 273 void *ret = memset(ptr, j, sizeof(buf)); 274 ASSERT_LABEL(ret, k_label); 275 ASSERT_EQ_ORIGIN(ret, ptr); 276 for (int i = 0; i < 8; ++i) { 277 ASSERT_LABEL(buf[i], j_label); 278 ASSERT_EQ_ORIGIN(buf[i], j); 279 assert(buf[i] == 'a'); 280 } 281 } 282 283 void test_strcmp() { 284 char str1[] = "str1", str2[] = "str2"; 285 dfsan_set_label(i_label, &str1[3], 1); 286 dfsan_set_label(j_label, &str2[3], 1); 287 288 int rv = strcmp(str1, str2); 289 assert(rv < 0); 290 #ifdef STRICT_DATA_DEPENDENCIES 291 ASSERT_ZERO_LABEL(rv); 292 #else 293 ASSERT_LABEL(rv, i_j_label); 294 ASSERT_EQ_ORIGIN(rv, str1[3]); 295 #endif 296 297 rv = strcmp(str1, str1); 298 assert(rv == 0); 299 #ifdef STRICT_DATA_DEPENDENCIES 300 ASSERT_ZERO_LABEL(rv); 301 ASSERT_ZERO_ORIGIN(rv); 302 #else 303 ASSERT_LABEL(rv, i_label); 304 ASSERT_EQ_ORIGIN(rv, str1[3]); 305 #endif 306 } 307 308 void test_strcat() { 309 char src[] = "world"; 310 int volatile x = 0; // buffer to ensure src and dst do not share origins 311 char dst[] = "hello \0 "; 312 int volatile y = 0; // buffer to ensure dst and p do not share origins 313 char *p = dst; 314 dfsan_set_label(k_label, &p, sizeof(p)); 315 dfsan_set_label(i_label, src, sizeof(src)); 316 dfsan_set_label(j_label, dst, sizeof(dst)); 317 dfsan_origin dst_o = dfsan_get_origin((long)dst[0]); 318 char *ret = strcat(p, src); 319 ASSERT_LABEL(ret, k_label); 320 ASSERT_EQ_ORIGIN(ret, p); 321 assert(ret == dst); 322 assert(strcmp(src, dst + 6) == 0); 323 // Origins are assigned for every 4 contiguous 4-aligned bytes. After 324 // appending src to dst, origins of src can overwrite origins of dst if their 325 // application adddresses are within [start_aligned_down, end_aligned_up). 326 // Other origins are not changed. 327 char *start_aligned_down = (char *)(((size_t)(dst + 6)) & ~3UL); 328 char *end_aligned_up = (char *)(((size_t)(dst + 11 + 4)) & ~3UL); 329 for (int i = 0; i < 12; ++i) { 330 if (dst + i < start_aligned_down || dst + i >= end_aligned_up) { 331 ASSERT_INIT_ORIGIN(&dst[i], dst_o); 332 } else { 333 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&dst[i], src[0]); 334 } 335 } 336 for (int i = 0; i < 6; ++i) { 337 ASSERT_LABEL(dst[i], j_label); 338 } 339 for (int i = 6; i < strlen(dst); ++i) { 340 ASSERT_LABEL(dst[i], i_label); 341 assert(dfsan_get_label(dst[i]) == dfsan_get_label(src[i - 6])); 342 } 343 ASSERT_LABEL(dst[11], j_label); 344 } 345 346 void test_strlen() { 347 char str1[] = "str1"; 348 dfsan_set_label(i_label, &str1[3], 1); 349 350 int rv = strlen(str1); 351 assert(rv == 4); 352 #ifdef STRICT_DATA_DEPENDENCIES 353 ASSERT_ZERO_LABEL(rv); 354 #else 355 ASSERT_LABEL(rv, i_label); 356 ASSERT_EQ_ORIGIN(rv, str1[3]); 357 #endif 358 } 359 360 void test_strdup() { 361 char str1[] = "str1"; 362 dfsan_set_label(i_label, &str1[3], 1); 363 DEFINE_AND_SAVE_ORIGINS(str1) 364 365 char *strd = strdup(str1); 366 ASSERT_ZERO_LABEL(strd); 367 ASSERT_ZERO_LABEL(strd[0]); 368 ASSERT_LABEL(strd[3], i_label); 369 370 for (int i = 0; i < strlen(strd); ++i) { 371 if (!dfsan_get_label(strd[i])) 372 continue; 373 ASSERT_INIT_ORIGIN(&(strd[i]), str1_o[i]); 374 } 375 376 free(strd); 377 } 378 379 void test_strncpy() { 380 char str1[] = "str1"; 381 char str2[sizeof(str1)]; 382 dfsan_set_label(i_label, &str1[3], 1); 383 384 char *strd = strncpy(str2, str1, 5); 385 assert(strd == str2); 386 assert(strcmp(str1, str2) == 0); 387 ASSERT_ZERO_LABEL(strd); 388 ASSERT_ZERO_LABEL(strd[0]); 389 ASSERT_ZERO_LABEL(strd[1]); 390 ASSERT_ZERO_LABEL(strd[2]); 391 ASSERT_LABEL(strd[3], i_label); 392 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&(strd[3]), str1[3]); 393 394 char *p2 = str2; 395 dfsan_set_label(j_label, &p2, sizeof(p2)); 396 strd = strncpy(p2, str1, 3); 397 assert(strd == str2); 398 assert(strncmp(str1, str2, 3) == 0); 399 ASSERT_LABEL(strd, j_label); 400 ASSERT_EQ_ORIGIN(strd, p2); 401 // When -dfsan-combine-pointer-labels-on-load is on, strd's label propagates 402 // to strd[i]'s label. When ORIGIN_TRACKING is defined, 403 // -dfsan-combine-pointer-labels-on-load is always off, otherwise the flag 404 // is on by default. 405 #if defined(ORIGIN_TRACKING) 406 ASSERT_ZERO_LABEL(strd[0]); 407 ASSERT_ZERO_LABEL(strd[1]); 408 ASSERT_ZERO_LABEL(strd[2]); 409 #else 410 ASSERT_LABEL(strd[0], j_label); 411 ASSERT_LABEL(strd[1], j_label); 412 ASSERT_LABEL(strd[2], j_label); 413 #endif 414 } 415 416 void test_strncmp() { 417 char str1[] = "str1", str2[] = "str2"; 418 dfsan_set_label(i_label, &str1[3], 1); 419 dfsan_set_label(j_label, &str2[3], 1); 420 421 int rv = strncmp(str1, str2, sizeof(str1)); 422 assert(rv < 0); 423 #ifdef STRICT_DATA_DEPENDENCIES 424 ASSERT_ZERO_LABEL(rv); 425 #else 426 ASSERT_LABEL(rv, dfsan_union(i_label, j_label)); 427 ASSERT_EQ_ORIGIN(rv, str1[3]); 428 #endif 429 430 rv = strncmp(str1, str2, 0); 431 assert(rv == 0); 432 ASSERT_ZERO_LABEL(rv); 433 434 rv = strncmp(str1, str2, 3); 435 assert(rv == 0); 436 ASSERT_ZERO_LABEL(rv); 437 438 rv = strncmp(str1, str1, 4); 439 assert(rv == 0); 440 #ifdef STRICT_DATA_DEPENDENCIES 441 ASSERT_ZERO_LABEL(rv); 442 #else 443 ASSERT_LABEL(rv, i_label); 444 ASSERT_EQ_ORIGIN(rv, str1[3]); 445 #endif 446 } 447 448 void test_strcasecmp() { 449 char str1[] = "str1", str2[] = "str2", str3[] = "Str1"; 450 dfsan_set_label(i_label, &str1[3], 1); 451 dfsan_set_label(j_label, &str2[3], 1); 452 dfsan_set_label(j_label, &str3[2], 1); 453 454 int rv = strcasecmp(str1, str2); 455 assert(rv < 0); 456 #ifdef STRICT_DATA_DEPENDENCIES 457 ASSERT_ZERO_LABEL(rv); 458 #else 459 ASSERT_LABEL(rv, dfsan_union(i_label, j_label)); 460 ASSERT_EQ_ORIGIN(rv, str1[3]); 461 #endif 462 463 rv = strcasecmp(str1, str3); 464 assert(rv == 0); 465 #ifdef STRICT_DATA_DEPENDENCIES 466 ASSERT_ZERO_LABEL(rv); 467 #else 468 ASSERT_LABEL(rv, dfsan_union(i_label, j_label)); 469 ASSERT_EQ_ORIGIN(rv, str1[3]); 470 #endif 471 472 char s1[] = "AbZ"; 473 char s2[] = "aBy"; 474 dfsan_set_label(i_label, &s1[2], 1); 475 dfsan_set_label(j_label, &s2[2], 1); 476 477 rv = strcasecmp(s1, s2); 478 assert(rv > 0); // 'Z' > 'y' 479 #ifdef STRICT_DATA_DEPENDENCIES 480 ASSERT_ZERO_LABEL(rv); 481 #else 482 ASSERT_LABEL(rv, dfsan_union(i_label, j_label)); 483 ASSERT_EQ_ORIGIN(rv, s1[2]); 484 #endif 485 } 486 487 void test_strncasecmp() { 488 char str1[] = "Str1", str2[] = "str2"; 489 dfsan_set_label(i_label, &str1[3], 1); 490 dfsan_set_label(j_label, &str2[3], 1); 491 492 int rv = strncasecmp(str1, str2, sizeof(str1)); 493 assert(rv < 0); 494 #ifdef STRICT_DATA_DEPENDENCIES 495 ASSERT_ZERO_LABEL(rv); 496 #else 497 ASSERT_LABEL(rv, dfsan_union(i_label, j_label)); 498 ASSERT_EQ_ORIGIN(rv, str1[3]); 499 #endif 500 501 rv = strncasecmp(str1, str2, 3); 502 assert(rv == 0); 503 ASSERT_ZERO_LABEL(rv); 504 505 char s1[] = "AbZ"; 506 char s2[] = "aBy"; 507 dfsan_set_label(i_label, &s1[2], 1); 508 dfsan_set_label(j_label, &s2[2], 1); 509 510 rv = strncasecmp(s1, s2, 0); 511 assert(rv == 0); // Compare zero chars. 512 ASSERT_ZERO_LABEL(rv); 513 514 rv = strncasecmp(s1, s2, 1); 515 assert(rv == 0); // 'A' == 'a' 516 ASSERT_ZERO_LABEL(rv); 517 518 rv = strncasecmp(s1, s2, 2); 519 assert(rv == 0); // 'b' == 'B' 520 ASSERT_ZERO_LABEL(rv); 521 522 rv = strncasecmp(s1, s2, 3); 523 assert(rv > 0); // 'Z' > 'y' 524 #ifdef STRICT_DATA_DEPENDENCIES 525 ASSERT_ZERO_LABEL(rv); 526 #else 527 ASSERT_LABEL(rv, dfsan_union(i_label, j_label)); 528 ASSERT_EQ_ORIGIN(rv, s1[2]); 529 #endif 530 } 531 532 void test_strchr() { 533 char str1[] = "str1"; 534 dfsan_set_label(i_label, &str1[3], 1); 535 536 char *p1 = str1; 537 char c = 'r'; 538 dfsan_set_label(k_label, &c, sizeof(c)); 539 540 char *crv = strchr(p1, c); 541 assert(crv == &str1[2]); 542 #ifdef STRICT_DATA_DEPENDENCIES 543 ASSERT_ZERO_LABEL(crv); 544 #else 545 ASSERT_LABEL(crv, k_label); 546 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&crv, c); 547 #endif 548 549 dfsan_set_label(j_label, &p1, sizeof(p1)); 550 crv = strchr(p1, 'r'); 551 assert(crv == &str1[2]); 552 ASSERT_LABEL(crv, j_label); 553 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&crv, p1); 554 555 crv = strchr(p1, '1'); 556 assert(crv == &str1[3]); 557 #ifdef STRICT_DATA_DEPENDENCIES 558 ASSERT_LABEL(crv, j_label); 559 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&crv, p1); 560 #else 561 ASSERT_LABEL(crv, i_j_label); 562 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&crv, str1[3]); 563 #endif 564 565 crv = strchr(p1, 'x'); 566 assert(!crv); 567 #ifdef STRICT_DATA_DEPENDENCIES 568 ASSERT_LABEL(crv, j_label); 569 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&crv, p1); 570 #else 571 ASSERT_LABEL(crv, i_j_label); 572 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&crv, str1[3]); 573 #endif 574 575 // `man strchr` says: 576 // The terminating null byte is considered part of the string, so that if c 577 // is specified as '\0', these functions return a pointer to the terminator. 578 crv = strchr(p1, '\0'); 579 assert(crv == &str1[4]); 580 #ifdef STRICT_DATA_DEPENDENCIES 581 ASSERT_LABEL(crv, j_label); 582 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&crv, p1); 583 #else 584 ASSERT_LABEL(crv, i_j_label); 585 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&crv, str1[3]); 586 #endif 587 } 588 589 void test_calloc() { 590 // With any luck this sequence of calls will cause calloc to return the same 591 // pointer both times. This is probably the best we can do to test this 592 // function. 593 char *crv = (char *) calloc(4096, 1); 594 ASSERT_ZERO_LABEL(crv[0]); 595 dfsan_set_label(i_label, crv, 100); 596 free(crv); 597 598 crv = (char *) calloc(4096, 1); 599 ASSERT_ZERO_LABEL(crv[0]); 600 free(crv); 601 } 602 603 #if !defined(ORIGIN_TRACKING) 604 void test_recvmmsg() { 605 int sockfds[2]; 606 int ret = socketpair(AF_UNIX, SOCK_DGRAM, 0, sockfds); 607 assert(ret != -1); 608 609 // Setup messages to send. 610 struct mmsghdr smmsg[2] = {}; 611 char sbuf0[] = "abcdefghijkl"; 612 struct iovec siov0[2] = {{&sbuf0[0], 4}, {&sbuf0[4], 4}}; 613 smmsg[0].msg_hdr.msg_iov = siov0; 614 smmsg[0].msg_hdr.msg_iovlen = 2; 615 char sbuf1[] = "1234567890"; 616 struct iovec siov1[1] = {{&sbuf1[0], 7}}; 617 smmsg[1].msg_hdr.msg_iov = siov1; 618 smmsg[1].msg_hdr.msg_iovlen = 1; 619 620 // Send messages. 621 int sent_msgs = sendmmsg(sockfds[0], smmsg, 2, 0); 622 assert(sent_msgs == 2); 623 624 // Setup receive buffers. 625 struct mmsghdr rmmsg[2] = {}; 626 char rbuf0[128]; 627 struct iovec riov0[2] = {{&rbuf0[0], 4}, {&rbuf0[4], 4}}; 628 rmmsg[0].msg_hdr.msg_iov = riov0; 629 rmmsg[0].msg_hdr.msg_iovlen = 2; 630 char rbuf1[128]; 631 struct iovec riov1[1] = {{&rbuf1[0], 16}}; 632 rmmsg[1].msg_hdr.msg_iov = riov1; 633 rmmsg[1].msg_hdr.msg_iovlen = 1; 634 struct timespec timeout = {1, 1}; 635 dfsan_set_label(i_label, rbuf0, sizeof(rbuf0)); 636 dfsan_set_label(i_label, rbuf1, sizeof(rbuf1)); 637 dfsan_set_label(i_label, &rmmsg[0].msg_len, sizeof(rmmsg[0].msg_len)); 638 dfsan_set_label(i_label, &rmmsg[1].msg_len, sizeof(rmmsg[1].msg_len)); 639 dfsan_set_label(i_label, &timeout, sizeof(timeout)); 640 641 // Receive messages and check labels. 642 int received_msgs = recvmmsg(sockfds[1], rmmsg, 2, 0, &timeout); 643 assert(received_msgs == sent_msgs); 644 assert(rmmsg[0].msg_len == smmsg[0].msg_len); 645 assert(rmmsg[1].msg_len == smmsg[1].msg_len); 646 assert(memcmp(sbuf0, rbuf0, 8) == 0); 647 assert(memcmp(sbuf1, rbuf1, 7) == 0); 648 ASSERT_ZERO_LABEL(received_msgs); 649 ASSERT_ZERO_LABEL(rmmsg[0].msg_len); 650 ASSERT_ZERO_LABEL(rmmsg[1].msg_len); 651 ASSERT_READ_ZERO_LABEL(&rbuf0[0], 8); 652 ASSERT_READ_LABEL(&rbuf0[8], 1, i_label); 653 ASSERT_READ_ZERO_LABEL(&rbuf1[0], 7); 654 ASSERT_READ_LABEL(&rbuf1[7], 1, i_label); 655 ASSERT_LABEL(timeout.tv_sec, i_label); 656 ASSERT_LABEL(timeout.tv_nsec, i_label); 657 658 close(sockfds[0]); 659 close(sockfds[1]); 660 } 661 662 void test_recvmsg() { 663 int sockfds[2]; 664 int ret = socketpair(AF_UNIX, SOCK_DGRAM, 0, sockfds); 665 assert(ret != -1); 666 667 char sbuf[] = "abcdefghijkl"; 668 struct iovec siovs[2] = {{&sbuf[0], 4}, {&sbuf[4], 4}}; 669 struct msghdr smsg = {}; 670 smsg.msg_iov = siovs; 671 smsg.msg_iovlen = 2; 672 673 ssize_t sent = sendmsg(sockfds[0], &smsg, 0); 674 assert(sent > 0); 675 676 char rbuf[128]; 677 struct iovec riovs[2] = {{&rbuf[0], 4}, {&rbuf[4], 4}}; 678 struct msghdr rmsg = {}; 679 rmsg.msg_iov = riovs; 680 rmsg.msg_iovlen = 2; 681 682 dfsan_set_label(i_label, rbuf, sizeof(rbuf)); 683 dfsan_set_label(i_label, &rmsg, sizeof(rmsg)); 684 685 ssize_t received = recvmsg(sockfds[1], &rmsg, 0); 686 assert(received == sent); 687 assert(memcmp(sbuf, rbuf, 8) == 0); 688 ASSERT_ZERO_LABEL(received); 689 ASSERT_READ_ZERO_LABEL(&rmsg, sizeof(rmsg)); 690 ASSERT_READ_ZERO_LABEL(&rbuf[0], 8); 691 ASSERT_READ_LABEL(&rbuf[8], 1, i_label); 692 693 close(sockfds[0]); 694 close(sockfds[1]); 695 } 696 #endif // !defined(ORIGIN_TRACKING) 697 698 void test_read() { 699 char buf[16]; 700 dfsan_set_label(i_label, buf, 1); 701 dfsan_set_label(j_label, buf + 15, 1); 702 703 DEFINE_AND_SAVE_ORIGINS(buf) 704 ASSERT_LABEL(buf[0], i_label); 705 ASSERT_LABEL(buf[15], j_label); 706 707 int fd = open("/dev/zero", O_RDONLY); 708 int rv = read(fd, buf, sizeof(buf)); 709 assert(rv == sizeof(buf)); 710 ASSERT_ZERO_LABEL(rv); 711 ASSERT_ZERO_LABEL(buf[0]); 712 ASSERT_ZERO_LABEL(buf[15]); 713 ASSERT_SAVED_ORIGINS(buf) 714 close(fd); 715 } 716 717 void test_pread() { 718 char buf[16]; 719 dfsan_set_label(i_label, buf, 1); 720 dfsan_set_label(j_label, buf + 15, 1); 721 722 DEFINE_AND_SAVE_ORIGINS(buf) 723 ASSERT_LABEL(buf[0], i_label); 724 ASSERT_LABEL(buf[15], j_label); 725 726 int fd = open("/bin/sh", O_RDONLY); 727 int rv = pread(fd, buf, sizeof(buf), 0); 728 assert(rv == sizeof(buf)); 729 ASSERT_ZERO_LABEL(rv); 730 ASSERT_ZERO_LABEL(buf[0]); 731 ASSERT_ZERO_LABEL(buf[15]); 732 ASSERT_SAVED_ORIGINS(buf) 733 close(fd); 734 } 735 736 void test_dlopen() { 737 void *map = dlopen(NULL, RTLD_NOW); 738 assert(map); 739 ASSERT_ZERO_LABEL(map); 740 dlclose(map); 741 map = dlopen("/nonexistent", RTLD_NOW); 742 assert(!map); 743 ASSERT_ZERO_LABEL(map); 744 } 745 746 void test_clock_gettime() { 747 struct timespec tp; 748 dfsan_set_label(j_label, ((char *)&tp) + 3, 1); 749 dfsan_origin origin = dfsan_get_origin((long)(((char *)&tp)[3])); 750 int t = clock_gettime(CLOCK_REALTIME, &tp); 751 assert(t == 0); 752 ASSERT_ZERO_LABEL(t); 753 ASSERT_ZERO_LABEL(((char *)&tp)[3]); 754 ASSERT_ORIGIN(((char *)&tp)[3], origin); 755 } 756 757 #if !defined(ORIGIN_TRACKING) 758 void test_ctime_r() { 759 char *buf = (char*) malloc(64); 760 time_t t = 0; 761 762 char *ret = ctime_r(&t, buf); 763 ASSERT_ZERO_LABEL(ret); 764 assert(buf == ret); 765 ASSERT_READ_ZERO_LABEL(buf, strlen(buf) + 1); 766 767 dfsan_set_label(i_label, &t, sizeof(t)); 768 ret = ctime_r(&t, buf); 769 ASSERT_ZERO_LABEL(ret); 770 ASSERT_READ_LABEL(buf, strlen(buf) + 1, i_label); 771 772 t = 0; 773 dfsan_set_label(j_label, &buf, sizeof(&buf)); 774 ret = ctime_r(&t, buf); 775 ASSERT_LABEL(ret, j_label); 776 ASSERT_READ_ZERO_LABEL(buf, strlen(buf) + 1); 777 } 778 #endif // !defined(ORIGIN_TRACKING) 779 780 static int write_callback_count = 0; 781 static int last_fd; 782 static const unsigned char *last_buf; 783 static size_t last_count; 784 785 void write_callback(int fd, const void *buf, size_t count) { 786 write_callback_count++; 787 788 last_fd = fd; 789 last_buf = (const unsigned char*) buf; 790 last_count = count; 791 } 792 793 void test_dfsan_set_write_callback() { 794 char buf[] = "Sample chars"; 795 int buf_len = strlen(buf); 796 797 int fd = open("/dev/null", O_WRONLY); 798 799 dfsan_set_write_callback(write_callback); 800 801 write_callback_count = 0; 802 803 DEFINE_AND_SAVE_ORIGINS(buf) 804 805 // Callback should be invoked on every call to write(). 806 int res = write(fd, buf, buf_len); 807 assert(write_callback_count == 1); 808 ASSERT_READ_ZERO_LABEL(&res, sizeof(res)); 809 ASSERT_READ_ZERO_LABEL(&last_fd, sizeof(last_fd)); 810 ASSERT_READ_ZERO_LABEL(last_buf, sizeof(last_buf)); 811 ASSERT_READ_ZERO_LABEL(&last_count, sizeof(last_count)); 812 813 for (int i = 0; i < buf_len; ++i) 814 ASSERT_ORIGIN(last_buf[i], buf_o[i]); 815 816 ASSERT_ZERO_ORIGINS(&last_count, sizeof(last_count)); 817 818 // Add a label to write() arguments. Check that the labels are readable from 819 // the values passed to the callback. 820 dfsan_set_label(i_label, &fd, sizeof(fd)); 821 dfsan_set_label(j_label, &(buf[3]), 1); 822 dfsan_set_label(k_label, &buf_len, sizeof(buf_len)); 823 824 dfsan_origin fd_o = dfsan_get_origin((long)fd); 825 dfsan_origin buf3_o = dfsan_get_origin((long)(buf[3])); 826 dfsan_origin buf_len_o = dfsan_get_origin((long)buf_len); 827 828 res = write(fd, buf, buf_len); 829 assert(write_callback_count == 2); 830 ASSERT_READ_ZERO_LABEL(&res, sizeof(res)); 831 ASSERT_READ_LABEL(&last_fd, sizeof(last_fd), i_label); 832 ASSERT_READ_LABEL(&last_buf[3], sizeof(last_buf[3]), j_label); 833 ASSERT_READ_LABEL(last_buf, sizeof(last_buf), j_label); 834 ASSERT_READ_LABEL(&last_count, sizeof(last_count), k_label); 835 ASSERT_ZERO_ORIGINS(&res, sizeof(res)); 836 ASSERT_INIT_ORIGINS(&last_fd, sizeof(last_fd), fd_o); 837 ASSERT_INIT_ORIGINS(&last_buf[3], sizeof(last_buf[3]), buf3_o); 838 839 // Origins are assigned for every 4 contiguous 4-aligned bytes. After 840 // appending src to dst, origins of src can overwrite origins of dst if their 841 // application adddresses are within an aligned range. Other origins are not 842 // changed. 843 for (int i = 0; i < buf_len; ++i) { 844 size_t i_addr = size_t(&last_buf[i]); 845 if (((size_t(&last_buf[3]) & ~3UL) > i_addr) || 846 (((size_t(&last_buf[3]) + 4) & ~3UL) <= i_addr)) 847 ASSERT_ORIGIN(last_buf[i], buf_o[i]); 848 } 849 850 ASSERT_INIT_ORIGINS(&last_count, sizeof(last_count), buf_len_o); 851 852 dfsan_set_write_callback(NULL); 853 } 854 855 #if !defined(ORIGIN_TRACKING) 856 void test_fgets() { 857 char *buf = (char*) malloc(128); 858 FILE *f = fopen("/etc/passwd", "r"); 859 dfsan_set_label(j_label, buf, 1); 860 char *ret = fgets(buf, sizeof(buf), f); 861 assert(ret == buf); 862 ASSERT_ZERO_LABEL(ret); 863 ASSERT_READ_ZERO_LABEL(buf, 128); 864 dfsan_set_label(j_label, &buf, sizeof(&buf)); 865 ret = fgets(buf, sizeof(buf), f); 866 ASSERT_LABEL(ret, j_label); 867 fclose(f); 868 } 869 870 void test_getcwd() { 871 char buf[1024]; 872 char *ptr = buf; 873 dfsan_set_label(i_label, buf + 2, 2); 874 char* ret = getcwd(buf, sizeof(buf)); 875 assert(ret == buf); 876 assert(ret[0] == '/'); 877 ASSERT_READ_ZERO_LABEL(buf + 2, 2); 878 dfsan_set_label(i_label, &ptr, sizeof(ptr)); 879 ret = getcwd(ptr, sizeof(buf)); 880 ASSERT_LABEL(ret, i_label); 881 } 882 883 void test_get_current_dir_name() { 884 char* ret = get_current_dir_name(); 885 assert(ret); 886 assert(ret[0] == '/'); 887 ASSERT_READ_ZERO_LABEL(ret, strlen(ret) + 1); 888 } 889 890 void test_gethostname() { 891 char buf[1024]; 892 dfsan_set_label(i_label, buf + 2, 2); 893 assert(gethostname(buf, sizeof(buf)) == 0); 894 ASSERT_READ_ZERO_LABEL(buf + 2, 2); 895 } 896 897 void test_getrlimit() { 898 struct rlimit rlim; 899 dfsan_set_label(i_label, &rlim, sizeof(rlim)); 900 assert(getrlimit(RLIMIT_CPU, &rlim) == 0); 901 ASSERT_READ_ZERO_LABEL(&rlim, sizeof(rlim)); 902 } 903 904 void test_getrusage() { 905 struct rusage usage; 906 dfsan_set_label(i_label, &usage, sizeof(usage)); 907 assert(getrusage(RUSAGE_SELF, &usage) == 0); 908 ASSERT_READ_ZERO_LABEL(&usage, sizeof(usage)); 909 } 910 911 void test_strcpy() { 912 char src[] = "hello world"; 913 char dst[sizeof(src) + 2]; 914 dfsan_set_label(0, src, sizeof(src)); 915 dfsan_set_label(0, dst, sizeof(dst)); 916 dfsan_set_label(i_label, src + 2, 1); 917 dfsan_set_label(j_label, src + 3, 1); 918 dfsan_set_label(j_label, dst + 4, 1); 919 dfsan_set_label(i_label, dst + 12, 1); 920 char *ret = strcpy(dst, src); 921 assert(ret == dst); 922 assert(strcmp(src, dst) == 0); 923 for (int i = 0; i < strlen(src) + 1; ++i) { 924 assert(dfsan_get_label(dst[i]) == dfsan_get_label(src[i])); 925 } 926 // Note: if strlen(src) + 1 were used instead to compute the first untouched 927 // byte of dest, the label would be I|J. This is because strlen() might 928 // return a non-zero label, and because by default pointer labels are not 929 // ignored on loads. 930 ASSERT_LABEL(dst[12], i_label); 931 } 932 933 void test_strtol() { 934 char buf[] = "1234578910"; 935 char *endptr = NULL; 936 dfsan_set_label(i_label, buf + 1, 1); 937 dfsan_set_label(j_label, buf + 10, 1); 938 long int ret = strtol(buf, &endptr, 10); 939 assert(ret == 1234578910); 940 assert(endptr == buf + 10); 941 ASSERT_LABEL(ret, i_j_label); 942 } 943 944 void test_strtoll() { 945 char buf[] = "1234578910 "; 946 char *endptr = NULL; 947 dfsan_set_label(i_label, buf + 1, 1); 948 dfsan_set_label(j_label, buf + 2, 1); 949 long long int ret = strtoll(buf, &endptr, 10); 950 assert(ret == 1234578910); 951 assert(endptr == buf + 10); 952 ASSERT_LABEL(ret, i_j_label); 953 } 954 955 void test_strtoul() { 956 char buf[] = "ffffffffffffaa"; 957 char *endptr = NULL; 958 dfsan_set_label(i_label, buf + 1, 1); 959 dfsan_set_label(j_label, buf + 2, 1); 960 long unsigned int ret = strtol(buf, &endptr, 16); 961 assert(ret == 72057594037927850); 962 assert(endptr == buf + 14); 963 ASSERT_LABEL(ret, i_j_label); 964 } 965 966 void test_strtoull() { 967 char buf[] = "ffffffffffffffaa"; 968 char *endptr = NULL; 969 dfsan_set_label(i_label, buf + 1, 1); 970 dfsan_set_label(j_label, buf + 2, 1); 971 long long unsigned int ret = strtoull(buf, &endptr, 16); 972 assert(ret == 0xffffffffffffffaa); 973 assert(endptr == buf + 16); 974 ASSERT_LABEL(ret, i_j_label); 975 } 976 977 void test_strtod() { 978 char buf[] = "12345.76 foo"; 979 char *endptr = NULL; 980 dfsan_set_label(i_label, buf + 1, 1); 981 dfsan_set_label(j_label, buf + 6, 1); 982 double ret = strtod(buf, &endptr); 983 assert(ret == 12345.76); 984 assert(endptr == buf + 8); 985 ASSERT_LABEL(ret, i_j_label); 986 } 987 988 void test_time() { 989 time_t t = 0; 990 dfsan_set_label(i_label, &t, 1); 991 time_t ret = time(&t); 992 assert(ret == t); 993 assert(ret > 0); 994 ASSERT_ZERO_LABEL(t); 995 } 996 997 void test_inet_pton() { 998 char addr4[] = "127.0.0.1"; 999 dfsan_set_label(i_label, addr4 + 3, 1); 1000 struct in_addr in4; 1001 int ret4 = inet_pton(AF_INET, addr4, &in4); 1002 assert(ret4 == 1); 1003 ASSERT_READ_LABEL(&in4, sizeof(in4), i_label); 1004 assert(in4.s_addr == htonl(0x7f000001)); 1005 1006 char addr6[] = "::1"; 1007 dfsan_set_label(j_label, addr6 + 3, 1); 1008 struct in6_addr in6; 1009 int ret6 = inet_pton(AF_INET6, addr6, &in6); 1010 assert(ret6 == 1); 1011 ASSERT_READ_LABEL(((char *) &in6) + sizeof(in6) - 1, 1, j_label); 1012 } 1013 1014 void test_localtime_r() { 1015 time_t t0 = 1384800998; 1016 struct tm t1; 1017 dfsan_set_label(i_label, &t0, sizeof(t0)); 1018 struct tm* ret = localtime_r(&t0, &t1); 1019 assert(ret == &t1); 1020 assert(t1.tm_min == 56); 1021 ASSERT_LABEL(t1.tm_mon, i_label); 1022 } 1023 1024 void test_getpwuid_r() { 1025 struct passwd pwd; 1026 char buf[1024]; 1027 struct passwd *result; 1028 1029 dfsan_set_label(i_label, &pwd, 4); 1030 int ret = getpwuid_r(0, &pwd, buf, sizeof(buf), &result); 1031 assert(ret == 0); 1032 assert(strcmp(pwd.pw_name, "root") == 0); 1033 assert(result == &pwd); 1034 ASSERT_READ_ZERO_LABEL(&pwd, 4); 1035 } 1036 1037 void test_epoll_wait() { 1038 // Set up a pipe to monitor with epoll. 1039 int pipe_fds[2]; 1040 int ret = pipe(pipe_fds); 1041 assert(ret != -1); 1042 1043 // Configure epoll to monitor the pipe. 1044 int epfd = epoll_create1(0); 1045 assert(epfd != -1); 1046 struct epoll_event event; 1047 event.events = EPOLLIN; 1048 event.data.fd = pipe_fds[0]; 1049 ret = epoll_ctl(epfd, EPOLL_CTL_ADD, pipe_fds[0], &event); 1050 assert(ret != -1); 1051 1052 // Test epoll_wait when no events have occurred. 1053 event = {}; 1054 dfsan_set_label(i_label, &event, sizeof(event)); 1055 ret = epoll_wait(epfd, &event, /*maxevents=*/1, /*timeout=*/0); 1056 assert(ret == 0); 1057 assert(event.events == 0); 1058 assert(event.data.fd == 0); 1059 ASSERT_ZERO_LABEL(ret); 1060 ASSERT_READ_LABEL(&event, sizeof(event), i_label); 1061 1062 // Test epoll_wait when an event occurs. 1063 write(pipe_fds[1], "x", 1); 1064 ret = epoll_wait(epfd, &event, /*maxevents=*/1, /*timeout=*/0); 1065 assert(ret == 1); 1066 assert(event.events == EPOLLIN); 1067 assert(event.data.fd == pipe_fds[0]); 1068 ASSERT_ZERO_LABEL(ret); 1069 ASSERT_READ_ZERO_LABEL(&event, sizeof(event)); 1070 1071 // Clean up. 1072 close(epfd); 1073 close(pipe_fds[0]); 1074 close(pipe_fds[1]); 1075 } 1076 1077 void test_poll() { 1078 struct pollfd fd; 1079 fd.fd = 0; 1080 fd.events = POLLIN; 1081 dfsan_set_label(i_label, &fd.revents, sizeof(fd.revents)); 1082 int ret = poll(&fd, 1, 1); 1083 ASSERT_ZERO_LABEL(fd.revents); 1084 assert(ret >= 0); 1085 } 1086 1087 void test_select() { 1088 struct timeval t; 1089 fd_set fds; 1090 t.tv_sec = 2; 1091 FD_SET(0, &fds); 1092 dfsan_set_label(i_label, &fds, sizeof(fds)); 1093 dfsan_set_label(j_label, &t, sizeof(t)); 1094 int ret = select(1, &fds, NULL, NULL, &t); 1095 assert(ret >= 0); 1096 ASSERT_ZERO_LABEL(t.tv_sec); 1097 ASSERT_READ_ZERO_LABEL(&fds, sizeof(fds)); 1098 } 1099 1100 void test_sched_getaffinity() { 1101 cpu_set_t mask; 1102 dfsan_set_label(j_label, &mask, 1); 1103 int ret = sched_getaffinity(0, sizeof(mask), &mask); 1104 assert(ret == 0); 1105 ASSERT_READ_ZERO_LABEL(&mask, sizeof(mask)); 1106 } 1107 #endif // !defined(ORIGIN_TRACKING) 1108 1109 void test_sigemptyset() { 1110 sigset_t set; 1111 dfsan_set_label(j_label, &set, 1); 1112 DEFINE_AND_SAVE_ORIGINS(set) 1113 int ret = sigemptyset(&set); 1114 assert(ret == 0); 1115 ASSERT_ZERO_LABEL(ret); 1116 ASSERT_READ_ZERO_LABEL(&set, sizeof(set)); 1117 ASSERT_SAVED_ORIGINS(set) 1118 } 1119 1120 static void SignalHandler(int signo) {} 1121 1122 static void SignalAction(int signo, siginfo_t *si, void *uc) {} 1123 1124 void test_sigaction() { 1125 struct sigaction newact_with_sigaction = {}; 1126 newact_with_sigaction.sa_flags = SA_SIGINFO; 1127 newact_with_sigaction.sa_sigaction = SignalAction; 1128 1129 // Set sigaction to be SignalAction, save the last one into origin_act 1130 struct sigaction origin_act; 1131 dfsan_set_label(j_label, &origin_act, 1); 1132 DEFINE_AND_SAVE_ORIGINS(origin_act) 1133 int ret = sigaction(SIGUSR1, &newact_with_sigaction, &origin_act); 1134 assert(ret == 0); 1135 ASSERT_ZERO_LABEL(ret); 1136 ASSERT_READ_ZERO_LABEL(&origin_act, sizeof(origin_act)); 1137 ASSERT_SAVED_ORIGINS(origin_act) 1138 1139 struct sigaction newact_with_sighandler = {}; 1140 newact_with_sighandler.sa_handler = SignalHandler; 1141 1142 // Set sigaction to be SignalHandler, check the last one is SignalAction 1143 struct sigaction oldact; 1144 assert(0 == sigaction(SIGUSR1, &newact_with_sighandler, &oldact)); 1145 assert(oldact.sa_sigaction == SignalAction); 1146 assert(oldact.sa_flags & SA_SIGINFO); 1147 1148 // Set SIG_IGN or SIG_DFL, and check the previous one is expected. 1149 newact_with_sighandler.sa_handler = SIG_IGN; 1150 assert(0 == sigaction(SIGUSR1, &newact_with_sighandler, &oldact)); 1151 assert(oldact.sa_handler == SignalHandler); 1152 assert((oldact.sa_flags & SA_SIGINFO) == 0); 1153 1154 newact_with_sighandler.sa_handler = SIG_DFL; 1155 assert(0 == sigaction(SIGUSR1, &newact_with_sighandler, &oldact)); 1156 assert(oldact.sa_handler == SIG_IGN); 1157 assert((oldact.sa_flags & SA_SIGINFO) == 0); 1158 1159 // Restore sigaction to the orginal setting, check the last one is SignalHandler 1160 assert(0 == sigaction(SIGUSR1, &origin_act, &oldact)); 1161 assert(oldact.sa_handler == SIG_DFL); 1162 assert((oldact.sa_flags & SA_SIGINFO) == 0); 1163 } 1164 1165 void test_signal() { 1166 // Set signal to be SignalHandler, save the previous one into 1167 // old_signal_handler. 1168 sighandler_t old_signal_handler = signal(SIGHUP, SignalHandler); 1169 ASSERT_ZERO_LABEL(old_signal_handler); 1170 1171 // Set SIG_IGN or SIG_DFL, and check the previous one is expected. 1172 assert(SignalHandler == signal(SIGHUP, SIG_DFL)); 1173 assert(SIG_DFL == signal(SIGHUP, SIG_IGN)); 1174 1175 // Restore signal to old_signal_handler. 1176 assert(SIG_IGN == signal(SIGHUP, old_signal_handler)); 1177 } 1178 1179 void test_sigaltstack() { 1180 stack_t old_altstack = {}; 1181 dfsan_set_label(j_label, &old_altstack, sizeof(old_altstack)); 1182 DEFINE_AND_SAVE_ORIGINS(old_altstack) 1183 int ret = sigaltstack(NULL, &old_altstack); 1184 assert(ret == 0); 1185 ASSERT_ZERO_LABEL(ret); 1186 ASSERT_READ_ZERO_LABEL(&old_altstack, sizeof(old_altstack)); 1187 ASSERT_SAVED_ORIGINS(old_altstack) 1188 } 1189 1190 #if !defined(ORIGIN_TRACKING) 1191 void test_gettimeofday() { 1192 struct timeval tv; 1193 struct timezone tz; 1194 dfsan_set_label(i_label, &tv, sizeof(tv)); 1195 dfsan_set_label(j_label, &tz, sizeof(tz)); 1196 int ret = gettimeofday(&tv, &tz); 1197 assert(ret == 0); 1198 ASSERT_READ_ZERO_LABEL(&tv, sizeof(tv)); 1199 ASSERT_READ_ZERO_LABEL(&tz, sizeof(tz)); 1200 } 1201 #endif // !defined(ORIGIN_TRACKING) 1202 1203 void *pthread_create_test_cb(void *p) { 1204 assert(p == (void *)1); 1205 ASSERT_ZERO_LABEL(p); 1206 return (void *)2; 1207 } 1208 1209 void test_pthread_create() { 1210 pthread_t pt; 1211 int create_ret = pthread_create(&pt, 0, pthread_create_test_cb, (void *)1); 1212 assert(create_ret == 0); 1213 ASSERT_ZERO_LABEL(create_ret); 1214 void *cbrv; 1215 dfsan_set_label(i_label, &cbrv, sizeof(cbrv)); 1216 DEFINE_AND_SAVE_ORIGINS(cbrv) 1217 int joint_ret = pthread_join(pt, &cbrv); 1218 assert(joint_ret == 0); 1219 assert(cbrv == (void *)2); 1220 ASSERT_ZERO_LABEL(joint_ret); 1221 ASSERT_ZERO_LABEL(cbrv); 1222 ASSERT_SAVED_ORIGINS(cbrv); 1223 } 1224 1225 // Tested by test_pthread_create(). This empty function is here to appease the 1226 // check-wrappers script. 1227 void test_pthread_join() {} 1228 1229 int dl_iterate_phdr_test_cb(struct dl_phdr_info *info, size_t size, 1230 void *data) { 1231 assert(data == (void *)3); 1232 ASSERT_ZERO_LABEL(info); 1233 ASSERT_ZERO_LABEL(size); 1234 ASSERT_ZERO_LABEL(data); 1235 return 0; 1236 } 1237 1238 void test_dl_iterate_phdr() { 1239 dl_iterate_phdr(dl_iterate_phdr_test_cb, (void *)3); 1240 } 1241 1242 // On glibc < 2.27, this symbol is not available. Mark it weak so we can skip 1243 // testing in this case. 1244 __attribute__((weak)) extern "C" void _dl_get_tls_static_info(size_t *sizep, 1245 size_t *alignp); 1246 1247 void test__dl_get_tls_static_info() { 1248 if (!_dl_get_tls_static_info) 1249 return; 1250 size_t sizep = 0, alignp = 0; 1251 dfsan_set_label(i_label, &sizep, sizeof(sizep)); 1252 dfsan_set_label(i_label, &alignp, sizeof(alignp)); 1253 dfsan_origin sizep_o = dfsan_get_origin(sizep); 1254 dfsan_origin alignp_o = dfsan_get_origin(alignp); 1255 _dl_get_tls_static_info(&sizep, &alignp); 1256 ASSERT_ZERO_LABEL(sizep); 1257 ASSERT_ZERO_LABEL(alignp); 1258 ASSERT_ORIGIN(sizep, sizep_o); 1259 ASSERT_ORIGIN(alignp, alignp_o); 1260 } 1261 1262 #if !defined(ORIGIN_TRACKING) 1263 void test_strrchr() { 1264 char str1[] = "str1str1"; 1265 dfsan_set_label(i_label, &str1[7], 1); 1266 1267 char *rv = strrchr(str1, 'r'); 1268 assert(rv == &str1[6]); 1269 #ifdef STRICT_DATA_DEPENDENCIES 1270 ASSERT_ZERO_LABEL(rv); 1271 #else 1272 ASSERT_LABEL(rv, i_label); 1273 #endif 1274 } 1275 1276 void test_strstr() { 1277 char str1[] = "str1str1"; 1278 dfsan_set_label(i_label, &str1[3], 1); 1279 dfsan_set_label(j_label, &str1[5], 1); 1280 1281 char *rv = strstr(str1, "1s"); 1282 assert(rv == &str1[3]); 1283 #ifdef STRICT_DATA_DEPENDENCIES 1284 ASSERT_ZERO_LABEL(rv); 1285 #else 1286 ASSERT_LABEL(rv, i_label); 1287 #endif 1288 1289 rv = strstr(str1, "2s"); 1290 assert(rv == NULL); 1291 #ifdef STRICT_DATA_DEPENDENCIES 1292 ASSERT_ZERO_LABEL(rv); 1293 #else 1294 ASSERT_LABEL(rv, i_j_label); 1295 #endif 1296 } 1297 #endif // !defined(ORIGIN_TRACKING) 1298 1299 void test_strpbrk() { 1300 char s[] = "abcdefg"; 1301 char accept[] = "123fd"; 1302 1303 char *p_s = s; 1304 char *p_accept = accept; 1305 1306 dfsan_set_label(n_label, &p_accept, sizeof(p_accept)); 1307 1308 char *rv = strpbrk(p_s, p_accept); 1309 assert(rv == &s[3]); 1310 #ifdef STRICT_DATA_DEPENDENCIES 1311 ASSERT_ZERO_LABEL(rv); 1312 #else 1313 ASSERT_LABEL(rv, n_label); 1314 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&rv, p_accept); 1315 #endif 1316 1317 dfsan_set_label(m_label, &p_s, sizeof(p_s)); 1318 1319 rv = strpbrk(p_s, p_accept); 1320 assert(rv == &s[3]); 1321 #ifdef STRICT_DATA_DEPENDENCIES 1322 ASSERT_LABEL(rv, m_label); 1323 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&rv, p_s); 1324 #else 1325 ASSERT_LABEL(rv, dfsan_union(m_label, n_label)); 1326 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&rv, p_s); 1327 #endif 1328 1329 dfsan_set_label(i_label, &s[5], 1); 1330 dfsan_set_label(j_label, &accept[1], 1); 1331 1332 rv = strpbrk(s, accept); 1333 assert(rv == &s[3]); 1334 #ifdef STRICT_DATA_DEPENDENCIES 1335 ASSERT_ZERO_LABEL(rv); 1336 #else 1337 ASSERT_LABEL(rv, j_label); 1338 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&rv, accept[1]); 1339 #endif 1340 1341 char *ps = s; 1342 dfsan_set_label(j_label, &ps, sizeof(ps)); 1343 1344 rv = strpbrk(ps, "123gf"); 1345 assert(rv == &s[5]); 1346 #ifdef STRICT_DATA_DEPENDENCIES 1347 ASSERT_LABEL(rv, j_label); 1348 #else 1349 ASSERT_LABEL(rv, i_j_label); 1350 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&rv, s[5]); 1351 #endif 1352 1353 rv = strpbrk(ps, "123"); 1354 assert(rv == NULL); 1355 #ifdef STRICT_DATA_DEPENDENCIES 1356 ASSERT_ZERO_LABEL(rv); 1357 #else 1358 ASSERT_LABEL(rv, i_j_label); 1359 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&rv, s[5]); 1360 #endif 1361 } 1362 1363 #if !defined(ORIGIN_TRACKING) 1364 void test_memchr() { 1365 char str1[] = "str1"; 1366 dfsan_set_label(i_label, &str1[3], 1); 1367 dfsan_set_label(j_label, &str1[4], 1); 1368 1369 char *crv = (char *) memchr(str1, 'r', sizeof(str1)); 1370 assert(crv == &str1[2]); 1371 ASSERT_ZERO_LABEL(crv); 1372 1373 crv = (char *) memchr(str1, '1', sizeof(str1)); 1374 assert(crv == &str1[3]); 1375 #ifdef STRICT_DATA_DEPENDENCIES 1376 ASSERT_ZERO_LABEL(crv); 1377 #else 1378 ASSERT_LABEL(crv, i_label); 1379 #endif 1380 1381 crv = (char *) memchr(str1, 'x', sizeof(str1)); 1382 assert(!crv); 1383 #ifdef STRICT_DATA_DEPENDENCIES 1384 ASSERT_ZERO_LABEL(crv); 1385 #else 1386 ASSERT_LABEL(crv, i_j_label); 1387 #endif 1388 } 1389 1390 void alarm_handler(int unused) { 1391 ; 1392 } 1393 1394 void test_nanosleep() { 1395 struct timespec req, rem; 1396 req.tv_sec = 1; 1397 req.tv_nsec = 0; 1398 dfsan_set_label(i_label, &rem, sizeof(rem)); 1399 1400 // non interrupted 1401 int rv = nanosleep(&req, &rem); 1402 assert(rv == 0); 1403 ASSERT_ZERO_LABEL(rv); 1404 ASSERT_READ_LABEL(&rem, 1, i_label); 1405 1406 // interrupted by an alarm 1407 signal(SIGALRM, alarm_handler); 1408 req.tv_sec = 3; 1409 alarm(1); 1410 rv = nanosleep(&req, &rem); 1411 assert(rv == -1); 1412 ASSERT_ZERO_LABEL(rv); 1413 ASSERT_READ_ZERO_LABEL(&rem, sizeof(rem)); 1414 } 1415 1416 void test_socketpair() { 1417 int fd[2]; 1418 1419 dfsan_set_label(i_label, fd, sizeof(fd)); 1420 int rv = socketpair(PF_LOCAL, SOCK_STREAM, 0, fd); 1421 assert(rv == 0); 1422 ASSERT_ZERO_LABEL(rv); 1423 ASSERT_READ_ZERO_LABEL(fd, sizeof(fd)); 1424 } 1425 1426 void test_getpeername() { 1427 int sockfds[2]; 1428 int ret = socketpair(AF_UNIX, SOCK_DGRAM, 0, sockfds); 1429 assert(ret != -1); 1430 1431 struct sockaddr addr = {}; 1432 socklen_t addrlen = sizeof(addr); 1433 dfsan_set_label(i_label, &addr, addrlen); 1434 dfsan_set_label(i_label, &addrlen, sizeof(addrlen)); 1435 1436 ret = getpeername(sockfds[0], &addr, &addrlen); 1437 assert(ret != -1); 1438 ASSERT_ZERO_LABEL(ret); 1439 ASSERT_ZERO_LABEL(addrlen); 1440 assert(addrlen < sizeof(addr)); 1441 ASSERT_READ_ZERO_LABEL(&addr, addrlen); 1442 ASSERT_READ_LABEL(((char *)&addr) + addrlen, 1, i_label); 1443 1444 close(sockfds[0]); 1445 close(sockfds[1]); 1446 } 1447 1448 void test_getsockname() { 1449 int sockfd = socket(AF_UNIX, SOCK_DGRAM, 0); 1450 assert(sockfd != -1); 1451 1452 struct sockaddr addr = {}; 1453 socklen_t addrlen = sizeof(addr); 1454 dfsan_set_label(i_label, &addr, addrlen); 1455 dfsan_set_label(i_label, &addrlen, sizeof(addrlen)); 1456 1457 int ret = getsockname(sockfd, &addr, &addrlen); 1458 assert(ret != -1); 1459 ASSERT_ZERO_LABEL(ret); 1460 ASSERT_ZERO_LABEL(addrlen); 1461 assert(addrlen < sizeof(addr)); 1462 ASSERT_READ_ZERO_LABEL(&addr, addrlen); 1463 ASSERT_READ_LABEL(((char *)&addr) + addrlen, 1, i_label); 1464 1465 close(sockfd); 1466 } 1467 1468 void test_getsockopt() { 1469 int sockfd = socket(AF_UNIX, SOCK_DGRAM, 0); 1470 assert(sockfd != -1); 1471 1472 int optval[2] = {-1, -1}; 1473 socklen_t optlen = sizeof(optval); 1474 dfsan_set_label(i_label, &optval, sizeof(optval)); 1475 dfsan_set_label(i_label, &optlen, sizeof(optlen)); 1476 int ret = getsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, &optval, &optlen); 1477 assert(ret != -1); 1478 assert(optlen == sizeof(int)); 1479 assert(optval[0] == 0); 1480 assert(optval[1] == -1); 1481 ASSERT_ZERO_LABEL(ret); 1482 ASSERT_ZERO_LABEL(optlen); 1483 ASSERT_ZERO_LABEL(optval[0]); 1484 ASSERT_LABEL(optval[1], i_label); 1485 1486 close(sockfd); 1487 } 1488 #endif // !defined(ORIGIN_TRACKING) 1489 1490 void test_write() { 1491 int fd = open("/dev/null", O_WRONLY); 1492 1493 char buf[] = "a string"; 1494 int len = strlen(buf); 1495 1496 // The result of a write always unlabeled. 1497 int res = write(fd, buf, len); 1498 assert(res > 0); 1499 ASSERT_ZERO_LABEL(res); 1500 1501 // Label all arguments to write(). 1502 dfsan_set_label(i_label, &(buf[3]), 1); 1503 dfsan_set_label(j_label, &fd, sizeof(fd)); 1504 dfsan_set_label(i_label, &len, sizeof(len)); 1505 1506 // The value returned by write() should have no label. 1507 res = write(fd, buf, len); 1508 ASSERT_ZERO_LABEL(res); 1509 1510 close(fd); 1511 } 1512 1513 #if !defined(ORIGIN_TRACKING) 1514 template <class T> 1515 void test_sprintf_chunk(const char* expected, const char* format, T arg) { 1516 char buf[512]; 1517 memset(buf, 'a', sizeof(buf)); 1518 1519 char padded_expected[512]; 1520 strcpy(padded_expected, "foo "); 1521 strcat(padded_expected, expected); 1522 strcat(padded_expected, " bar"); 1523 1524 char padded_format[512]; 1525 strcpy(padded_format, "foo "); 1526 strcat(padded_format, format); 1527 strcat(padded_format, " bar"); 1528 1529 // Non labelled arg. 1530 assert(sprintf(buf, padded_format, arg) == strlen(padded_expected)); 1531 assert(strcmp(buf, padded_expected) == 0); 1532 ASSERT_READ_LABEL(buf, strlen(padded_expected), 0); 1533 memset(buf, 'a', sizeof(buf)); 1534 1535 // Labelled arg. 1536 dfsan_set_label(i_label, &arg, sizeof(arg)); 1537 assert(sprintf(buf, padded_format, arg) == strlen(padded_expected)); 1538 assert(strcmp(buf, padded_expected) == 0); 1539 ASSERT_READ_LABEL(buf, 4, 0); 1540 ASSERT_READ_LABEL(buf + 4, strlen(padded_expected) - 8, i_label); 1541 ASSERT_READ_LABEL(buf + (strlen(padded_expected) - 4), 4, 0); 1542 } 1543 1544 void test_sprintf() { 1545 char buf[2048]; 1546 memset(buf, 'a', sizeof(buf)); 1547 1548 // Test formatting (no conversion specifier). 1549 assert(sprintf(buf, "Hello world!") == 12); 1550 assert(strcmp(buf, "Hello world!") == 0); 1551 ASSERT_READ_LABEL(buf, sizeof(buf), 0); 1552 1553 // Test for extra arguments. 1554 assert(sprintf(buf, "Hello world!", 42, "hello") == 12); 1555 assert(strcmp(buf, "Hello world!") == 0); 1556 ASSERT_READ_LABEL(buf, sizeof(buf), 0); 1557 1558 // Test formatting & label propagation (multiple conversion specifiers): %s, 1559 // %d, %n, %f, and %%. 1560 const char* s = "world"; 1561 int m = 8; 1562 int d = 27; 1563 dfsan_set_label(k_label, (void *) (s + 1), 2); 1564 dfsan_set_label(i_label, &m, sizeof(m)); 1565 dfsan_set_label(j_label, &d, sizeof(d)); 1566 int n; 1567 int r = sprintf(buf, "hello %s, %-d/%d/%d %f %% %n%d", s, 2014, m, d, 1568 12345.6781234, &n, 1000); 1569 assert(r == 42); 1570 assert(strcmp(buf, "hello world, 2014/8/27 12345.678123 % 1000") == 0); 1571 ASSERT_READ_LABEL(buf, 7, 0); 1572 ASSERT_READ_LABEL(buf + 7, 2, k_label); 1573 ASSERT_READ_LABEL(buf + 9, 9, 0); 1574 ASSERT_READ_LABEL(buf + 18, 1, i_label); 1575 ASSERT_READ_LABEL(buf + 19, 1, 0); 1576 ASSERT_READ_LABEL(buf + 20, 2, j_label); 1577 ASSERT_READ_LABEL(buf + 22, 15, 0); 1578 ASSERT_LABEL(r, 0); 1579 assert(n == 38); 1580 1581 // Test formatting & label propagation (single conversion specifier, with 1582 // additional length and precision modifiers). 1583 test_sprintf_chunk("-559038737", "%d", 0xdeadbeef); 1584 test_sprintf_chunk("3735928559", "%u", 0xdeadbeef); 1585 test_sprintf_chunk("12345", "%i", 12345); 1586 test_sprintf_chunk("751", "%o", 0751); 1587 test_sprintf_chunk("babe", "%x", 0xbabe); 1588 test_sprintf_chunk("0000BABE", "%.8X", 0xbabe); 1589 test_sprintf_chunk("-17", "%hhd", 0xdeadbeef); 1590 test_sprintf_chunk("-16657", "%hd", 0xdeadbeef); 1591 test_sprintf_chunk("deadbeefdeadbeef", "%lx", 0xdeadbeefdeadbeef); 1592 test_sprintf_chunk("0xdeadbeefdeadbeef", "%p", 1593 (void *) 0xdeadbeefdeadbeef); 1594 test_sprintf_chunk("18446744073709551615", "%ju", (intmax_t) -1); 1595 test_sprintf_chunk("18446744073709551615", "%zu", (size_t) -1); 1596 test_sprintf_chunk("18446744073709551615", "%tu", (size_t) -1); 1597 1598 test_sprintf_chunk("0x1.f9acffa7eb6bfp-4", "%a", 0.123456); 1599 test_sprintf_chunk("0X1.F9ACFFA7EB6BFP-4", "%A", 0.123456); 1600 test_sprintf_chunk("0.12346", "%.5f", 0.123456); 1601 test_sprintf_chunk("0.123456", "%g", 0.123456); 1602 test_sprintf_chunk("1.234560e-01", "%e", 0.123456); 1603 test_sprintf_chunk("1.234560E-01", "%E", 0.123456); 1604 test_sprintf_chunk("0.1234567891234560", "%.16Lf", 1605 (long double) 0.123456789123456); 1606 1607 test_sprintf_chunk("z", "%c", 'z'); 1608 1609 // %n, %s, %d, %f, and %% already tested 1610 1611 // Test formatting with width passed as an argument. 1612 r = sprintf(buf, "hi %*d my %*s friend %.*f", 3, 1, 6, "dear", 4, 3.14159265359); 1613 assert(r == 30); 1614 assert(strcmp(buf, "hi 1 my dear friend 3.1416") == 0); 1615 } 1616 1617 void test_snprintf() { 1618 char buf[2048]; 1619 memset(buf, 'a', sizeof(buf)); 1620 dfsan_set_label(0, buf, sizeof(buf)); 1621 const char* s = "world"; 1622 int y = 2014; 1623 int m = 8; 1624 int d = 27; 1625 dfsan_set_label(k_label, (void *) (s + 1), 2); 1626 dfsan_set_label(i_label, &y, sizeof(y)); 1627 dfsan_set_label(j_label, &m, sizeof(m)); 1628 int r = snprintf(buf, 19, "hello %s, %-d/%d/%d %f", s, y, m, d, 1629 12345.6781234); 1630 // The return value is the number of bytes that would have been written to 1631 // the final string if enough space had been available. 1632 assert(r == 35); 1633 assert(memcmp(buf, "hello world, 2014/", 19) == 0); 1634 ASSERT_READ_LABEL(buf, 7, 0); 1635 ASSERT_READ_LABEL(buf + 7, 2, k_label); 1636 ASSERT_READ_LABEL(buf + 9, 4, 0); 1637 ASSERT_READ_LABEL(buf + 13, 4, i_label); 1638 ASSERT_READ_LABEL(buf + 17, 2, 0); 1639 ASSERT_LABEL(r, 0); 1640 } 1641 #endif // !defined(ORIGIN_TRACKING) 1642 1643 // Tested by a seperate source file. This empty function is here to appease the 1644 // check-wrappers script. 1645 void test_fork() {} 1646 1647 int main(void) { 1648 #ifdef FAST_16_LABELS 1649 i_label = 1; 1650 j_label = 2; 1651 k_label = 4; 1652 m_label = 8; 1653 n_label = 16; 1654 #else 1655 i_label = dfsan_create_label("i", 0); 1656 j_label = dfsan_create_label("j", 0); 1657 k_label = dfsan_create_label("k", 0); 1658 m_label = dfsan_create_label("m", 0); 1659 n_label = dfsan_create_label("n", 0); 1660 #endif 1661 i_j_label = dfsan_union(i_label, j_label); 1662 assert(i_j_label != i_label); 1663 assert(i_j_label != j_label); 1664 assert(i_j_label != k_label); 1665 1666 test__dl_get_tls_static_info(); 1667 test_bcmp(); 1668 test_calloc(); 1669 test_clock_gettime(); 1670 #if !defined(ORIGIN_TRACKING) 1671 test_ctime_r(); 1672 #endif // !defined(ORIGIN_TRACKING) 1673 test_dfsan_set_write_callback(); 1674 test_dl_iterate_phdr(); 1675 test_dlopen(); 1676 #if !defined(ORIGIN_TRACKING) 1677 test_epoll_wait(); 1678 test_fgets(); 1679 #endif // !defined(ORIGIN_TRACKING) 1680 test_fork(); 1681 test_fstat(); 1682 #if !defined(ORIGIN_TRACKING) 1683 test_get_current_dir_name(); 1684 test_getcwd(); 1685 test_gethostname(); 1686 test_getpeername(); 1687 test_getpwuid_r(); 1688 test_getrlimit(); 1689 test_getrusage(); 1690 test_getsockname(); 1691 test_getsockopt(); 1692 test_gettimeofday(); 1693 test_inet_pton(); 1694 test_localtime_r(); 1695 test_memchr(); 1696 #endif // !defined(ORIGIN_TRACKING) 1697 test_memcmp(); 1698 test_memcpy(); 1699 test_memmove(); 1700 test_memset(); 1701 #if !defined(ORIGIN_TRACKING) 1702 test_nanosleep(); 1703 test_poll(); 1704 #endif // !defined(ORIGIN_TRACKING) 1705 test_pread(); 1706 test_pthread_create(); 1707 test_pthread_join(); 1708 test_read(); 1709 #if !defined(ORIGIN_TRACKING) 1710 test_recvmmsg(); 1711 test_recvmsg(); 1712 test_sched_getaffinity(); 1713 test_select(); 1714 #endif // !defined(ORIGIN_TRACKING) 1715 test_sigaction(); 1716 test_signal(); 1717 test_sigaltstack(); 1718 test_sigemptyset(); 1719 #if !defined(ORIGIN_TRACKING) 1720 test_snprintf(); 1721 test_socketpair(); 1722 test_sprintf(); 1723 #endif // !defined(ORIGIN_TRACKING) 1724 test_stat(); 1725 test_strcasecmp(); 1726 test_strchr(); 1727 test_strcmp(); 1728 test_strcat(); 1729 #if !defined(ORIGIN_TRACKING) 1730 test_strcpy(); 1731 #endif // !defined(ORIGIN_TRACKING) 1732 test_strdup(); 1733 test_strlen(); 1734 test_strncasecmp(); 1735 test_strncmp(); 1736 test_strncpy(); 1737 test_strpbrk(); 1738 #if !defined(ORIGIN_TRACKING) 1739 test_strrchr(); 1740 test_strstr(); 1741 test_strtod(); 1742 test_strtol(); 1743 test_strtoll(); 1744 test_strtoul(); 1745 test_strtoull(); 1746 test_time(); 1747 #endif // !defined(ORIGIN_TRACKING) 1748 test_write(); 1749 } 1750