int main(void) { struct __user_cap_header_struct* hdr; struct __user_cap_data_struct* data; ALLOCATE_GUARD(hdr, 'a'); hdr->version = 0; hdr->pid = 0; test_assert(0 == capget(hdr, NULL)); test_assert(hdr->version > 0); VERIFY_GUARD(hdr); ALLOCATE_GUARD(hdr, 'a'); hdr->version = _LINUX_CAPABILITY_VERSION_1; hdr->pid = 0; ALLOCATE_GUARD(data, 'b'); test_assert(0 == capget(hdr, data)); VERIFY_GUARD(hdr); VERIFY_GUARD(data); ALLOCATE_GUARD(hdr, 'c'); hdr->version = _LINUX_CAPABILITY_VERSION_3; hdr->pid = 0; data = allocate_guard(sizeof(*data) * 2, 'd'); test_assert(0 == capget(hdr, data)); VERIFY_GUARD(hdr); verify_guard(sizeof(*data) * 2, data); atomic_puts("EXIT-SUCCESS"); return 0; }
static void test(int use_preadv) { char name[] = "/tmp/rr-readv-XXXXXX"; int fd = mkstemp(name); struct { char ch[7]; }* part1; struct { char ch[10]; }* part2; struct iovec iovs[2]; test_assert(fd >= 0); test_assert(0 == unlink(name)); test_assert(sizeof(data) == write(fd, data, sizeof(data))); ALLOCATE_GUARD(part1, 'x'); ALLOCATE_GUARD(part2, 'y'); iovs[0].iov_base = part1; iovs[0].iov_len = sizeof(*part1); iovs[1].iov_base = part2; iovs[1].iov_len = sizeof(*part2); if (use_preadv) { test_assert(sizeof(data) == preadv(fd, iovs, 2, 0)); } else { test_assert(0 == lseek(fd, 0, SEEK_SET)); test_assert(sizeof(data) == readv(fd, iovs, 2)); } test_assert(0 == memcmp(part1, data, sizeof(*part1))); test_assert( 0 == memcmp(part2, data + sizeof(*part1), sizeof(data) - sizeof(*part1))); test_assert(part2->ch[sizeof(data) - sizeof(*part1)] == 'y'); VERIFY_GUARD(part1); VERIFY_GUARD(part2); }
int main(int argc, char* argv[]) { struct rlimit* r; struct rlimit* r2; ALLOCATE_GUARD(r, 0); ALLOCATE_GUARD(r2, 'x'); test_assert(0 == getrlimit(RLIMIT_FSIZE, r)); test_assert(r->rlim_cur > 0); test_assert(r->rlim_max > 0); VERIFY_GUARD(r); r->rlim_cur /= 2; test_assert(0 == setrlimit(RLIMIT_FSIZE, r)); VERIFY_GUARD(r); test_assert(0 == getrlimit(RLIMIT_FSIZE, r2)); test_assert(r2->rlim_cur == r->rlim_cur); VERIFY_GUARD(r2); test_assert(0 == prlimit(0, RLIMIT_FSIZE, r, r2)); test_assert(r2->rlim_cur == r->rlim_cur); VERIFY_GUARD(r); VERIFY_GUARD(r2); atomic_puts("EXIT-SUCCESS"); return 0; }
int main(void) { struct itimerval* v1; struct itimerval* v2; struct itimerval* v3; ALLOCATE_GUARD(v1, 0); v1->it_interval.tv_sec = 10000; v1->it_interval.tv_usec = 0; v1->it_value.tv_sec = 10000; v1->it_value.tv_usec = 0; test_assert(0 == setitimer(ITIMER_REAL, v1, NULL)); VERIFY_GUARD(v1); ALLOCATE_GUARD(v2, 1); test_assert(0 == setitimer(ITIMER_REAL, v1, v2)); test_assert(v2->it_interval.tv_sec == v1->it_interval.tv_sec); VERIFY_GUARD(v2); ALLOCATE_GUARD(v3, 2); test_assert(0 == getitimer(ITIMER_REAL, v3)); test_assert(v3->it_interval.tv_sec == v1->it_interval.tv_sec); VERIFY_GUARD(v3); atomic_puts("EXIT-SUCCESS"); return 0; }
int main(int argc, char* argv[]) { struct timeval* tv; struct timezone* tz; ALLOCATE_GUARD(tv, 0); ALLOCATE_GUARD(tz, 'x'); test_assert(0 == gettimeofday(tv, tz)); test_assert(tv->tv_sec > 0); test_assert(tz->tz_dsttime == 0); /* always zero on Linux */ VERIFY_GUARD(tv); VERIFY_GUARD(tz); atomic_puts("EXIT-SUCCESS"); return 0; }
static void test(int use_pwritev) { char name[] = "/tmp/rr-readv-XXXXXX"; int fd = mkstemp(name); struct { char ch[50]; } * buf; struct iovec iovs[2]; ssize_t nwritten; test_assert(fd >= 0); test_assert(0 == unlink(name)); iovs[0].iov_base = data; iovs[0].iov_len = 7; iovs[1].iov_base = data + iovs[0].iov_len; iovs[1].iov_len = sizeof(data) - iovs[0].iov_len; if (use_pwritev) { /* Work around busted pwritev prototype in older libcs */ nwritten = syscall(SYS_pwritev, fd, iovs, 2, 0, 0); } else { nwritten = writev(fd, iovs, 2); } test_assert(sizeof(data) == nwritten); ALLOCATE_GUARD(buf, 'x'); test_assert(sizeof(data) == pread(fd, buf, sizeof(*buf), 0)); test_assert(0 == memcmp(buf, data, sizeof(data))); test_assert(buf->ch[sizeof(data)] == 'x'); VERIFY_GUARD(buf); }
int main(void) { struct inotify_event* event; int desc; int file_fd; int fd = inotify_init(); test_assert(fd >= 0); test_assert(0 == close(fd)); fd = inotify_init1(IN_CLOEXEC); test_assert(fd >= 0); file_fd = open("foo", O_WRONLY | O_CREAT, 0777); test_assert(file_fd >= 0); test_assert(0 == close(file_fd)); desc = inotify_add_watch(fd, "foo", IN_ALL_EVENTS); test_assert(desc >= 0); test_assert(0 <= open("foo", O_WRONLY | O_CREAT, 0777)); ALLOCATE_GUARD(event, 'x'); test_assert(sizeof(*event) == read(fd, event, sizeof(*event))); VERIFY_GUARD(event); test_assert(event->wd == desc); test_assert(event->mask == IN_OPEN); test_assert(0 == inotify_rm_watch(fd, desc)); test_assert(0 == unlink("foo")); atomic_puts("EXIT-SUCCESS"); return 0; }
int main(void) { struct sched_attr* attr; ALLOCATE_GUARD(attr, 'x'); test_assert(0 == sched_getattr(0, attr, sizeof(*attr), 0)); /* Don't check specific scheduling parameters in case someone is running the rr tests with low priority or something like that */ test_assert(attr->size == sizeof(*attr)); test_assert(attr->flags == 0); VERIFY_GUARD(attr); test_assert(0 == sched_setattr(0, attr, 0)); VERIFY_GUARD(attr); atomic_puts("EXIT-SUCCESS"); return 0; }
int main(void) { struct rusage* r; ALLOCATE_GUARD(r, 0); test_assert(0 == getrusage(RUSAGE_SELF, r)); test_assert(r->ru_maxrss > 0); VERIFY_GUARD(r); atomic_puts("EXIT-SUCCESS"); return 0; }
int main(void) { struct sysinfo* info; ALLOCATE_GUARD(info, 0); test_assert(0 == sysinfo(info)); test_assert(info->mem_unit > 0); test_assert(info->procs > 0); VERIFY_GUARD(info); atomic_puts("EXIT-SUCCESS"); return 0; }
int main(int argc, char* argv[]) { stack_t* ss; stack_t* oss; ALLOCATE_GUARD(ss, 'x'); ss->ss_sp = buf; ss->ss_flags = 0; ss->ss_size = sizeof(buf); test_assert(0 == sigaltstack(ss, NULL)); VERIFY_GUARD(ss); ALLOCATE_GUARD(oss, 'y'); test_assert(0 == sigaltstack(ss, oss)); test_assert(oss->ss_sp == buf); test_assert(oss->ss_flags == 0); test_assert(oss->ss_size == sizeof(buf)); VERIFY_GUARD(ss); VERIFY_GUARD(oss); atomic_puts("EXIT-SUCCESS"); return 0; }
static void test(int use_preadv) { char name[] = "/tmp/rr-readv-XXXXXX"; int fd = mkstemp(name); struct { char ch[7]; } * part1; struct { char ch[10]; } * part2; struct iovec iovs[2]; ssize_t nread; test_assert(fd >= 0); test_assert(0 == unlink(name)); test_assert(sizeof(data) == write(fd, data, sizeof(data))); ALLOCATE_GUARD(part1, 'x'); ALLOCATE_GUARD(part2, 'y'); iovs[0].iov_base = part1; iovs[0].iov_len = sizeof(*part1); iovs[1].iov_base = part2; iovs[1].iov_len = sizeof(*part2); if (use_preadv) { /* Work around busted preadv prototype in older libcs */ nread = syscall(SYS_preadv, fd, iovs, 2, 0, 0); } else { test_assert(0 == lseek(fd, 0, SEEK_SET)); nread = readv(fd, iovs, 2); } test_assert(sizeof(data) == nread); test_assert(0 == memcmp(part1, data, sizeof(*part1))); test_assert( 0 == memcmp(part2, data + sizeof(*part1), sizeof(data) - sizeof(*part1))); test_assert(part2->ch[sizeof(data) - sizeof(*part1)] == 'y'); VERIFY_GUARD(part1); VERIFY_GUARD(part2); }
int main(int argc, char* argv[]) { int fd = open(ALSA_DEVICE_DIRECTORY "control0", O_NONBLOCK | O_RDONLY); if (fd < 0) { test_assert(errno == EACCES || errno == ENOENT); } else { int* pversion; struct snd_ctl_card_info* info; ALLOCATE_GUARD(pversion, 'x'); *pversion = -1; test_assert(0 == ioctl(fd, SNDRV_CTL_IOCTL_PVERSION, pversion)); VERIFY_GUARD(pversion); test_assert(pversion >= 0); ALLOCATE_GUARD(info, 1); test_assert(0 == ioctl(fd, SNDRV_CTL_IOCTL_CARD_INFO, info)); VERIFY_GUARD(info); test_assert(info->id[0] > 1); test_assert(info->driver[0] > 1); } atomic_puts("EXIT-SUCCESS"); return 0; }
int main(void) { int fd; struct statfs* sfs1; struct statfs* sfs2; ALLOCATE_GUARD(sfs1, 0); ALLOCATE_GUARD(sfs2, 1); fd = creat(DUMMY_FILENAME, 0600); test_assert(fd >= 0); test_assert(0 == statfs(DUMMY_FILENAME, sfs1)); test_assert(0 == fstatfs(fd, sfs2)); VERIFY_GUARD(sfs1); VERIFY_GUARD(sfs2); dump_statfs("statfs buffer", sfs1); dump_statfs("fstatfs buffer", sfs2); test_assert(same_statfs_det(sfs1, sfs2)); unlink(DUMMY_FILENAME); atomic_puts("EXIT-SUCCESS"); return 0; }
int main(int argc, char* argv[]) { struct tms* buf; clock_t t; ALLOCATE_GUARD(buf, -1); test_assert((t = times(buf)) != (clock_t)-1); test_assert(buf->tms_cutime == 0); test_assert(buf->tms_utime >= 0); VERIFY_GUARD(buf); atomic_printf("tms_utime = %lld\n", (long long)buf->tms_utime); atomic_printf("result = %lld\n", (long long)t); atomic_puts("EXIT-SUCCESS"); return 0; }
int main(void) { struct fanotify_event_metadata* event; int file_fd; int fd = fanotify_init(0, O_RDONLY); if (fd == -1 && errno == EPERM) { atomic_puts("fanotify requires CAP_SYS_ADMIN (in the root namespace) but " "we don't have those privileges; skipping tests"); atomic_puts("EXIT-SUCCESS"); return 0; } if (fd == -1 && errno == ENOSYS) { atomic_puts("fanotify is not available in this kernel; skipping tests"); atomic_puts("EXIT-SUCCESS"); return 0; } test_assert(fd >= 0); file_fd = open("foo", O_WRONLY | O_CREAT, 0777); test_assert(file_fd >= 0); test_assert(0 == close(file_fd)); test_assert(0 == fanotify_mark(fd, FAN_MARK_ADD, FAN_OPEN, AT_FDCWD, "foo")); file_fd = open("foo", O_WRONLY | O_CREAT, 0777); test_assert(file_fd >= 0); test_assert(0 == close(file_fd)); ALLOCATE_GUARD(event, 'x'); test_assert(sizeof(*event) == read(fd, event, sizeof(*event))); VERIFY_GUARD(event); test_assert(event->event_len == sizeof(*event)); test_assert(event->vers == FANOTIFY_METADATA_VERSION); test_assert(event->mask == FAN_OPEN); test_assert(event->fd >= 0); test_assert(event->pid == getpid()); test_assert(0 == unlink("foo")); atomic_puts("EXIT-SUCCESS"); return 0; }
int main(int argc, char* argv[]) { pid_t child; int status; struct user_regs_struct* regs; struct user_fpregs_struct* fpregs; #ifdef __i386__ struct user_fpxregs_struct* fpxregs; #endif int pipe_fds[2]; test_assert(0 == pipe(pipe_fds)); if (0 == (child = fork())) { char ch; read(pipe_fds[0], &ch, 1); test_assert(static_data == NEW_VALUE); return 77; } test_assert(0 == ptrace(PTRACE_ATTACH, child, NULL, NULL)); test_assert(child == waitpid(child, &status, 0)); test_assert(status == ((SIGSTOP << 8) | 0x7f)); ALLOCATE_GUARD(regs, 0xFF); test_assert(0 == ptrace(PTRACE_GETREGS, child, NULL, regs)); #if defined(__i386__) test_assert((int32_t)regs->eip != -1); test_assert((int32_t)regs->esp != -1); #elif defined(__x86_64__) test_assert((int64_t)regs->rip != -1); test_assert((int64_t)regs->rsp != -1); #else #error unknown architecture #endif VERIFY_GUARD(regs); ALLOCATE_GUARD(fpregs, 0xBB); test_assert(0 == ptrace(PTRACE_GETFPREGS, child, NULL, fpregs)); test_assert(NULL == memchr(fpregs, 0xBB, sizeof(*fpregs))); VERIFY_GUARD(fpregs); #ifdef __i386__ ALLOCATE_GUARD(fpxregs, 0xCC); test_assert(0 == ptrace(PTRACE_GETFPXREGS, child, NULL, fpxregs)); test_assert(NULL == memchr(fpxregs, 0xCC, sizeof(*fpxregs))); VERIFY_GUARD(fpxregs); #endif test_assert(static_data == ptrace(PTRACE_PEEKDATA, child, &static_data, NULL)); test_assert(0 == ptrace(PTRACE_POKEDATA, child, &static_data, (void*)NEW_VALUE)); test_assert(NEW_VALUE == ptrace(PTRACE_PEEKDATA, child, &static_data, NULL)); /* Test invalid locations */ test_assert(-1 == ptrace(PTRACE_PEEKDATA, child, NULL, NULL)); test_assert(errno == EIO || errno == EFAULT); test_assert(-1 == ptrace(PTRACE_POKEDATA, child, NULL, (void*)NEW_VALUE)); test_assert(errno == EIO || errno == EFAULT); test_assert(regs->eflags == ptrace(PTRACE_PEEKUSER, child, (void*)offsetof(struct user, regs.eflags), NULL)); test_assert(0 == ptrace(PTRACE_PEEKUSER, child, (void*)offsetof(struct user, u_debugreg[0]), NULL)); test_assert(0 == ptrace(PTRACE_PEEKUSER, child, (void*)offsetof(struct user, u_debugreg[7]), NULL)); test_assert(0 == ptrace(PTRACE_DETACH, child, NULL, NULL)); test_assert(1 == write(pipe_fds[1], "x", 1)); test_assert(child == waitpid(child, &status, 0)); test_assert(WIFEXITED(status)); test_assert(WEXITSTATUS(status) == 77); atomic_puts("EXIT-SUCCESS"); return 0; }
static int run_child(void) { int child2; int status; struct sembuf ops[2]; struct timespec ts = { 0, 20000000 }; struct timespec ts_short = { 0, 10000000 }; struct timespec ts_long = { 10000, 0 }; union semun un_arg; struct semid_ds* ds; struct seminfo* si; unsigned short* array; ops[0].sem_num = 0; ops[0].sem_op = 1; ops[0].sem_flg = SEM_UNDO; ops[1].sem_num = 1; ops[1].sem_op = 1; ops[1].sem_flg = SEM_UNDO; test_assert(0 == semop(semid, ops, 2)); *shmem = 0; ALLOCATE_GUARD(ds, 'd'); un_arg.buf = ds; test_assert(0 == semctl(semid, 0, IPC_STAT, un_arg)); VERIFY_GUARD(ds); test_assert(ds->sem_perm.mode == 0666); test_assert(ds->sem_nsems == COUNT); ds->sem_perm.mode = 0660; test_assert(0 == semctl(semid, 0, IPC_SET, un_arg)); ALLOCATE_GUARD(si, 'i'); un_arg.__buf = si; /* The following syscall should always return >= 1, but sometimes it returns 0. I don't know why. */ test_assert(0 <= semctl(semid, 0, IPC_INFO, un_arg)); VERIFY_GUARD(si); test_assert(si->semvmx > 0); test_assert(si->semusz < 100000); /* The following syscall should always return >= 1, but sometimes it returns 0. I don't know why. */ test_assert(0 <= semctl(semid, 0, SEM_INFO, un_arg)); VERIFY_GUARD(si); test_assert(si->semusz > 0); test_assert(si->semusz < 100000); array = allocate_guard(COUNT * sizeof(*array), 'a'); un_arg.array = array; test_assert(0 == semctl(semid, 0, GETALL, un_arg)); verify_guard(COUNT * sizeof(*array), array); test_assert(array[0] == 1); test_assert(array[1] == 1); test_assert(array[2] == 0); test_assert(array[3] == 0); array[2] = 2; test_assert(0 == semctl(semid, 0, SETALL, un_arg)); test_assert(0 == semctl(semid, 1, GETNCNT, NULL)); test_assert(getpid() == semctl(semid, 1, GETPID, NULL)); test_assert(2 == semctl(semid, 2, GETVAL, NULL)); test_assert(0 == semctl(semid, 0, GETZCNT, NULL)); un_arg.val = 0; test_assert(0 == semctl(semid, 2, SETVAL, un_arg)); if ((child2 = fork()) == 0) { ops[0].sem_op = -1; ops[1].sem_op = -1; /* The semtimedop timeout is irrelevant. We're just checking that the syscall works. */ test_assert(0 == semtimedop(semid, ops, 2, &ts_long)); *shmem = 1; test_assert(0 == nanosleep(&ts, NULL)); *shmem = 0; ops[0].sem_op = 1; ops[1].sem_op = 1; test_assert(0 == semtimedop(semid, ops, 2, &ts)); return 0; } test_assert(0 == nanosleep(&ts_short, NULL)); ops[0].sem_op = -1; ops[1].sem_op = -1; test_assert(0 == semop(semid, ops, 2)); test_assert(*shmem == 0); ops[0].sem_op = 1; ops[1].sem_op = 1; test_assert(0 == semop(semid, ops, 2)); test_assert(child2 == waitpid(child2, &status, __WALL)); test_assert(0 == status); return 0; }
/** * Fetch and print the ifconfig for this machine. Fill in * |req.ifr_name| with the first non-loopback interface name found, preferring * a wireless interface if possible. * |eth_req| returns an ethernet interface if possible. */ static void get_ifconfig(int sockfd, struct ifreq* req, struct ifreq* eth_req) { struct { struct ifreq ifaces[100]; } * ifaces; struct ifconf* ifconf; int ret; ssize_t num_ifaces; int i; int wireless_index = -1; int eth_index = -1; int non_loop_index = -1; ALLOCATE_GUARD(ifconf, 0xff); ALLOCATE_GUARD(ifaces, 'y'); ifconf->ifc_len = sizeof(*ifaces); ifconf->ifc_req = ifaces->ifaces; ret = ioctl(sockfd, SIOCGIFCONF, ifconf); VERIFY_GUARD(ifconf); VERIFY_GUARD(ifaces); num_ifaces = ifconf->ifc_len / sizeof(ifaces->ifaces[0]); test_assert(num_ifaces < 100); atomic_printf("SIOCGIFCONF(ret %d): %zd ifaces (%d bytes of ifreq)\n", ret, num_ifaces, ifconf->ifc_len); test_assert(0 == ret); test_assert(0 == (ifconf->ifc_len % sizeof(ifaces->ifaces[0]))); if (!num_ifaces) { atomic_puts("No interfaces found\n"); atomic_puts("EXIT-SUCCESS"); exit(0); } for (i = 0; i < num_ifaces; ++i) { const struct ifreq* ifc = &ifconf->ifc_req[i]; atomic_printf(" iface %d: name:%s addr:%s\n", i, ifc->ifr_name, sockaddr_name(&ifc->ifr_addr)); switch (ifc->ifr_name[0]) { case 'w': wireless_index = i; non_loop_index = i; break; case 'e': eth_index = i; non_loop_index = i; break; case 't': case 'l': break; default: non_loop_index = i; break; } } if (wireless_index >= 0) { strcpy(req->ifr_name, ifaces->ifaces[wireless_index].ifr_name); } else if (non_loop_index >= 0) { strcpy(req->ifr_name, ifaces->ifaces[non_loop_index].ifr_name); } else { strcpy(req->ifr_name, ifaces->ifaces[0].ifr_name); } if (eth_index >= 0) { strcpy(eth_req->ifr_name, ifaces->ifaces[eth_index].ifr_name); } else if (non_loop_index >= 0) { strcpy(eth_req->ifr_name, ifaces->ifaces[non_loop_index].ifr_name); } else { strcpy(eth_req->ifr_name, ifaces->ifaces[0].ifr_name); } }
int main(void) { int sockfd = socket(AF_INET, SOCK_DGRAM, 0); struct ifreq* req; struct ifreq* eth_req; char name[PATH_MAX]; int index; struct ethtool_cmd* etc; int err, ret; struct iwreq* wreq; char buf[1024]; ALLOCATE_GUARD(req, 'a'); ALLOCATE_GUARD(eth_req, 'a'); get_ifconfig(sockfd, req, eth_req); strcpy(name, req->ifr_name); req->ifr_ifindex = -1; strcpy(req->ifr_name, name); ret = ioctl(sockfd, SIOCGIFINDEX, req); VERIFY_GUARD(req); atomic_printf("SIOCGIFINDEX(ret:%d): %s index is %d\n", ret, req->ifr_name, req->ifr_ifindex); test_assert(0 == ret); test_assert(req->ifr_ifindex != -1); index = req->ifr_ifindex; memset(&req->ifr_name, 0xff, sizeof(req->ifr_name)); req->ifr_ifindex = index; ret = ioctl(sockfd, SIOCGIFNAME, req); VERIFY_GUARD(req); atomic_printf("SIOCGIFNAME(ret:%d): index %d(%s) name is %s\n", ret, index, name, req->ifr_name); test_assert(0 == ret); test_assert(!strcmp(name, req->ifr_name)); GENERIC_REQUEST_BY_NAME(SIOCGIFFLAGS); atomic_printf("flags are %#x\n", req->ifr_flags); GENERIC_REQUEST_BY_NAME(SIOCGIFADDR); atomic_printf("addr is %s\n", sockaddr_name(&req->ifr_addr)); GENERIC_REQUEST_BY_NAME(SIOCGIFDSTADDR); atomic_printf("addr is %s\n", sockaddr_name(&req->ifr_addr)); GENERIC_REQUEST_BY_NAME(SIOCGIFBRDADDR); atomic_printf("addr is %s\n", sockaddr_name(&req->ifr_addr)); GENERIC_REQUEST_BY_NAME(SIOCGIFNETMASK); atomic_printf("netmask is %s\n", sockaddr_name(&req->ifr_addr)); GENERIC_REQUEST_BY_NAME(SIOCGIFMETRIC); atomic_printf("metric is %d\n", req->ifr_metric); memset(&req->ifr_metric, 0xff, sizeof(req->ifr_metric)); ret = ioctl(sockfd, SIOCGIFMEM, req); VERIFY_GUARD(req); test_assert(-1 == ret && errno == ENOTTY); GENERIC_REQUEST_BY_NAME(SIOCGIFMTU); atomic_printf("MTU is %d\n", req->ifr_mtu); GENERIC_REQUEST_BY_NAME(SIOCGIFHWADDR); atomic_printf("hwaddr %s\n", sockaddr_hw_name(&req->ifr_addr)); memset(&req->ifr_flags, 0xff, sizeof(req->ifr_flags)); ret = ioctl(sockfd, SIOCGIFPFLAGS, req); VERIFY_GUARD(req); if (ret != -1 || errno != EINVAL) { test_assert(0 == ret); atomic_printf("SIOCGIFPFLAGS(ret:%d): %s flags are", ret, req->ifr_name); atomic_printf(" %#x\n", req->ifr_flags); } GENERIC_REQUEST_BY_NAME(SIOCGIFTXQLEN); atomic_printf("qlen is %d\n", req->ifr_qlen); ALLOCATE_GUARD(etc, 'b'); etc->cmd = ETHTOOL_GSET; req->ifr_data = (char*)&etc; ret = ioctl(sockfd, SIOCETHTOOL, req); VERIFY_GUARD(req); VERIFY_GUARD(etc); err = errno; atomic_printf("SIOCETHTOOL(ret:%d): %s ethtool data: ", ret, req->ifr_name); if (-1 == ret) { atomic_printf("WARNING: %s doesn't appear to support SIOCETHTOOL\n", name); test_assert(EOPNOTSUPP == err || EPERM == err); } else { atomic_printf("speed:%#x duplex:%#x port:%#x physaddr:%#x, maxtxpkt:%u " "maxrxpkt:%u ...\n", ethtool_cmd_speed(etc), etc->duplex, etc->port, etc->phy_address, etc->maxtxpkt, etc->maxrxpkt); } GENERIC_WIRELESS_PARAM_REQUEST_BY_NAME(SIOCGIWRATE, bitrate); GENERIC_WIRELESS_REQUEST_BY_NAME(SIOCGIWNAME, ("wireless protocol name:%s", wreq->u.name)); GENERIC_WIRELESS_REQUEST_BY_NAME(SIOCGIWMODE, (" wireless mode:%d", wreq->u.mode)); ALLOCATE_GUARD(wreq, 'e'); strcpy(wreq->ifr_ifrn.ifrn_name, name); wreq->u.essid.length = sizeof(buf); wreq->u.essid.pointer = buf; wreq->u.essid.flags = 0; ret = ioctl(sockfd, SIOCGIWESSID, wreq); VERIFY_GUARD(wreq); err = errno; atomic_printf("SIOCGIWESSID(ret:%d): %s: ", ret, wreq->ifr_name); if (-1 == ret) { atomic_printf("WARNING: %s doesn't appear to be a wireless iface\n", name); test_assert(EOPNOTSUPP == err || EPERM == err || EINVAL == err); } else { atomic_printf("wireless ESSID:%s\n", buf); } GENERIC_WIRELESS_PARAM_REQUEST_BY_NAME(SIOCGIWSENS, sens); atomic_puts("EXIT-SUCCESS"); return 0; }
int main(void) { int fd = open("/dev/ptmx", O_RDONLY); pid_t child; int ret; int status; int* arg; test_assert(fd >= 0); atomic_printf("pty ptsname = %s\n", ptsname(fd)); ALLOCATE_GUARD(arg, 'a'); test_assert(0 == ioctl(fd, TIOCGPKT, arg)); VERIFY_GUARD(arg); test_assert(*arg == 0); test_assert(0 == ioctl(fd, TIOCPKT, arg)); ALLOCATE_GUARD(arg, 'b'); test_assert(0 == ioctl(fd, TIOCGPTN, arg)); VERIFY_GUARD(arg); atomic_printf("pty number = %d\n", *arg); ALLOCATE_GUARD(arg, 'c'); test_assert(0 == ioctl(fd, TIOCGPTLCK, arg)); VERIFY_GUARD(arg); test_assert(*arg == 1); test_assert(0 == ioctl(fd, TIOCSPTLCK, arg)); test_assert(0 == ioctl(fd, TCXONC, TCOOFF)); test_assert(0 == ioctl(fd, TCFLSH, TCIFLUSH)); child = fork(); if (!child) { test_assert(getpid() == setsid()); test_assert(0 == ioctl(fd, TIOCSCTTY, 0)); ioctl(fd, TIOCNOTTY); // The above ioctl can legitimately fail. If so, fake it. kill(getpid(), SIGHUP); } test_assert(child == waitpid(child, &status, 0)); test_assert(WIFSIGNALED(status) && WTERMSIG(status) == SIGHUP); ret = ioctl(fd, TIOCSTI, "x"); test_assert(ret >= 0 || errno == EPERM); test_assert(0 == ioctl(fd, TIOCEXCL)); ALLOCATE_GUARD(arg, 'd'); test_assert(0 == ioctl(fd, TIOCGEXCL, arg)); VERIFY_GUARD(arg); test_assert(*arg == 1); test_assert(0 == ioctl(fd, TIOCNXCL)); ALLOCATE_GUARD(arg, 'e'); test_assert(0 == ioctl(fd, TIOCGETD, arg)); VERIFY_GUARD(arg); atomic_printf("pty TIOCGETD = %d\n", *arg); test_assert(0 == ioctl(fd, TIOCSETD, arg)); atomic_puts("EXIT-SUCCESS"); return 0; }