static void
ssl_ctx_cache_remove(const char *key) {
mtevL(eventer_deb, "ssl_ctx_cache->remove(%s)\n", key);
pthread_mutex_lock(&ssl_ctx_cache_lock);
mtev_hash_delete(&ssl_ctx_cache, key, strlen(key),
NULL, (void (*)(void *))ssl_ctx_cache_node_free);
pthread_mutex_unlock(&ssl_ctx_cache_lock);
}
static int
filterset_accum(noit_check_t *check, void *closure) {
mtev_hash_table *active = closure;
if(!check->filterset) return 0;
if(mtev_hash_delete(active, check->filterset, strlen(check->filterset), free, NULL))
return 1;
return 0;
}
int
noit_filter_remove(mtev_conf_section_t vnode) {
int removed;
char *name = (char *)xmlGetProp(vnode, (xmlChar *)"name");
if(!name) return 0;
LOCKFS();
removed = mtev_hash_delete(filtersets, name, strlen(name),
NULL, filterset_free);
UNLOCKFS();
return removed;
}
static void noit_fq_set_filters(mq_command_t *commands, int count) {
int i, j;
if (!global_fq_ctx.filtered_exchange[0]) {
mtevL(mtev_error, "ERROR: trying to set check for filtered exchange when no such exchange exists\n");
return;
}
for (i=0; i<count; i++) {
if (commands[i].action == MQ_ACTION_SET) {
mtev_hash_table *metric_table = calloc(1, sizeof(mtev_hash_table));
mtev_hash_init(metric_table);
for (j=0; j<commands[i].check.metric_count; j++) {
mtev_hash_store(metric_table, strdup(commands[i].check.metrics[j]), strlen(commands[i].check.metrics[j]), NULL);
filtered_metrics_exist = true;
}
mtev_hash_replace(&filtered_checks_hash, strdup(commands[i].check.uuid), strlen(commands[i].check.uuid), metric_table, free, noit_fq_free_metric_hash);
}
else {
if (commands[i].check.metric_count == 0) {
/* Forget the whole check */
if (!mtev_hash_delete(&filtered_checks_hash, commands[i].check.uuid, strlen(commands[i].check.uuid), free, noit_fq_free_metric_hash)) {
mtevL(mtev_error, "failed forgetting check %s - check does not exist\n", commands[i].check.uuid);
}
}
else {
mtev_hash_table *filtered_metrics;
if(mtev_hash_retrieve(&filtered_checks_hash, commands[i].check.uuid, strlen(commands[i].check.uuid), (void**)&filtered_metrics)) {
for (j=0; j<commands[i].check.metric_count; j++) {
if (!mtev_hash_delete(filtered_metrics, commands[i].check.metrics[j], strlen(commands[i].check.metrics[j]),
free, noit_fq_free_metric_hash)) {
mtevL(mtev_error, "failed forgetting metric '%s' for check %s - metric does not exist\n",
commands[i].check.metrics[j], commands[i].check.uuid);
}
}
}
else {
mtevL(mtev_error, "failed forgetting metrics for check %s - check does not exist\n", commands[i].check.uuid);
}
}
}
}
}
static int
prune_old_dedupe_hashes(eventer_t e, int mask, void *unused,
struct timeval *now) {
mtev_hash_iter iter = MTEV_HASH_ITER_ZERO;
uint64_t now_hrtime = mtev_gethrtime() / 1000000000;
const char *k;
int klen;
void *data;
struct hash_and_time *hash_with_time;
struct removable_hashes {
uint64_t key;
struct hash_and_time *data;
struct removable_hashes *next;
};
struct removable_hashes *head = NULL;
struct removable_hashes *tail = NULL;
/* build a list of expirable items */
while(mtev_hash_next(&dedupe_hashes, &iter, &k, &klen, &data)) {
hash_with_time = data;
if (now_hrtime > hash_with_time->last_touched_s && now_hrtime - hash_with_time->last_touched_s > 10) {
struct removable_hashes *h = calloc(1, sizeof(struct removable_hashes));
h->key = *(uint64_t *)k;
h->data = hash_with_time;
if (tail != NULL) {
tail->next = h;
}
tail = h;
if (head == NULL) {
head = tail;
}
}
}
/* expire them */
while (head != NULL) {
mtev_hash_delete(&dedupe_hashes, (const char *)&head->key, sizeof(head->key), free, NULL);
mtev_hash_destroy(&head->data->hash, free, NULL);
free(head->data);
struct removable_hashes *prev = head;
head = head->next;
free(prev);
}
e->whence.tv_sec = now->tv_sec + 5;
return 1;
}
static mtev_hash_table *
stratcon_datastore_journal_remove(struct sockaddr *remote,
const char *remote_cn) {
void *vhash = NULL;
if(mtev_hash_retrieve(&working_sets, remote_cn, strlen(remote_cn), &vhash)) {
/* pluck it out */
mtev_hash_delete(&working_sets, remote_cn, strlen(remote_cn), free, NULL);
}
else {
mtevL(noit_error, "attempted checkpoint on non-existing workingset: '%s'\n",
remote_cn);
}
return vhash;
}
static int ping_icmp_timeout(eventer_t e, int mask,
void *closure, struct timeval *now) {
struct ping_closure *pcl = (struct ping_closure *)closure;
struct ping_session_key k;
struct check_info *data;
ping_icmp_data_t *ping_data;
if(!NOIT_CHECK_KILLED(pcl->check) && !NOIT_CHECK_DISABLED(pcl->check)) {
ping_icmp_log_results(pcl->self, pcl->check);
}
data = (struct check_info *)pcl->check->closure;
data->timeout_event = NULL;
pcl->check->flags &= ~NP_RUNNING;
ping_data = noit_module_get_userdata(pcl->self);
k.addr_of_check = (vpsized_uint)pcl->check ^ random_num;
uuid_copy(k.checkid, pcl->check->checkid);
mtev_hash_delete(ping_data->in_flight, (const char *)&k, sizeof(k),
free, NULL);
free(pcl);
return 0;
}
static int ping_icmp_handler(eventer_t e, int mask,
void *closure, struct timeval *now,
u_int8_t family) {
noit_module_t *self = (noit_module_t *)closure;
ping_icmp_data_t *ping_data;
struct check_info *data;
char packet[1500];
int packet_len = sizeof(packet);
union {
struct sockaddr_in in4;
struct sockaddr_in6 in6;
} from;
unsigned int from_len;
struct ping_payload *payload;
if(family != AF_INET && family != AF_INET6) return EVENTER_READ;
ping_data = noit_module_get_userdata(self);
while(1) {
struct ping_session_key k;
int inlen;
u_int8_t iphlen = 0;
void *vcheck;
noit_check_t *check;
struct timeval tt, whence;
from_len = sizeof(from);
inlen = recvfrom(e->fd, packet, packet_len, 0,
(struct sockaddr *)&from, &from_len);
mtev_gettimeofday(now, NULL); /* set it, as we care about accuracy */
if(inlen < 0) {
if(errno == EAGAIN || errno == EINTR) break;
mtevLT(nldeb, now, "ping_icmp recvfrom: %s\n", strerror(errno));
break;
}
if(family == AF_INET) {
struct icmp *icp4;
iphlen = ((struct ip *)packet)->ip_hl << 2;
if((inlen-iphlen) != sizeof(struct icmp)+PING_PAYLOAD_LEN) {
mtevLT(nldeb, now,
"ping_icmp bad size: %d+%d\n", iphlen, inlen-iphlen);
continue;
}
icp4 = (struct icmp *)(packet + iphlen);
payload = (struct ping_payload *)(icp4 + 1);
if(icp4->icmp_type != ICMP_ECHOREPLY) {
mtevLT(nldeb, now, "ping_icmp bad type: %d\n", icp4->icmp_type);
continue;
}
if(icp4->icmp_id != (((vpsized_uint)self) & 0xffff)) {
mtevLT(nldeb, now,
"ping_icmp not sent from this instance (%d:%d) vs. %lu\n",
icp4->icmp_id, ntohs(icp4->icmp_seq),
(unsigned long)(((vpsized_uint)self) & 0xffff));
continue;
}
}
else if(family == AF_INET6) {
struct icmp6_hdr *icp6 = (struct icmp6_hdr *)packet;
if((inlen) != sizeof(struct icmp6_hdr)+PING_PAYLOAD_LEN) {
mtevLT(nldeb, now,
"ping_icmp bad size: %d+%d\n", iphlen, inlen-iphlen);
continue;
}
payload = (struct ping_payload *)(icp6+1);
if(icp6->icmp6_type != ICMP6_ECHO_REPLY) {
mtevLT(nldeb, now, "ping_icmp bad type: %d\n", icp6->icmp6_type);
continue;
}
if(icp6->icmp6_id != (((vpsized_uint)self) & 0xffff)) {
mtevLT(nldeb, now,
"ping_icmp not sent from this instance (%d:%d) vs. %lu\n",
icp6->icmp6_id, ntohs(icp6->icmp6_seq),
(unsigned long)(((vpsized_uint)self) & 0xffff));
continue;
}
}
else {
/* This should be unreachable */
continue;
}
check = NULL;
k.addr_of_check = payload->addr_of_check;
uuid_copy(k.checkid, payload->checkid);
if(mtev_hash_retrieve(ping_data->in_flight,
(const char *)&k, sizeof(k),
&vcheck))
check = vcheck;
/* make sure this check is from this generation! */
if(!check) {
char uuid_str[37];
uuid_unparse_lower(payload->checkid, uuid_str);
mtevLT(nldeb, now,
"ping_icmp response for unknown check '%s'\n", uuid_str);
continue;
}
if((check->generation & 0xffff) != payload->generation) {
mtevLT(nldeb, now,
"ping_icmp response in generation gap\n");
continue;
}
data = (struct check_info *)check->closure;
/* If there is no timeout_event, the check must have completed.
* We have nothing to do. */
if(!data->timeout_event) continue;
/* Sanity check the payload */
if(payload->check_no != data->check_no) continue;
if(payload->check_pack_cnt != data->expected_count) continue;
if(payload->check_pack_no >= data->expected_count) continue;
whence.tv_sec = payload->tv_sec;
whence.tv_usec = payload->tv_usec;
sub_timeval(*now, whence, &tt);
data->turnaround[payload->check_pack_no] =
(float)tt.tv_sec + (float)tt.tv_usec / 1000000.0;
if(ping_icmp_is_complete(self, check)) {
ping_icmp_log_results(self, check);
eventer_remove(data->timeout_event);
free(data->timeout_event->closure);
eventer_free(data->timeout_event);
data->timeout_event = NULL;
check->flags &= ~NP_RUNNING;
k.addr_of_check = (vpsized_uint)check ^ random_num;
uuid_copy(k.checkid, check->checkid);
mtev_hash_delete(ping_data->in_flight, (const char *)&k,
sizeof(k), free, NULL);
}
}
return EVENTER_READ;
}
