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;
}
