/*
* Fork off a child process. The child will open the semaphore via
* the same name. The child will then block on the semaphore waiting
* for the parent to post it.
*/
static int
wait_twoproc_child(void *arg)
{
semid_t id;
if (ksem_open(&id, TEST_PATH, 0, 0, 0) < 0)
return (CSTAT(1, errno));
if (ksem_wait(id) < 0)
return (CSTAT(2, errno));
if (ksem_close(id) < 0)
return (CSTAT(3, errno));
return (CSTAT(0, 0));
}
static int
fdlimit_set(void *arg)
{
struct rlimit rlim;
int max;
max = (intptr_t)arg;
if (getrlimit(RLIMIT_NOFILE, &rlim) < 0)
return (CSTAT(3, errno));
rlim.rlim_cur = max;
if (setrlimit(RLIMIT_NOFILE, &rlim) < 0)
return (CSTAT(4, errno));
return (0);
}
static int
exhaust_unnamed_child(void *arg)
{
semid_t id;
int i, max;
max = (intptr_t)arg;
for (i = 0; i < max + 1; i++) {
if (ksem_init(&id, 1) < 0) {
if (errno == ENOSPC)
return (CSTAT(0, 0));
return (CSTAT(1, errno));
}
}
return (CSTAT(2, 0));
}
static int
exhaust_named_child(void *arg)
{
char buffer[64];
semid_t id;
int i, max;
max = (intptr_t)arg;
for (i = 0; i < max + 1; i++) {
snprintf(buffer, sizeof(buffer), "%s%d", TEST_PATH, i);
if (ksem_open(&id, buffer, O_CREAT, 0777, 1) < 0) {
if (errno == ENOSPC || errno == EMFILE ||
errno == ENFILE)
return (CSTAT(0, 0));
return (CSTAT(1, errno));
}
}
return (CSTAT(2, errno));
}
int
noit_check_etc_hosts_cache_refresh(eventer_t e, int mask, void *closure,
struct timeval *now) {
static struct stat last_stat;
struct stat sb;
struct hostent *ent;
int reload = 0;
memset(&sb, 0, sizeof(sb));
stat("/etc/hosts", &sb);
#define CSTAT(f) (sb.f == last_stat.f)
reload = ! (CSTAT(st_dev) && CSTAT(st_ino) && CSTAT(st_mode) && CSTAT(st_uid) &&
CSTAT(st_gid) && CSTAT(st_size) && CSTAT(st_mtime));
memcpy(&last_stat, &sb, sizeof(sb));
if(reload) {
mtev_hash_delete_all(&etc_hosts_cache, free, free);
while(NULL != (ent = gethostent())) {
int i = 0;
char *name = ent->h_name;
while(name) {
void *vnode;
static_host_node *node;
if(!mtev_hash_retrieve(&etc_hosts_cache, name, strlen(name), &vnode)) {
vnode = node = calloc(1, sizeof(*node));
node->target = strdup(name);
mtev_hash_store(&etc_hosts_cache, node->target, strlen(node->target), node);
}
node = vnode;
if(ent->h_addrtype == AF_INET) {
node->has_ip4 = 1;
memcpy(&node->ip4, ent->h_addr_list[0], ent->h_length);
}
if(ent->h_addrtype == AF_INET6) {
node->has_ip6 = 1;
memcpy(&node->ip6, ent->h_addr_list[0], ent->h_length);
}
name = ent->h_aliases[i++];
}
}
endhostent();
mtevL(noit_debug, "reloaded %d /etc/hosts targets\n", mtev_hash_size(&etc_hosts_cache));
}
eventer_add_in_s_us(noit_check_etc_hosts_cache_refresh, NULL, 1, 0);
return 0;
}
void sendarp(int ifr_idx, const unsigned char* mac, in_addr_t ip)
{
int fd;
struct sockaddr_ll sll;
struct arp_buf buf;
CSTAT(sendarp);
STAT(arp_sent);
/* Ethernet */
memset(buf.eth.ether_dhost, 0xFF, ETH_ALEN);
memcpy(buf.eth.ether_shost, mac, ETH_ALEN);
buf.eth.ether_type = htons(ETHERTYPE_ARP);
/* ARP */
buf.arp.ar_hrd = htons(ARPHRD_ETHER);
buf.arp.ar_pro = htons(ETHERTYPE_IP);
buf.arp.ar_hln = ETH_ALEN;
buf.arp.ar_pln = 4; //IPPROTO_ADDR_LEN;
buf.arp.ar_op = htons(ARPOP_REQUEST);
/* Data */
memcpy(buf.ar_sha, mac, ETH_ALEN);
memcpy(&buf.ar_sip, &ip, sizeof(ip));
memcpy(buf.ar_tha, mac, ETH_ALEN);
memcpy(&buf.ar_tip, &ip, sizeof(ip));
/* Now actually send the thing */
fd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_RARP));
memset(&sll, 0, sizeof(sll));
sll.sll_family = AF_PACKET;
memcpy(sll.sll_addr, mac, sizeof(sll.sll_addr) - 1);
sll.sll_halen = ETH_ALEN;
sll.sll_ifindex = ifr_idx;
sendto(fd, &buf, sizeof(buf), 0, (struct sockaddr*)&sll, sizeof(sll));
close(fd);
}
