static int tish_uname(char * argv[])
{
char * arg = argv[1];
int mib[2];
int len;
size_t str_len;
char type[20];
char rele[40] = "";
char vers[40] = "";
len = sysctlnametomib("kern.ostype", mib, num_elem(mib));
str_len = sizeof(type);
sysctl(mib, len, &type, &str_len, 0, 0);
if (arg && !strcmp(arg, "-a")) {
len = sysctlnametomib("kern.osrelease", mib, num_elem(mib));
str_len = sizeof(rele);
sysctl(mib, len, &rele, &str_len, 0, 0);
len = sysctlnametomib("kern.version", mib, num_elem(mib));
str_len = sizeof(vers);
sysctl(mib, len, &vers, &str_len, 0, 0);
}
printf("%s %s %s\n", type, rele, vers);
return 0;
}
static int tish_ikut(char * argv[])
{
int mib_test[5];
int mib_cur[5];
int mib_next[5];
size_t len_cur, len_next;
const int one = 1;
const size_t len_test = sysctlnametomib("debug.test", mib_test,
num_elem(mib_test));
printf(" \n"); /* Hack */
print_mib_name(mib_test, len_test);
memcpy(mib_cur, mib_test, len_test * sizeof(int));
len_cur = len_test;
while ((len_next = sizeof(mib_next)),
sysctlgetnext(mib_cur, len_cur, mib_next, &len_next) == 0) {
if (!sysctltstmib(mib_next, mib_test, len_test)) {
printf("End of tests\n");
break; /* EOF debug.test */
}
memcpy(mib_cur, mib_next, len_next * sizeof(int));
len_cur = len_next;
print_mib_name(mib_cur, len_cur);
sysctl(mib_cur, len_cur, 0, 0, (void *)(&one), sizeof(one));
}
return 0;
}
static int
num_elem(int height)
{
if (height < 0)
return 0;
return (1 << height) + num_elem(height - 1);
}
static int getset_parm(char * arg)
{
char * name;
char * value;
char * rest;
int mib[CTL_MAXNAME];
char fmt[5];
unsigned int kind;
int ctltype;
size_t dlen;
name = strtok_r(arg, "=", &rest);
value = strtok_r(0, "=", &rest);
if (!name) {
printf("Invalid argument\n");
errno = EINVAL;
return -1;
}
const int mib_len = sysctlnametomib(name, mib, num_elem(mib));
if (mib_len < 0) {
printf("Node not found\n");
return -1;
}
printf("%s = ", name);
if (sysctloidfmt(mib, mib_len, fmt, &kind)) {
printf("Invalid node\n");
return -1;
}
if (sysctl(mib, mib_len, 0, &dlen, 0, 0)) {
printf("Invalid node\n");
return -1;
}
ctltype = (kind & CTLTYPE);
switch (ctltype) {
case CTLTYPE_STRING:
return getset_svalue(mib, mib_len, dlen, value, strnlen(value, 80));
case CTLTYPE_INT:
case CTLTYPE_UINT:
return getset_ivalue(mib, mib_len, dlen, value, sizeof(int));
case CTLTYPE_LONG:
case CTLTYPE_ULONG:
case CTLTYPE_S64:
case CTLTYPE_U64:
printf("Data type not supported yet\n");
break;
}
return 0;
}
static void arp_cache_update(int delta_time)
{
size_t i;
for (i = 0; i < num_elem(arp_cache); i++) {
struct arp_cache_entry * entry = &arp_cache[i];
if (entry->age > ARP_CACHE_AGE_MAX) {
entry->age = ARP_CACHE_FREE;
} else if (entry->age >= 0) {
entry->age += delta_time;
}
}
}
int arp_cache_insert(in_addr_t ip_addr, const mac_addr_t haddr,
enum arp_cache_entry_type type)
{
size_t i;
struct arp_cache_entry * it;
struct arp_cache_entry * entry = NULL;
if (ip_addr == 0) {
return 0;
}
it = arp_cache;
for (i = 0; i < num_elem(arp_cache); i++) {
if (it->age == ARP_CACHE_FREE) {
entry = it;
} else if ((entry && entry->age > it->age) ||
(!entry && it->age >= 0)) {
entry = it;
}
/* TODO Use RB_FIND first */
if (it->ip_addr == ip_addr) {
/* This is a replacement for an existing entry. */
entry = it;
break;
}
it++;
}
if (!entry) {
errno = ENOMEM;
return -1;
} else if (entry->age >= 0) {
RB_REMOVE(arp_cache_tree, &arp_cache_head, entry);
}
entry->ip_addr = ip_addr;
memcpy(entry->haddr, haddr, sizeof(mac_addr_t));
entry->age = (int)type;
RB_INSERT(arp_cache_tree, &arp_cache_head, entry);
return 0;
}
/*
* Some pthread implementations requires that the stack size is a
* multiple of the size of a page
*/
static int
stack_sz(int depth)
{
int sz = (num_elem(depth) * sizeof(struct node) + STACK_WORK_SZ);
return (sz + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1);
}
