Lines Matching +full:data +full:- +full:addr
2 * services/cache/infra.c - infrastructure cache, server rtt and capabilities
29 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
49 #include "util/data/dname.h"
66 * infra-cache-max-rtt) change it to just above the RTT_BAND. */
69 USEFUL_SERVER_TOP_TIMEOUT - 1000 <= RTT_BAND \
71 :USEFUL_SERVER_TOP_TIMEOUT - 1000)
89 return sizeof(*key) + sizeof(struct infra_data) + key->namelen
90 + lock_get_mem(&key->entry.lock);
98 int r = sockaddr_cmp(&k1->addr, k1->addrlen, &k2->addr, k2->addrlen);
101 if(k1->namelen != k2->namelen) {
102 if(k1->namelen < k2->namelen)
103 return -1;
106 return query_dname_compare(k1->zonename, k2->zonename);
115 lock_rw_destroy(&key->entry.lock);
116 free(key->zonename);
123 struct infra_data* data = (struct infra_data*)d;
124 free(data);
131 return sizeof(*key) + sizeof(struct rate_data) + key->namelen
132 + lock_get_mem(&key->entry.lock);
140 if(k1->namelen != k2->namelen) {
141 if(k1->namelen < k2->namelen)
142 return -1;
145 return query_dname_compare(k1->name, k2->name);
154 lock_rw_destroy(&key->entry.lock);
155 free(key->name);
162 struct rate_data* data = (struct rate_data*)d;
163 free(data);
184 d = (struct domain_limit_data*)name_tree_find(&infra->domain_limits,
197 d->node.node.key = &d->node;
198 d->node.name = nm;
199 d->node.len = nmlen;
200 d->node.labs = labs;
201 d->node.dclass = LDNS_RR_CLASS_IN;
202 d->lim = -1;
203 d->below = -1;
204 if(!name_tree_insert(&infra->domain_limits, &d->node, nm, nmlen,
220 for(p = cfg->ratelimit_for_domain; p; p = p->next) {
221 d = domain_limit_findcreate(infra, p->str);
224 d->lim = atoi(p->str2);
226 for(p = cfg->ratelimit_below_domain; p; p = p->next) {
227 d = domain_limit_findcreate(infra, p->str);
230 d->below = atoi(p->str2);
239 name_tree_init(&infra->domain_limits);
243 name_tree_init_parents(&infra->domain_limits);
253 struct sockaddr_storage addr;
258 if(!netblockstrtoaddr(str, 0, &addr, &addrlen, &net)) {
265 tree = &infra->wait_limits_cookie_netblock;
267 tree = &infra->wait_limits_netblock;
268 d = (struct wait_limit_netblock_info*)addr_tree_find(tree, &addr,
277 d->limit = -1;
278 if(!addr_tree_insert(tree, &d->node, &addr, addrlen, net)) {
294 for(p = cfg->wait_limit_netblock; p; p = p->next) {
295 d = wait_limit_netblock_findcreate(infra, p->str, 0);
298 d->limit = atoi(p->str2);
300 for(p = cfg->wait_limit_cookie_netblock; p; p = p->next) {
301 d = wait_limit_netblock_findcreate(infra, p->str, 1);
304 d->limit = atoi(p->str2);
313 addr_tree_init(&infra->wait_limits_netblock);
314 addr_tree_init(&infra->wait_limits_cookie_netblock);
317 addr_tree_init_parents(&infra->wait_limits_netblock);
318 addr_tree_init_parents(&infra->wait_limits_cookie_netblock);
327 size_t maxmem = cfg->infra_cache_numhosts * (sizeof(struct infra_key)+
332 infra->hosts = slabhash_create(cfg->infra_cache_slabs,
335 if(!infra->hosts) {
339 infra->host_ttl = cfg->host_ttl;
340 infra->infra_keep_probing = cfg->infra_keep_probing;
341 infra_dp_ratelimit = cfg->ratelimit;
342 infra->domain_rates = slabhash_create(cfg->ratelimit_slabs,
343 INFRA_HOST_STARTSIZE, cfg->ratelimit_size,
346 if(!infra->domain_rates) {
350 /* insert config data into ratelimits */
359 infra_ip_ratelimit = cfg->ip_ratelimit;
360 infra_ip_ratelimit_cookie = cfg->ip_ratelimit_cookie;
361 infra->client_ip_rates = slabhash_create(cfg->ip_ratelimit_slabs,
362 INFRA_HOST_STARTSIZE, cfg->ip_ratelimit_size, &ip_rate_sizefunc,
364 if(!infra->client_ip_rates) {
375 free(((struct domain_limit_data*)n)->node.name);
391 slabhash_delete(infra->hosts);
392 slabhash_delete(infra->domain_rates);
393 traverse_postorder(&infra->domain_limits, domain_limit_free, NULL);
394 slabhash_delete(infra->client_ip_rates);
395 traverse_postorder(&infra->wait_limits_netblock,
397 traverse_postorder(&infra->wait_limits_cookie_netblock,
408 infra->host_ttl = cfg->host_ttl;
409 infra->infra_keep_probing = cfg->infra_keep_probing;
410 infra_dp_ratelimit = cfg->ratelimit;
411 infra_ip_ratelimit = cfg->ip_ratelimit;
412 infra_ip_ratelimit_cookie = cfg->ip_ratelimit_cookie;
413 maxmem = cfg->infra_cache_numhosts * (sizeof(struct infra_key)+
418 if(!slabhash_is_size(infra->hosts, maxmem, cfg->infra_cache_slabs) ||
419 !slabhash_is_size(infra->domain_rates, cfg->ratelimit_size,
420 cfg->ratelimit_slabs) ||
421 !slabhash_is_size(infra->client_ip_rates, cfg->ip_ratelimit_size,
422 cfg->ip_ratelimit_slabs)) {
427 traverse_postorder(&infra->domain_limits, domain_limit_free,
438 * set use_port to a non-0 number to use the port in
441 hash_addr(struct sockaddr_storage* addr, socklen_t addrlen,
445 /* select the pieces to hash, some OS have changing data inside */
446 if(addr_is_ip6(addr, addrlen)) {
447 struct sockaddr_in6* in6 = (struct sockaddr_in6*)addr;
448 h = hashlittle(&in6->sin6_family, sizeof(in6->sin6_family), h);
450 h = hashlittle(&in6->sin6_port, sizeof(in6->sin6_port), h);
452 h = hashlittle(&in6->sin6_addr, INET6_SIZE, h);
454 struct sockaddr_in* in = (struct sockaddr_in*)addr;
455 h = hashlittle(&in->sin_family, sizeof(in->sin_family), h);
457 h = hashlittle(&in->sin_port, sizeof(in->sin_port), h);
459 h = hashlittle(&in->sin_addr, INET_SIZE, h);
466 hash_infra(struct sockaddr_storage* addr, socklen_t addrlen, uint8_t* name)
468 return dname_query_hash(name, hash_addr(addr, addrlen, 1));
473 infra_lookup_nottl(struct infra_cache* infra, struct sockaddr_storage* addr,
478 memcpy(&k.addr, addr, addrlen);
481 k.entry.hash = hash_infra(addr, addrlen, name);
483 k.entry.data = NULL;
484 return slabhash_lookup(infra->hosts, k.entry.hash, &k, wr);
487 /** init the data elements */
492 struct infra_data* data = (struct infra_data*)e->data;
493 data->ttl = timenow + infra->host_ttl;
494 rtt_init(&data->rtt);
495 data->edns_version = 0;
496 data->edns_lame_known = 0;
497 data->probedelay = 0;
498 data->isdnsseclame = 0;
499 data->rec_lame = 0;
500 data->lame_type_A = 0;
501 data->lame_other = 0;
502 data->timeout_A = 0;
503 data->timeout_AAAA = 0;
504 data->timeout_other = 0;
510 * @param addr: host address.
511 * @param addrlen: length of addr.
518 new_entry(struct infra_cache* infra, struct sockaddr_storage* addr,
521 struct infra_data* data;
525 data = (struct infra_data*)malloc(sizeof(struct infra_data));
526 if(!data) {
530 key->zonename = memdup(name, namelen);
531 if(!key->zonename) {
533 free(data);
536 key->namelen = namelen;
537 lock_rw_init(&key->entry.lock);
538 key->entry.hash = hash_infra(addr, addrlen, name);
539 key->entry.key = (void*)key;
540 key->entry.data = (void*)data;
541 key->addrlen = addrlen;
542 memcpy(&key->addr, addr, addrlen);
543 data_entry_init(infra, &key->entry, tm);
544 return &key->entry;
548 infra_host(struct infra_cache* infra, struct sockaddr_storage* addr,
552 struct lruhash_entry* e = infra_lookup_nottl(infra, addr, addrlen,
554 struct infra_data* data;
556 if(e && ((struct infra_data*)e->data)->ttl < timenow) {
558 int old = ((struct infra_data*)e->data)->rtt.rto;
559 time_t tprobe = ((struct infra_data*)e->data)->probedelay;
560 uint8_t tA = ((struct infra_data*)e->data)->timeout_A;
561 uint8_t tAAAA = ((struct infra_data*)e->data)->timeout_AAAA;
562 uint8_t tother = ((struct infra_data*)e->data)->timeout_other;
563 lock_rw_unlock(&e->lock);
564 e = infra_lookup_nottl(infra, addr, addrlen, nm, nmlen, 1);
567 /* re-initialise */
573 ((struct infra_data*)e->data)->rtt.rto
575 ((struct infra_data*)e->data)->probedelay = tprobe;
576 ((struct infra_data*)e->data)->timeout_A = tA;
577 ((struct infra_data*)e->data)->timeout_AAAA = tAAAA;
578 ((struct infra_data*)e->data)->timeout_other = tother;
584 if(!(e = new_entry(infra, addr, addrlen, nm, nmlen, timenow)))
586 data = (struct infra_data*)e->data;
587 *edns_vs = data->edns_version;
588 *edns_lame_known = data->edns_lame_known;
589 *to = rtt_timeout(&data->rtt);
590 slabhash_insert(infra->hosts, e->hash, e, data, NULL);
594 data = (struct infra_data*)e->data;
595 *edns_vs = data->edns_version;
596 *edns_lame_known = data->edns_lame_known;
597 *to = rtt_timeout(&data->rtt);
598 if(*to >= PROBE_MAXRTO && (infra->infra_keep_probing ||
599 rtt_notimeout(&data->rtt)*4 <= *to)) {
602 lock_rw_unlock(&e->lock);
603 e = infra_lookup_nottl(infra, addr,addrlen,nm,nmlen, 1);
608 data = (struct infra_data*)e->data;
613 data->probedelay = timenow + ((*to)+1999)/1000;
615 lock_rw_unlock(&e->lock);
620 infra_set_lame(struct infra_cache* infra, struct sockaddr_storage* addr,
624 struct infra_data* data;
627 e = infra_lookup_nottl(infra, addr, addrlen, nm, nmlen, 1);
630 if(!(e = new_entry(infra, addr, addrlen, nm, nmlen, timenow))) {
635 } else if( ((struct infra_data*)e->data)->ttl < timenow) {
640 data = (struct infra_data*)e->data;
641 /* merge data (if any) */
643 data->isdnsseclame = 1;
645 data->rec_lame = 1;
647 data->lame_type_A = 1;
649 data->lame_other = 1;
652 slabhash_insert(infra->hosts, e->hash, e, e->data, NULL);
653 else { lock_rw_unlock(&e->lock); }
659 struct sockaddr_storage* addr, socklen_t addrlen, uint8_t* nm,
662 struct lruhash_entry* e = infra_lookup_nottl(infra, addr, addrlen,
664 struct infra_data* data;
667 data = (struct infra_data*)e->data;
668 if(data->rtt.rto >= RTT_MAX_TIMEOUT)
671 data->rtt.rto = STILL_USEFUL_TIMEOUT;
672 lock_rw_unlock(&e->lock);
676 infra_rtt_update(struct infra_cache* infra, struct sockaddr_storage* addr,
680 struct lruhash_entry* e = infra_lookup_nottl(infra, addr, addrlen,
682 struct infra_data* data;
687 if(!(e = new_entry(infra, addr, addrlen, nm, nmlen, timenow)))
690 } else if(((struct infra_data*)e->data)->ttl < timenow) {
691 oldprobedelay = ((struct infra_data*)e->data)->probedelay;
696 data = (struct infra_data*)e->data;
697 if(roundtrip == -1) {
701 data->rtt.rto = orig_rtt;
702 data->probedelay = oldprobedelay;
704 rtt_lost(&data->rtt, orig_rtt);
706 if(data->timeout_A < TIMEOUT_COUNT_MAX)
707 data->timeout_A++;
709 if(data->timeout_AAAA < TIMEOUT_COUNT_MAX)
710 data->timeout_AAAA++;
712 if(data->timeout_other < TIMEOUT_COUNT_MAX)
713 data->timeout_other++;
719 if(rtt_unclamped(&data->rtt) >= USEFUL_SERVER_TOP_TIMEOUT)
720 rtt_init(&data->rtt);
721 rtt_update(&data->rtt, roundtrip);
722 data->probedelay = 0;
724 data->timeout_A = 0;
726 data->timeout_AAAA = 0;
727 else data->timeout_other = 0;
729 if(data->rtt.rto > 0)
730 rto = data->rtt.rto;
733 slabhash_insert(infra->hosts, e->hash, e, e->data, NULL);
734 else { lock_rw_unlock(&e->lock); }
739 struct sockaddr_storage* addr, socklen_t addrlen, uint8_t* nm,
743 struct lruhash_entry* e = infra_lookup_nottl(infra, addr, addrlen,
745 struct infra_data* data;
746 long long ttl = -2;
747 if(!e) return -1;
748 data = (struct infra_data*)e->data;
749 if(data->ttl >= timenow) {
750 ttl = (long long)(data->ttl - timenow);
751 memmove(rtt, &data->rtt, sizeof(*rtt));
752 if(timenow < data->probedelay)
753 *delay = (int)(data->probedelay - timenow);
756 *tA = (int)data->timeout_A;
757 *tAAAA = (int)data->timeout_AAAA;
758 *tother = (int)data->timeout_other;
759 lock_rw_unlock(&e->lock);
764 infra_edns_update(struct infra_cache* infra, struct sockaddr_storage* addr,
768 struct lruhash_entry* e = infra_lookup_nottl(infra, addr, addrlen,
770 struct infra_data* data;
773 if(!(e = new_entry(infra, addr, addrlen, nm, nmlen, timenow)))
776 } else if(((struct infra_data*)e->data)->ttl < timenow) {
780 data = (struct infra_data*)e->data;
782 if(!(edns_version == -1 && (data->edns_version != -1 &&
783 data->edns_lame_known))) {
784 data->edns_version = edns_version;
785 data->edns_lame_known = 1;
789 slabhash_insert(infra->hosts, e->hash, e, e->data, NULL);
790 else { lock_rw_unlock(&e->lock); }
796 struct sockaddr_storage* addr, socklen_t addrlen,
801 struct lruhash_entry* e = infra_lookup_nottl(infra, addr, addrlen,
805 host = (struct infra_data*)e->data;
806 *rtt = rtt_unclamped(&host->rtt);
807 if(host->rtt.rto >= PROBE_MAXRTO && timenow >= host->probedelay
808 && infra->infra_keep_probing) {
812 } else if(host->rtt.rto >= PROBE_MAXRTO && timenow < host->probedelay
813 && rtt_notimeout(&host->rtt)*4 <= host->rtt.rto) {
817 if(host->timeout_A >= TIMEOUT_COUNT_MAX)
821 if(host->timeout_AAAA >= TIMEOUT_COUNT_MAX)
825 if(host->timeout_other >= TIMEOUT_COUNT_MAX)
831 if(timenow > host->ttl) {
832 /* see if this can be a re-probe of an unresponsive server */
833 if(host->rtt.rto >= USEFUL_SERVER_TOP_TIMEOUT) {
834 lock_rw_unlock(&e->lock);
841 lock_rw_unlock(&e->lock);
845 if(host->lame_type_A && qtype == LDNS_RR_TYPE_A) {
846 lock_rw_unlock(&e->lock);
851 } else if(host->lame_other && qtype != LDNS_RR_TYPE_A) {
852 lock_rw_unlock(&e->lock);
857 } else if(host->isdnsseclame) {
858 lock_rw_unlock(&e->lock);
863 } else if(host->rec_lame) {
864 lock_rw_unlock(&e->lock);
871 lock_rw_unlock(&e->lock);
883 name_tree_lookup(&infra->domain_limits, name, namelen, labs,
887 if(d->node.labs == labs && d->lim != -1)
888 return d->lim; /* exact match */
891 if(d->node.labs == labs)
892 d = (struct domain_limit_data*)d->node.parent;
894 if(d->below != -1)
895 return d->below;
896 d = (struct domain_limit_data*)d->node.parent;
905 + lock_get_mem(&key->entry.lock);
912 return sockaddr_cmp_addr(&k1->addr, k1->addrlen,
913 &k2->addr, k2->addrlen);
921 lock_rw_destroy(&key->entry.lock);
925 /** find data item in array, for write access, caller unlocks */
935 return slabhash_lookup(infra->domain_rates, h, &key, wr);
938 /** find data item in array for ip addresses */
940 struct sockaddr_storage* addr, socklen_t addrlen, int wr)
943 hashvalue_type h = hash_addr(addr, addrlen, 0);
945 key.addr = *addr;
948 return slabhash_lookup(infra->client_ip_rates, h, &key, wr);
951 /** create rate data item for name, number 1 in now */
963 k->namelen = namelen;
964 k->name = memdup(name, namelen);
965 if(!k->name) {
970 lock_rw_init(&k->entry.lock);
971 k->entry.hash = h;
972 k->entry.key = k;
973 k->entry.data = d;
974 d->qps[0] = 1;
975 d->timestamp[0] = timenow;
976 slabhash_insert(infra->domain_rates, h, &k->entry, d, NULL);
979 /** create rate data item for ip address */
981 struct sockaddr_storage* addr, socklen_t addrlen, time_t timenow,
984 hashvalue_type h = hash_addr(addr, addrlen, 0);
992 k->addr = *addr;
993 k->addrlen = addrlen;
994 lock_rw_init(&k->entry.lock);
995 k->entry.hash = h;
996 k->entry.key = k;
997 k->entry.data = d;
998 d->qps[0] = 1;
999 d->timestamp[0] = timenow;
1000 d->mesh_wait = mesh_wait;
1001 slabhash_insert(infra->client_ip_rates, h, &k->entry, d, NULL);
1006 static int* infra_rate_find_second_or_none(void* data, time_t t, int should_add)
1008 struct rate_data* d = (struct rate_data*)data;
1011 if(d->timestamp[i] == t)
1012 return &(d->qps[i]);
1018 if(d->timestamp[i] < d->timestamp[oldest])
1021 d->timestamp[oldest] = t;
1022 d->qps[oldest] = 0;
1023 return &(d->qps[oldest]);
1028 static int* infra_rate_give_second(void* data, time_t t)
1030 return infra_rate_find_second_or_none(data, t, 1);
1035 static int* infra_rate_get_second(void* data, time_t t)
1037 return infra_rate_find_second_or_none(data, t, 0);
1040 int infra_rate_max(void* data, time_t now, int backoff)
1042 struct rate_data* d = (struct rate_data*)data;
1046 if(now-d->timestamp[i] <= RATE_WINDOW &&
1047 d->qps[i] > max) {
1048 max = d->qps[i];
1051 if(now == d->timestamp[i]) {
1052 return d->qps[i];
1077 int premax = infra_rate_max(entry->data, timenow, backoff);
1078 int* cur = infra_rate_give_second(entry->data, timenow);
1080 max = infra_rate_max(entry->data, timenow, backoff);
1081 lock_rw_unlock(&entry->lock);
1086 dname_str(qinfo->qname, qnm);
1087 sldns_wire2str_type_buf(qinfo->qtype, ts, sizeof(ts));
1088 sldns_wire2str_class_buf(qinfo->qclass, cs, sizeof(cs));
1091 addr_to_str((struct sockaddr_storage *)&replylist->remote_addr,
1092 replylist->remote_addrlen, ip, sizeof(ip));
1115 cur = infra_rate_get_second(entry->data, timenow);
1118 lock_rw_unlock(&entry->lock);
1122 (*cur)--;
1123 lock_rw_unlock(&entry->lock);
1143 max = infra_rate_max(entry->data, timenow, backoff);
1144 lock_rw_unlock(&entry->lock);
1152 size_t s = sizeof(*infra) + slabhash_get_mem(infra->hosts);
1153 if(infra->domain_rates) s += slabhash_get_mem(infra->domain_rates);
1154 if(infra->client_ip_rates) s += slabhash_get_mem(infra->client_ip_rates);
1161 check_ip_ratelimit(struct sockaddr_storage* addr, socklen_t addrlen,
1174 addr_to_str(addr, addrlen, client_ip, sizeof(client_ip));
1180 sldns_buffer_limit(buffer)-LDNS_HEADER_SIZE,
1182 if(strlen(qnm)>0 && qnm[strlen(qnm)-1]=='\n')
1183 qnm[strlen(qnm)-1] = 0; /*remove newline*/
1201 struct sockaddr_storage* addr, socklen_t addrlen, time_t timenow,
1212 entry = infra_find_ip_ratedata(infra, addr, addrlen, 1);
1214 int premax = infra_rate_max(entry->data, timenow, backoff);
1215 int* cur = infra_rate_give_second(entry->data, timenow);
1217 max = infra_rate_max(entry->data, timenow, backoff);
1218 lock_rw_unlock(&entry->lock);
1219 return check_ip_ratelimit(addr, addrlen, buffer, premax, max,
1224 infra_ip_create_ratedata(infra, addr, addrlen, timenow, 0);
1232 if(cfg->wait_limit == 0)
1235 entry = infra_find_ip_ratedata(infra, &rep->client_addr,
1236 rep->client_addrlen, 0);
1240 struct rate_data* d = (struct rate_data*)entry->data;
1241 int mesh_wait = d->mesh_wait;
1242 lock_rw_unlock(&entry->lock);
1246 tree = &infra->wait_limits_cookie_netblock;
1247 else tree = &infra->wait_limits_netblock;
1249 &rep->client_addr, rep->client_addrlen);
1251 if(w->limit != -1 && mesh_wait > w->limit)
1256 if(mesh_wait > (cookie_valid?cfg->wait_limit_cookie:
1257 cfg->wait_limit))
1268 if(cfg->wait_limit == 0)
1272 entry = infra_find_ip_ratedata(infra, &rep->client_addr,
1273 rep->client_addrlen, 1);
1275 struct rate_data* d = (struct rate_data*)entry->data;
1276 d->mesh_wait++;
1277 lock_rw_unlock(&entry->lock);
1282 infra_ip_create_ratedata(infra, &rep->client_addr,
1283 rep->client_addrlen, timenow, 1);
1290 if(cfg->wait_limit == 0)
1293 entry = infra_find_ip_ratedata(infra, &rep->client_addr,
1294 rep->client_addrlen, 1);
1296 struct rate_data* d = (struct rate_data*)entry->data;
1297 if(d->mesh_wait > 0)
1298 d->mesh_wait--;
1299 lock_rw_unlock(&entry->lock);