ATF_TC_BODY(setlogin_err, tc) { char buf[MAXLOGNAME + 1]; char *name; pid_t pid; int sta; pid = fork(); ATF_REQUIRE(pid >= 0); (void)memset(buf, 'x', sizeof(buf)); if (pid == 0) { (void)setsid(); errno = 0; if (setlogin(buf) != -1) _exit(EINVAL); if (errno != EINVAL) _exit(EINVAL); errno = 0; if (setlogin((void *)-1) != -1) _exit(EFAULT); if (errno != EFAULT) _exit(EFAULT); name = getlogin(); if (name == NULL) _exit(EXIT_FAILURE); if (strcmp(name, "foobar") == 0) _exit(EXIT_FAILURE); _exit(EXIT_SUCCESS); } (void)wait(&sta); if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS) { if (WEXITSTATUS(sta) == EFAULT) atf_tc_fail("expected EFAULT, but the call succeeded"); if (WEXITSTATUS(sta) == EINVAL) atf_tc_fail("expected EINVAL, but the call succeeded"); atf_tc_fail("setlogin(2) failed, but login name was set"); } }
ATF_TC_BODY(ia_na_negative, tc) { uint32_t iaid; struct ia_xx *ia_na; struct ia_xx *ia_na_copy; /* set up dhcp globals */ dhcp_context_create(); /* tests */ /* bogus allocate arguments */ if (ia_allocate(NULL, 123, "", 0, MDL) != DHCP_R_INVALIDARG) { atf_tc_fail("ERROR: ia_allocate() %s:%d", MDL); } ia_na = (struct ia_xx *)1; if (ia_allocate(&ia_na, 456, "", 0, MDL) != DHCP_R_INVALIDARG) { atf_tc_fail("ERROR: ia_allocate() %s:%d", MDL); } /* bogus reference arguments */ iaid = 666; ia_na = NULL; if (ia_allocate(&ia_na, iaid, "TestDUID", 8, MDL) != ISC_R_SUCCESS) { atf_tc_fail("ERROR: ia_allocate() %s:%d", MDL); } if (ia_reference(NULL, ia_na, MDL) != DHCP_R_INVALIDARG) { atf_tc_fail("ERROR: ia_reference() %s:%d", MDL); } ia_na_copy = (struct ia_xx *)1; if (ia_reference(&ia_na_copy, ia_na, MDL) != DHCP_R_INVALIDARG) { atf_tc_fail("ERROR: ia_reference() %s:%d", MDL); } ia_na_copy = NULL; if (ia_reference(&ia_na_copy, NULL, MDL) != DHCP_R_INVALIDARG) { atf_tc_fail("ERROR: ia_reference() %s:%d", MDL); } if (ia_dereference(&ia_na, MDL) != ISC_R_SUCCESS) { atf_tc_fail("ERROR: ia_dereference() %s:%d", MDL); } /* bogus dereference arguments */ if (ia_dereference(NULL, MDL) != DHCP_R_INVALIDARG) { atf_tc_fail("ERROR: ia_dereference() %s:%d", MDL); } /* bogus remove */ iaid = 666; ia_na = NULL; if (ia_allocate(&ia_na, iaid, "TestDUID", 8, MDL) != ISC_R_SUCCESS) { atf_tc_fail("ERROR: ia_allocate() %s:%d", MDL); } ia_remove_iasubopt(ia_na, NULL, MDL); if (ia_dereference(&ia_na, MDL) != ISC_R_SUCCESS) { atf_tc_fail("ERROR: ia_dereference() %s:%d", MDL); } }
ATF_TC_BODY(setrlimit_memlock, tc) { struct rlimit res; void *buf; long page; pid_t pid; int sta; #ifdef __FreeBSD__ /* Set max_wired really really high to avoid EAGAIN */ set_vm_max_wired(INT_MAX); #endif page = sysconf(_SC_PAGESIZE); ATF_REQUIRE(page >= 0); buf = malloc(page); pid = fork(); if (buf == NULL || pid < 0) atf_tc_fail("initialization failed"); if (pid == 0) { /* * Try to lock a page while * RLIMIT_MEMLOCK is zero. */ if (mlock(buf, page) != 0) _exit(EXIT_FAILURE); if (munlock(buf, page) != 0) _exit(EXIT_FAILURE); res.rlim_cur = 0; res.rlim_max = 0; if (setrlimit(RLIMIT_MEMLOCK, &res) != 0) _exit(EXIT_FAILURE); if (mlock(buf, page) != 0) _exit(EXIT_SUCCESS); (void)munlock(buf, page); _exit(EXIT_FAILURE); } free(buf); (void)wait(&sta); if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS) atf_tc_fail("RLIMIT_MEMLOCK not enforced"); }
ATF_TC_BODY(connect_low_port, tc) { struct sockaddr_in sin, sinlist; int sd, val, slist; socklen_t slen; slist = socket(AF_INET, SOCK_STREAM, 0); sd = socket(AF_INET, SOCK_STREAM, 0); #ifdef __FreeBSD__ ATF_REQUIRE(sd > 0); ATF_REQUIRE(slist > 0); #endif /* bind listening socket */ memset(&sinlist, 0, sizeof(sinlist)); sinlist.sin_family = AF_INET; sinlist.sin_port = htons(31522); sinlist.sin_addr.s_addr = inet_addr("127.0.0.1"); ATF_REQUIRE_EQ(bind(slist, (struct sockaddr *)&sinlist, sizeof(sinlist)), 0); ATF_REQUIRE_EQ(listen(slist, 1), 0); val = IP_PORTRANGE_LOW; if (setsockopt(sd, IPPROTO_IP, IP_PORTRANGE, &val, sizeof(val)) == -1) atf_tc_fail("setsockopt failed: %s", strerror(errno)); memset(&sin, 0, sizeof(sin)); sin.sin_port = htons(31522); sin.sin_addr.s_addr = inet_addr("127.0.0.1"); sin.sin_family = AF_INET; if (connect(sd, (struct sockaddr *)&sin, sizeof(sin)) == -1) { int serrno = errno; atf_tc_fail("connect failed: %s%s", strerror(serrno), serrno != EACCES ? "" : " (see http://mail-index.netbsd.org/" "source-changes/2007/12/16/0011.html)"); } slen = sizeof(sin); ATF_REQUIRE_EQ(getsockname(sd, (struct sockaddr *)&sin, &slen), 0); ATF_REQUIRE_EQ(slen, sizeof(sin)); ATF_REQUIRE(ntohs(sin.sin_port) <= IPPORT_RESERVEDMAX); close(sd); #ifdef __FreeBSD__ close(slist); #endif }
ATF_TC_BODY(rcvbuf_oversized, tc) { int s, i, j; int sv[2]; const size_t sndbufsize = 8192; const size_t rcvbufsize = 131072; const size_t geom_mean_bufsize = 32768; const int pktsize = 1024; char sndbuf[pktsize]; char recv_buf[pktsize]; size_t datalen; ssize_t ssize, rsize; /* setup the socket pair */ do_socketpair_nonblocking(sv); /* * Send and receive packets that are collectively greater than the send * buffer, but less than the receive buffer */ for (i=0; i < geom_mean_bufsize / pktsize; i++) { /* Fill the buffer */ memset(sndbuf, i, pktsize); /* send the packet */ ssize = send(sv[0], sndbuf, pktsize, MSG_EOR); if (ssize < 0) { perror("send"); atf_tc_fail("send returned < 0"); } ATF_CHECK_EQ_MSG(pktsize, ssize, "expected %zd=send(...) but got %zd", pktsize, ssize); /* Receive it */ rsize = recv(sv[1], recv_buf, pktsize, MSG_WAITALL); if (rsize < 0) { perror("recv"); atf_tc_fail("recv returned < 0"); } ATF_CHECK_EQ_MSG(pktsize, rsize, "expected %zd=send(...) but got %zd", pktsize, rsize); /* Verify the contents */ ATF_CHECK_EQ_MSG(0, memcmp(sndbuf, recv_buf, pktsize), "Received data miscompare"); } /* Trying to receive again should return EAGAIN */ rsize = recv(sv[1], recv_buf, pktsize, MSG_WAITALL); ATF_CHECK_EQ(EAGAIN, errno); ATF_CHECK_EQ(-1, rsize); }
ATF_TC_BODY(setrlimit_basic, tc) { struct rlimit res; int *buf, lim; size_t i; buf = calloc(__arraycount(rlimit), sizeof(int)); if (buf == NULL) atf_tc_fail("initialization failed"); for (i = lim = 0; i < __arraycount(rlimit); i++) { (void)memset(&res, 0, sizeof(struct rlimit)); if (getrlimit(rlimit[i], &res) != 0) continue; if (res.rlim_cur == RLIM_INFINITY || res.rlim_cur == 0) continue; if (res.rlim_cur == res.rlim_max) /* An unprivileged run. */ continue; buf[i] = res.rlim_cur; res.rlim_cur = res.rlim_cur - 1; if (setrlimit(rlimit[i], &res) != 0) { lim = rlimit[i]; goto out; } } out: for (i = 0; i < __arraycount(rlimit); i++) { (void)memset(&res, 0, sizeof(struct rlimit)); if (buf[i] == 0) continue; if (getrlimit(rlimit[i], &res) != 0) continue; res.rlim_cur = buf[i]; (void)setrlimit(rlimit[i], &res); } if (lim != 0) atf_tc_fail("failed to set limit (%d)", lim); free(buf); }
ATF_TC_BODY(aio_fifo_test, tc) { int error, read_fd = -1, write_fd = -1; struct aio_fifo_arg arg; char pathname[PATH_MAX]; struct aio_context ac; ATF_REQUIRE_KERNEL_MODULE("aio"); ATF_REQUIRE_UNSAFE_AIO(); /* * In theory, mkstemp() can return a name that is then collided with. * Because this is a regression test, we treat that as a test failure * rather than retrying. */ strcpy(pathname, PATH_TEMPLATE); ATF_REQUIRE_MSG(mkstemp(pathname) != -1, "mkstemp failed: %s", strerror(errno)); ATF_REQUIRE_MSG(unlink(pathname) == 0, "unlink failed: %s", strerror(errno)); ATF_REQUIRE_MSG(mkfifo(pathname, 0600) != -1, "mkfifo failed: %s", strerror(errno)); arg.afa_pathname = pathname; arg.afa_read_fd = -1; arg.afa_write_fd = -1; read_fd = open(pathname, O_RDONLY | O_NONBLOCK); if (read_fd == -1) { error = errno; aio_fifo_cleanup(&arg); errno = error; atf_tc_fail("read_fd open failed: %s", strerror(errno)); } arg.afa_read_fd = read_fd; write_fd = open(pathname, O_WRONLY); if (write_fd == -1) { error = errno; aio_fifo_cleanup(&arg); errno = error; atf_tc_fail("write_fd open failed: %s", strerror(errno)); } arg.afa_write_fd = write_fd; aio_context_init(&ac, read_fd, write_fd, FIFO_LEN, FIFO_TIMEOUT, aio_fifo_cleanup, &arg); aio_write_test(&ac); aio_read_test(&ac); aio_fifo_cleanup(&arg); }
ATF_TC_BODY(msgctl_pid, tc) { struct msg msg = { MSG_MTYPE_1, { 'a', 'b', 'c' } }; struct msqid_ds msgds; int id, sta; pid_t pid; id = msgget(MSG_KEY, IPC_CREAT | 0600); ATF_REQUIRE(id != -1); pid = fork(); ATF_REQUIRE(pid >= 0); if (pid == 0) { (void)msgsnd(id, &msg, sizeof(struct msg), IPC_NOWAIT); _exit(EXIT_SUCCESS); } (void)sleep(1); (void)wait(&sta); (void)memset(&msgds, 0, sizeof(struct msqid_ds)); ATF_REQUIRE(msgctl(id, IPC_STAT, &msgds) == 0); if (pid != msgds.msg_lspid) atf_tc_fail("the PID of last msgsnd(2) was not updated"); pid = fork(); ATF_REQUIRE(pid >= 0); if (pid == 0) { (void)msgrcv(id, &msg, sizeof(struct msg), MSG_MTYPE_1, IPC_NOWAIT); _exit(EXIT_SUCCESS); } (void)sleep(1); (void)wait(&sta); (void)memset(&msgds, 0, sizeof(struct msqid_ds)); ATF_REQUIRE(msgctl(id, IPC_STAT, &msgds) == 0); if (pid != msgds.msg_lrpid) atf_tc_fail("the PID of last msgrcv(2) was not updated"); ATF_REQUIRE(msgctl(id, IPC_RMID, 0) == 0); }
static void h_check(int test) { struct sigaction sa; jmp_buf jb; sigjmp_buf sjb; sigset_t ss; int i, x; i = getpid(); if (test == TEST_SETJMP || test == TEST_SIGSETJMP_SAVE) expectsignal = 0; else if (test == TEST_U_SETJMP || test == TEST_SIGSETJMP_NOSAVE) expectsignal = 1; else atf_tc_fail("unknown test"); sa.sa_handler = aborthandler; sigemptyset(&sa.sa_mask); sa.sa_flags = 0; REQUIRE_ERRNO(sigaction(SIGABRT, &sa, NULL) != -1); REQUIRE_ERRNO(sigemptyset(&ss) != -1); REQUIRE_ERRNO(sigaddset(&ss, SIGABRT) != -1); REQUIRE_ERRNO(sigprocmask(SIG_BLOCK, &ss, NULL) != -1); if (test == TEST_SETJMP) x = setjmp(jb); else if (test == TEST_U_SETJMP) x = _setjmp(jb); else x = sigsetjmp(sjb, !expectsignal); if (x != 0) { ATF_REQUIRE_MSG(x == i, "setjmp returned wrong value"); kill(i, SIGABRT); ATF_REQUIRE_MSG(!expectsignal, "kill(SIGABRT) failed"); atf_tc_pass(); } REQUIRE_ERRNO(sigprocmask(SIG_UNBLOCK, &ss, NULL) != -1); if (test == TEST_SETJMP) longjmp(jb, i); else if (test == TEST_U_SETJMP) _longjmp(jb, i); else siglongjmp(sjb, i); atf_tc_fail("jmp failed"); }
ATF_TC_BODY(data_string_new, tc) { struct data_string new_string; const char *src = "Really? Latin? ... geeks"; int len_arg = 0; const char *error; /* Case 1: Call with an invalid data_string pointer, should fail */ if (data_string_new(NULL, src, len_arg, MDL)) { atf_tc_fail("case 1: call should have failed"); } /* Case 2: Passing in NULL src should fail */ if (data_string_new(&new_string, NULL, 10, MDL)) { atf_tc_fail("case 2: did not return success"); } /* Case 3: Call with valid params, length includes NULL */ len_arg = strlen(src) + 1; if (data_string_new(&new_string, src, len_arg, MDL) == 0) { atf_tc_fail("case 3: did not return success"); } error = checkString(&new_string, src); ATF_REQUIRE_MSG((error == NULL), "case 3: %s", error); data_string_forget(&new_string, MDL); /* Case 4: Call with valid params, length does not include NULL */ len_arg = 7; if (data_string_new(&new_string, src, len_arg, MDL) == 0) { atf_tc_fail("case 4: did not return success"); } error = checkString(&new_string, "Really?"); ATF_REQUIRE_MSG((error == NULL), "case 4: %s", error); data_string_forget(&new_string, MDL); /* Case 5: Call with valid params, source string is "" */ len_arg = 0; if (data_string_new(&new_string, "", len_arg, MDL) == 0) { atf_tc_fail("case 5: did not return success"); } error = checkString(&new_string, ""); ATF_REQUIRE_MSG((error == NULL), "case 4: %s", error); data_string_forget(&new_string, MDL); }
ATF_TC_BODY(resize_connected_buffers, tc) { int sv[2]; int sndbuf = 12345; int rcvbuf = 23456; int err; int ls, lr, rs, rr; socklen_t sl = sizeof(ls); /* setup the socket pair */ do_socketpair(sv); printf(" Socket Buffer Sizes\n"); printf(" | Left Socket | Right Socket |\n"); printf(" | SNDBUF | RCVBUF | SNDBUF | RCVBUF |\n"); ATF_CHECK_EQ(0, getsockopt(sv[0], SOL_SOCKET, SO_SNDBUF, &ls, &sl)); ATF_CHECK_EQ(0, getsockopt(sv[0], SOL_SOCKET, SO_RCVBUF, &lr, &sl)); ATF_CHECK_EQ(0, getsockopt(sv[1], SOL_SOCKET, SO_SNDBUF, &rs, &sl)); ATF_CHECK_EQ(0, getsockopt(sv[1], SOL_SOCKET, SO_RCVBUF, &rr, &sl)); printf("Default | %7d | %7d | %7d | %7d |\n", ls, lr, rs, rr); /* Update one side's send buffer */ err = setsockopt(sv[0], SOL_SOCKET, SO_SNDBUF, &sndbuf, sizeof(sndbuf)); if (err != 0){ perror("setsockopt"); atf_tc_fail("setsockopt(SO_SNDBUF) failed"); } ATF_CHECK_EQ(0, getsockopt(sv[0], SOL_SOCKET, SO_SNDBUF, &ls, &sl)); ATF_CHECK_EQ(0, getsockopt(sv[0], SOL_SOCKET, SO_RCVBUF, &lr, &sl)); ATF_CHECK_EQ(0, getsockopt(sv[1], SOL_SOCKET, SO_SNDBUF, &rs, &sl)); ATF_CHECK_EQ(0, getsockopt(sv[1], SOL_SOCKET, SO_RCVBUF, &rr, &sl)); printf("After changing Left's SNDBUF | %7d | %7d | %7d | %7d |\n", ls, lr, rs, rr); /* Update the same side's receive buffer */ err = setsockopt(sv[0], SOL_SOCKET, SO_RCVBUF, &rcvbuf, sizeof(rcvbuf)); if (err != 0){ perror("setsockopt"); atf_tc_fail("setsockopt(SO_RCVBUF) failed"); } ATF_CHECK_EQ(0, getsockopt(sv[0], SOL_SOCKET, SO_SNDBUF, &ls, &sl)); ATF_CHECK_EQ(0, getsockopt(sv[0], SOL_SOCKET, SO_RCVBUF, &lr, &sl)); ATF_CHECK_EQ(0, getsockopt(sv[1], SOL_SOCKET, SO_SNDBUF, &rs, &sl)); ATF_CHECK_EQ(0, getsockopt(sv[1], SOL_SOCKET, SO_RCVBUF, &rr, &sl)); printf("After changing Left's RCVBUF | %7d | %7d | %7d | %7d |\n", ls, lr, rs, rr); }
static void check_prepend(atf_error_t (*prepend)(atf_dynstr_t *, const char *, ...)) { const size_t maxlen = 8192; char buf[maxlen + 1]; size_t i; atf_dynstr_t str; printf("Prepending with plain string\n"); buf[0] = '\0'; RE(atf_dynstr_init(&str)); for (i = 0; i < maxlen; i++) { if (strcmp(atf_dynstr_cstring(&str), buf) != 0) { fprintf(stderr, "Failed at iteration %zd\n", i); atf_tc_fail("Failed to prepend character at iteration %zd", i); } memmove(buf + 1, buf, i + 1); if (i % 2 == 0) { RE(prepend(&str, "%s", "a")); buf[0] = 'a'; } else { RE(prepend(&str, "%s", "b")); buf[0] = 'b'; } } atf_dynstr_fini(&str); printf("Prepending with formatted string\n"); buf[0] = '\0'; RE(atf_dynstr_init(&str)); for (i = 0; i < maxlen; i++) { if (strcmp(atf_dynstr_cstring(&str), buf) != 0) { fprintf(stderr, "Failed at iteration %zd\n", i); atf_tc_fail("Failed to prepend character at iteration %zd", i); } memmove(buf + 1, buf, i + 1); if (i % 2 == 0) { RE(prepend(&str, "%s", "a")); buf[0] = 'a'; } else { RE(prepend(&str, "%s", "b")); buf[0] = 'b'; } } atf_dynstr_fini(&str); }
ATF_TC_BODY(ia_na_basic, tc) { uint32_t iaid; struct ia_xx *ia_na; struct ia_xx *ia_na_copy; struct iasubopt *iaaddr; /* set up dhcp globals */ dhcp_context_create(); /* and other common arguments */ iaid = 666; ia_na = NULL; ia_na_copy = NULL; iaaddr = NULL; /* tests */ if (ia_allocate(&ia_na, iaid, "TestDUID", 8, MDL) != ISC_R_SUCCESS) { atf_tc_fail("ERROR: ia_allocate() %s:%d", MDL); } if (memcmp(ia_na->iaid_duid.data, &iaid, sizeof(iaid)) != 0) { atf_tc_fail("ERROR: bad IAID_DUID %s:%d", MDL); } if (memcmp(ia_na->iaid_duid.data+sizeof(iaid), "TestDUID", 8) != 0) { atf_tc_fail("ERROR: bad IAID_DUID %s:%d", MDL); } if (ia_na->num_iasubopt != 0) { atf_tc_fail("ERROR: bad num_iasubopt %s:%d", MDL); } if (ia_reference(&ia_na_copy, ia_na, MDL) != ISC_R_SUCCESS) { atf_tc_fail("ERROR: ia_reference() %s:%d", MDL); } if (iasubopt_allocate(&iaaddr, MDL) != ISC_R_SUCCESS) { atf_tc_fail("ERROR: iasubopt_allocate() %s:%d", MDL); } if (ia_add_iasubopt(ia_na, iaaddr, MDL) != ISC_R_SUCCESS) { atf_tc_fail("ERROR: ia_add_iasubopt() %s:%d", MDL); } ia_remove_iasubopt(ia_na, iaaddr, MDL); if (iasubopt_dereference(&iaaddr, MDL) != ISC_R_SUCCESS) { atf_tc_fail("ERROR: iasubopt_reference() %s:%d", MDL); } if (ia_dereference(&ia_na, MDL) != ISC_R_SUCCESS) { atf_tc_fail("ERROR: ia_dereference() %s:%d", MDL); } if (ia_dereference(&ia_na_copy, MDL) != ISC_R_SUCCESS) { atf_tc_fail("ERROR: ia_dereference() %s:%d", MDL); } }
ATF_TC_BODY(link_count, tc) { struct stat sa, sb; int fd; (void)memset(&sa, 0, sizeof(struct stat)); (void)memset(&sb, 0, sizeof(struct stat)); pathl = getpath(); fd = open(path, O_RDWR | O_CREAT, 0600); ATF_REQUIRE(fd >= 0); ATF_REQUIRE(pathl != NULL); ATF_REQUIRE(stat(path, &sa) == 0); ATF_REQUIRE(link(path, pathl) == 0); ATF_REQUIRE(stat(path, &sb) == 0); if (sa.st_nlink != sb.st_nlink - 1) atf_tc_fail("incorrect link(2) count"); ATF_REQUIRE(close(fd) == 0); ATF_REQUIRE(unlink(path) == 0); ATF_REQUIRE(unlink(pathl) == 0); }
static void getnsec3parameters(isc_assertioncallback_t callback) { isc_result_t result; dns_hash_t hash; isc_uint8_t flags; isc_uint16_t iterations; unsigned char salt[DNS_NSEC3_SALTSIZE]; size_t salt_length = sizeof(salt); result = dns_test_begin(NULL, ISC_FALSE); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); setup_db(); isc_assertion_setcallback(callback); result = dns_db_getnsec3parameters(db1, VERSION(callback), &hash, &flags, &iterations, salt, &salt_length); if (callback != NULL) atf_tc_fail("dns_db_dump did not assert"); ATF_REQUIRE_EQ(result, ISC_R_NOTFOUND); close_db(); dns_test_end(); }
static void dump(isc_assertioncallback_t callback) { isc_result_t result; FILE *f = NULL; result = dns_test_begin(NULL, ISC_FALSE); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); setup_db(); result = isc_file_openunique(tempname, &f); fclose(f); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); isc_assertion_setcallback(callback); result = dns_db_dump(db1, VERSION(callback), tempname); (void)unlink(tempname); if (callback != NULL) atf_tc_fail("dns_db_dump did not assert"); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); close_db(); dns_test_end(); }
static void deleterdataset(isc_assertioncallback_t callback) { isc_result_t result; dns_rdataset_t rdataset; dns_fixedname_t fixed; dns_dbnode_t *node = NULL; result = dns_test_begin(NULL, ISC_FALSE); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); setup_db(); dns_rdataset_init(&rdataset); dns_fixedname_init(&fixed); result = dns_db_findnode(db1, dns_rootname, ISC_FALSE, &node); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); isc_assertion_setcallback(callback); result = dns_db_deleterdataset(db1, node, VERSION(callback), dns_rdatatype_soa, 0); if (callback != NULL) atf_tc_fail("dns_db_deleterdataset did not assert"); ATF_REQUIRE_EQ(result, DNS_R_UNCHANGED); dns_db_detachnode(db1, &node); ATF_REQUIRE_EQ(node, NULL); close_db(); dns_test_end(); }
static void allrdatasets(isc_assertioncallback_t callback) { isc_result_t result; dns_dbnode_t *node = NULL; dns_rdatasetiter_t *iterator = NULL; result = dns_test_begin(NULL, ISC_FALSE); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); setup_db(); result = dns_db_findnode(db1, dns_rootname, ISC_FALSE, &node); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); isc_assertion_setcallback(callback); result = dns_db_allrdatasets(db1, node, VERSION(callback), 0, &iterator); if (callback != NULL) atf_tc_fail("dns_db_allrdatasets did not assert"); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); dns_rdatasetiter_destroy(&iterator); ATF_REQUIRE_EQ(iterator, NULL); dns_db_detachnode(db1, &node); ATF_REQUIRE_EQ(node, NULL); close_db(); dns_test_end(); }
static void* test_pipe_reader(void* args) { test_pipe_thread_data_t* td = args; char rcvbuf[td->pktsize]; char comparebuf[td->pktsize]; ssize_t rsize; int i, d; for(i=0; i < td->numpkts; i++) { memset(comparebuf, i, td->pktsize); rsize = recv(td->so, rcvbuf, td->pktsize, MSG_WAITALL); if (rsize < 0) { perror("recv"); atf_tc_fail("recv returned < 0"); } ATF_CHECK_EQ_MSG(td->pktsize, rsize, "expected %zd=send(...) but got %zd", td->pktsize, rsize); d = memcmp(comparebuf, rcvbuf, td->pktsize); ATF_CHECK_EQ_MSG(0, d, "Received data miscompare on packet %d", i); } return (0); }
ATF_TC_BODY(stat_mtime, tc) { struct stat sa, sb; int fd[3]; size_t i; for (i = 0; i < __arraycount(fd); i++) { (void)memset(&sa, 0, sizeof(struct stat)); (void)memset(&sb, 0, sizeof(struct stat)); fd[i] = open(path, O_WRONLY | O_CREAT); ATF_REQUIRE(fd[i] != -1); ATF_REQUIRE(write(fd[i], "X", 1) == 1); ATF_REQUIRE(stat(path, &sa) == 0); (void)sleep(1); ATF_REQUIRE(write(fd[i], "X", 1) == 1); ATF_REQUIRE(stat(path, &sb) == 0); ATF_REQUIRE(close(fd[i]) == 0); ATF_REQUIRE(unlink(path) == 0); if (sa.st_mtime == sb.st_mtime) atf_tc_fail("mtimes did not change"); } }
static void rename_dotdot(const atf_tc_t *tc, const char *mp) { if (FSTYPE_RUMPFS(tc)) atf_tc_skip("rename not supported by file system"); USES_DIRS; if (rump_sys_chdir(mp) == -1) atf_tc_fail_errno("chdir mountpoint"); if (rump_sys_mkdir("dir1", 0777) == -1) atf_tc_fail_errno("mkdir 1"); if (rump_sys_mkdir("dir2", 0777) == -1) atf_tc_fail_errno("mkdir 2"); if (rump_sys_rename("dir1", "dir1/..") != -1 || errno != EINVAL) atf_tc_fail_errno("self-dotdot to"); if (rump_sys_rename("dir1/..", "sometarget") != -1 || errno != EINVAL) atf_tc_fail_errno("self-dotdot from"); if (rump_sys_rename("dir1", "dir2/..") != -1 || errno != EINVAL) atf_tc_fail("other-dotdot"); rump_sys_chdir("/"); }
ATF_TC_BODY(send_recv_nonblocking, tc) { int s; int sv[2]; const int bufsize = 64; const char *data = "data"; char recv_buf[bufsize]; size_t datalen; ssize_t ssize, rsize; /* setup the socket pair */ do_socketpair_nonblocking(sv); /* Verify that there is nothing to receive */ rsize = recv(sv[1], recv_buf, bufsize, MSG_WAITALL); ATF_CHECK_EQ(EAGAIN, errno); ATF_CHECK_EQ(-1, rsize); /* send and receive a small packet */ datalen = strlen(data) + 1; /* +1 for the null */ ssize = send(sv[0], data, datalen, MSG_EOR); if (ssize < 0) { perror("send"); atf_tc_fail("send returned < 0"); } ATF_CHECK_EQ_MSG(datalen, ssize, "expected %zd=send(...) but got %zd", datalen, ssize); rsize = recv(sv[1], recv_buf, bufsize, MSG_WAITALL); ATF_CHECK_EQ(datalen, rsize); }
ATF_TC_BODY(setitimer_basic, tc) { struct itimerval it; it.it_value.tv_sec = 0; it.it_value.tv_usec = 100; it.it_interval.tv_sec = 0; it.it_interval.tv_usec = 0; fail = true; ATF_REQUIRE(signal(SIGALRM, sighandler) != SIG_ERR); ATF_REQUIRE(setitimer(ITIMER_REAL, &it, NULL) == 0); /* * Although the interaction between * setitimer(2) and sleep(3) can be * unspecified, it is assumed that one * second suspension will be enough for * the timer to fire. */ (void)sleep(1); if (fail != false) atf_tc_fail("timer did not fire"); }
key_t get_ftok(int id) { int fd; char token_key[64], token_dir[64]; char *tmpdir; key_t key; strlcpy(token_key, "/tmp/t_sysv.XXXXXX", sizeof(token_key)); tmpdir = mkdtemp(token_key); ATF_REQUIRE_MSG(tmpdir != NULL, "mkdtemp() failed: %d", errno); strlcpy(token_dir, tmpdir, sizeof(token_dir)); strlcpy(token_key, tmpdir, sizeof(token_key)); strlcat(token_key, "/token_key", sizeof(token_key)); /* Create the file, since ftok() requires it to exist! */ fd = open(token_key, O_RDWR | O_CREAT | O_EXCL); if (fd == -1) { rmdir(tmpdir); atf_tc_fail("open() of temp file failed: %d", errno); return (key_t)-1; } else close(fd); key = ftok(token_key, id); ATF_REQUIRE_MSG(unlink(token_key) != -1, "unlink() failed: %d", errno); ATF_REQUIRE_MSG(rmdir(token_dir) != -1, "rmdir() failed: %d", errno); return key; }
ATF_TC_BODY(connect, tc) { struct sockaddr_un sun; /* ATF's isolation mechanisms will guarantee uniqueness of this file */ const char *path = "sock"; int s, r, err, l, s2; s = socket(PF_LOCAL, SOCK_SEQPACKET, 0); ATF_REQUIRE(s >= 0); bzero(&sun, sizeof(sun)); sun.sun_family = AF_LOCAL; sun.sun_len = sizeof(sun); strlcpy(sun.sun_path, path, sizeof(sun.sun_path)); r = bind(s, (struct sockaddr *)&sun, sizeof(sun)); l = listen(s, -1); ATF_CHECK_EQ(0, r); ATF_CHECK_EQ(0, l); /* Create the other socket */ s2 = socket(PF_LOCAL, SOCK_SEQPACKET, 0); ATF_REQUIRE(s2 >= 0); err = connect(s2, (struct sockaddr*)&sun, sizeof(sun)); if (err != 0) { perror("connect"); atf_tc_fail("connect(2) failed"); } }
static void safe_remove(const char* path) { if (unlink(path) == -1) atf_tc_fail("unlink(2) of %s failed", path); }
static void find(isc_assertioncallback_t callback) { isc_result_t result; dns_rdataset_t rdataset; dns_fixedname_t fixed; result = dns_test_begin(NULL, ISC_FALSE); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); setup_db(); dns_rdataset_init(&rdataset); dns_fixedname_init(&fixed); isc_assertion_setcallback(callback); result = dns_db_find(db1, dns_rootname, VERSION(callback), dns_rdatatype_soa, 0, 0, NULL, dns_fixedname_name(&fixed), &rdataset, NULL); if (callback != NULL) atf_tc_fail("dns_db_find did not assert"); ATF_REQUIRE_EQ(result, DNS_R_NXDOMAIN); close_db(); dns_test_end(); }
ATF_TC_BODY(getitimer_empty, tc) { struct itimerval it; /* * Verify that the passed structure remains * empty after calling getitimer(2) but before * actually arming the timer with setitimer(2). */ (void)memset(&it, 0, sizeof(struct itimerval)); ATF_REQUIRE(getitimer(ITIMER_REAL, &it) == 0); if (it.it_value.tv_sec != 0 || it.it_value.tv_usec != 0) goto fail; ATF_REQUIRE(getitimer(ITIMER_VIRTUAL, &it) == 0); if (it.it_value.tv_sec != 0 || it.it_value.tv_usec != 0) goto fail; ATF_REQUIRE(getitimer(ITIMER_PROF, &it) == 0); if (it.it_value.tv_sec != 0 || it.it_value.tv_usec != 0) goto fail; return; fail: atf_tc_fail("getitimer(2) modfied the timer before it was armed"); }
ATF_TC_BODY(strtol_range, tc) { #if LONG_MAX == 0x7fffffff /* XXX: Is this portable? */ struct test t[] = { { "20000000000", 2147483647, 8, NULL }, { "2147483648", 2147483647, 10, NULL }, { "80000000", 2147483647, 16, NULL }, }; #else struct test t[] = { { "1000000000000000000000", 9223372036854775807, 8, NULL }, { "9223372036854775808", 9223372036854775807, 10, NULL }, { "8000000000000000", 9223372036854775807, 16, NULL }, }; #endif long int li; char *end; size_t i; for (i = 0; i < __arraycount(t); i++) { errno = 0; li = strtol(t[i].str, &end, t[i].base); if (errno != ERANGE) atf_tc_fail("strtol(3) did not catch ERANGE"); check(&t[i], li, -1, end); } }
ATF_TC_BODY(send_recv_with_connect, tc) { const char* path; int sv[2]; const int bufsize = 64; const char *data = "data"; char recv_buf[bufsize]; size_t datalen; ssize_t ssize, rsize; mk_pair_of_sockets(sv); /* send and receive a small packet */ datalen = strlen(data) + 1; /* +1 for the null */ ssize = send(sv[0], data, datalen, MSG_EOR); if (ssize < 0) { perror("send"); atf_tc_fail("send returned < 0"); } ATF_CHECK_EQ_MSG(datalen, ssize, "expected %zd=send(...) but got %zd", datalen, ssize); rsize = recv(sv[1], recv_buf, bufsize, MSG_WAITALL); ATF_CHECK_EQ(datalen, rsize); }