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"
70 * infra-cache-max-rtt) change it to just above the RTT_BAND. */
76 USEFUL_SERVER_TOP_TIMEOUT - 1000 <= RTT_BAND
78 :USEFUL_SERVER_TOP_TIMEOUT - 1000;
85 return sizeof(*key) + sizeof(struct infra_data) + key->namelen
86 + lock_get_mem(&key->entry.lock);
94 int r = sockaddr_cmp(&k1->addr, k1->addrlen, &k2->addr, k2->addrlen);
97 if(k1->namelen != k2->namelen) {
98 if(k1->namelen < k2->namelen)
99 return -1;
102 return query_dname_compare(k1->zonename, k2->zonename);
111 lock_rw_destroy(&key->entry.lock);
112 free(key->zonename);
119 struct infra_data* data = (struct infra_data*)d;
120 free(data);
127 return sizeof(*key) + sizeof(struct rate_data) + key->namelen
128 + lock_get_mem(&key->entry.lock);
136 if(k1->namelen != k2->namelen) {
137 if(k1->namelen < k2->namelen)
138 return -1;
141 return query_dname_compare(k1->name, k2->name);
150 lock_rw_destroy(&key->entry.lock);
151 free(key->name);
158 struct rate_data* data = (struct rate_data*)d;
159 free(data);
193 d->node.node.key = &d->node;
194 d->node.name = nm;
195 d->node.len = nmlen;
196 d->node.labs = labs;
197 d->node.dclass = LDNS_RR_CLASS_IN;
198 d->lim = -1;
199 d->below = -1;
200 if(!name_tree_insert(domain_limits, &d->node, nm, nmlen, labs,
216 for(p = cfg->ratelimit_for_domain; p; p = p->next) {
217 d = domain_limit_findcreate(domain_limits, p->str);
220 d->lim = atoi(p->str2);
222 for(p = cfg->ratelimit_below_domain; p; p = p->next) {
223 d = domain_limit_findcreate(domain_limits, p->str);
226 d->below = atoi(p->str2);
246 struct sockaddr_storage addr;
251 if(!netblockstrtoaddr(str, 0, &addr, &addrlen, &net)) {
257 d = (struct wait_limit_netblock_info*)addr_tree_find(tree, &addr,
266 d->limit = -1;
267 if(!addr_tree_insert(tree, &d->node, &addr, addrlen, net)) {
283 for(p = cfg->wait_limit_netblock; p; p = p->next) {
285 p->str);
288 d->limit = atoi(p->str2);
290 for(p = cfg->wait_limit_cookie_netblock; p; p = p->next) {
292 p->str);
295 d->limit = atoi(p->str2);
308 d->limit = limit;
321 /* wait-limit-netblock: 127.0.0.0/8 -1 */
323 -1))
325 /* wait-limit-netblock: ::1/128 -1 */
326 if(!wait_limit_netblock_default(wait_limits_netblock, "::1/128", -1))
328 /* wait-limit-cookie-netblock: 127.0.0.0/8 -1 */
330 "127.0.0.0/8", -1))
332 /* wait-limit-cookie-netblock: ::1/128 -1 */
334 "::1/128", -1))
350 size_t maxmem = cfg->infra_cache_numhosts * (sizeof(struct infra_key)+
355 infra->hosts = slabhash_create(cfg->infra_cache_slabs,
358 if(!infra->hosts) {
362 infra->host_ttl = cfg->host_ttl;
363 infra->infra_keep_probing = cfg->infra_keep_probing;
364 infra_dp_ratelimit = cfg->ratelimit;
365 infra->domain_rates = slabhash_create(cfg->ratelimit_slabs,
366 INFRA_HOST_STARTSIZE, cfg->ratelimit_size,
369 if(!infra->domain_rates) {
373 /* insert config data into ratelimits */
374 if(!setup_domain_limits(&infra->domain_limits, cfg)) {
378 if(!setup_wait_limits(&infra->wait_limits_netblock,
379 &infra->wait_limits_cookie_netblock, cfg)) {
383 infra_ip_ratelimit = cfg->ip_ratelimit;
384 infra_ip_ratelimit_cookie = cfg->ip_ratelimit_cookie;
385 infra->client_ip_rates = slabhash_create(cfg->ip_ratelimit_slabs,
386 INFRA_HOST_STARTSIZE, cfg->ip_ratelimit_size, &ip_rate_sizefunc,
388 if(!infra->client_ip_rates) {
399 free(((struct domain_limit_data*)n)->node.name);
432 slabhash_delete(infra->hosts);
433 slabhash_delete(infra->domain_rates);
434 domain_limits_free(&infra->domain_limits);
435 slabhash_delete(infra->client_ip_rates);
436 wait_limits_free(&infra->wait_limits_netblock);
437 wait_limits_free(&infra->wait_limits_cookie_netblock);
447 infra->host_ttl = cfg->host_ttl;
448 infra->infra_keep_probing = cfg->infra_keep_probing;
449 infra_dp_ratelimit = cfg->ratelimit;
450 infra_ip_ratelimit = cfg->ip_ratelimit;
451 infra_ip_ratelimit_cookie = cfg->ip_ratelimit_cookie;
452 maxmem = cfg->infra_cache_numhosts * (sizeof(struct infra_key)+
457 if(!slabhash_is_size(infra->hosts, maxmem, cfg->infra_cache_slabs) ||
458 !slabhash_is_size(infra->domain_rates, cfg->ratelimit_size,
459 cfg->ratelimit_slabs) ||
460 !slabhash_is_size(infra->client_ip_rates, cfg->ip_ratelimit_size,
461 cfg->ip_ratelimit_slabs)) {
466 traverse_postorder(&infra->domain_limits, domain_limit_free,
468 if(!setup_domain_limits(&infra->domain_limits, cfg)) {
477 * set use_port to a non-0 number to use the port in
480 hash_addr(struct sockaddr_storage* addr, socklen_t addrlen,
484 /* select the pieces to hash, some OS have changing data inside */
485 if(addr_is_ip6(addr, addrlen)) {
486 struct sockaddr_in6* in6 = (struct sockaddr_in6*)addr;
487 h = hashlittle(&in6->sin6_family, sizeof(in6->sin6_family), h);
489 h = hashlittle(&in6->sin6_port, sizeof(in6->sin6_port), h);
491 h = hashlittle(&in6->sin6_addr, INET6_SIZE, h);
493 struct sockaddr_in* in = (struct sockaddr_in*)addr;
494 h = hashlittle(&in->sin_family, sizeof(in->sin_family), h);
496 h = hashlittle(&in->sin_port, sizeof(in->sin_port), h);
498 h = hashlittle(&in->sin_addr, INET_SIZE, h);
505 hash_infra(struct sockaddr_storage* addr, socklen_t addrlen, uint8_t* name)
507 return dname_query_hash(name, hash_addr(addr, addrlen, 1));
512 infra_lookup_nottl(struct infra_cache* infra, struct sockaddr_storage* addr,
517 memcpy(&k.addr, addr, addrlen);
520 k.entry.hash = hash_infra(addr, addrlen, name);
522 k.entry.data = NULL;
523 return slabhash_lookup(infra->hosts, k.entry.hash, &k, wr);
526 /** init the data elements */
531 struct infra_data* data = (struct infra_data*)e->data;
532 data->ttl = timenow + infra->host_ttl;
533 rtt_init(&data->rtt);
534 data->edns_version = 0;
535 data->edns_lame_known = 0;
536 data->probedelay = 0;
537 data->isdnsseclame = 0;
538 data->rec_lame = 0;
539 data->lame_type_A = 0;
540 data->lame_other = 0;
541 data->timeout_A = 0;
542 data->timeout_AAAA = 0;
543 data->timeout_other = 0;
549 * @param addr: host address.
550 * @param addrlen: length of addr.
557 new_entry(struct infra_cache* infra, struct sockaddr_storage* addr,
560 struct infra_data* data;
564 data = (struct infra_data*)malloc(sizeof(struct infra_data));
565 if(!data) {
569 key->zonename = memdup(name, namelen);
570 if(!key->zonename) {
572 free(data);
575 key->namelen = namelen;
576 lock_rw_init(&key->entry.lock);
577 key->entry.hash = hash_infra(addr, addrlen, name);
578 key->entry.key = (void*)key;
579 key->entry.data = (void*)data;
580 key->addrlen = addrlen;
581 memcpy(&key->addr, addr, addrlen);
582 data_entry_init(infra, &key->entry, tm);
583 return &key->entry;
587 infra_host(struct infra_cache* infra, struct sockaddr_storage* addr,
591 struct lruhash_entry* e = infra_lookup_nottl(infra, addr, addrlen,
593 struct infra_data* data;
595 if(e && ((struct infra_data*)e->data)->ttl < timenow) {
597 int old = ((struct infra_data*)e->data)->rtt.rto;
598 time_t tprobe = ((struct infra_data*)e->data)->probedelay;
599 uint8_t tA = ((struct infra_data*)e->data)->timeout_A;
600 uint8_t tAAAA = ((struct infra_data*)e->data)->timeout_AAAA;
601 uint8_t tother = ((struct infra_data*)e->data)->timeout_other;
602 lock_rw_unlock(&e->lock);
603 e = infra_lookup_nottl(infra, addr, addrlen, nm, nmlen, 1);
606 /* re-initialise */
612 ((struct infra_data*)e->data)->rtt.rto
614 ((struct infra_data*)e->data)->probedelay = tprobe;
615 ((struct infra_data*)e->data)->timeout_A = tA;
616 ((struct infra_data*)e->data)->timeout_AAAA = tAAAA;
617 ((struct infra_data*)e->data)->timeout_other = tother;
623 if(!(e = new_entry(infra, addr, addrlen, nm, nmlen, timenow)))
625 data = (struct infra_data*)e->data;
626 *edns_vs = data->edns_version;
627 *edns_lame_known = data->edns_lame_known;
628 *to = rtt_timeout(&data->rtt);
629 slabhash_insert(infra->hosts, e->hash, e, data, NULL);
633 data = (struct infra_data*)e->data;
634 *edns_vs = data->edns_version;
635 *edns_lame_known = data->edns_lame_known;
636 *to = rtt_timeout(&data->rtt);
637 if(*to >= PROBE_MAXRTO && (infra->infra_keep_probing ||
638 rtt_notimeout(&data->rtt)*4 <= *to)) {
641 lock_rw_unlock(&e->lock);
642 e = infra_lookup_nottl(infra, addr,addrlen,nm,nmlen, 1);
647 data = (struct infra_data*)e->data;
652 data->probedelay = timenow + ((*to)+1999)/1000;
654 lock_rw_unlock(&e->lock);
659 infra_set_lame(struct infra_cache* infra, struct sockaddr_storage* addr,
663 struct infra_data* data;
666 e = infra_lookup_nottl(infra, addr, addrlen, nm, nmlen, 1);
669 if(!(e = new_entry(infra, addr, addrlen, nm, nmlen, timenow))) {
674 } else if( ((struct infra_data*)e->data)->ttl < timenow) {
679 data = (struct infra_data*)e->data;
680 /* merge data (if any) */
682 data->isdnsseclame = 1;
684 data->rec_lame = 1;
686 data->lame_type_A = 1;
688 data->lame_other = 1;
691 slabhash_insert(infra->hosts, e->hash, e, e->data, NULL);
692 else { lock_rw_unlock(&e->lock); }
698 struct sockaddr_storage* addr, socklen_t addrlen, uint8_t* nm,
701 struct lruhash_entry* e = infra_lookup_nottl(infra, addr, addrlen,
703 struct infra_data* data;
706 data = (struct infra_data*)e->data;
707 if(data->rtt.rto >= RTT_MAX_TIMEOUT)
710 data->rtt.rto = still_useful_timeout();
711 lock_rw_unlock(&e->lock);
715 infra_rtt_update(struct infra_cache* infra, struct sockaddr_storage* addr,
719 struct lruhash_entry* e = infra_lookup_nottl(infra, addr, addrlen,
721 struct infra_data* data;
726 if(!(e = new_entry(infra, addr, addrlen, nm, nmlen, timenow)))
729 } else if(((struct infra_data*)e->data)->ttl < timenow) {
730 oldprobedelay = ((struct infra_data*)e->data)->probedelay;
735 data = (struct infra_data*)e->data;
736 if(roundtrip == -1) {
740 data->rtt.rto = orig_rtt;
741 data->probedelay = oldprobedelay;
743 rtt_lost(&data->rtt, orig_rtt);
745 if(data->timeout_A < TIMEOUT_COUNT_MAX)
746 data->timeout_A++;
748 if(data->timeout_AAAA < TIMEOUT_COUNT_MAX)
749 data->timeout_AAAA++;
751 if(data->timeout_other < TIMEOUT_COUNT_MAX)
752 data->timeout_other++;
758 if(rtt_unclamped(&data->rtt) >= USEFUL_SERVER_TOP_TIMEOUT)
759 rtt_init(&data->rtt);
760 rtt_update(&data->rtt, roundtrip);
761 data->probedelay = 0;
763 data->timeout_A = 0;
765 data->timeout_AAAA = 0;
766 else data->timeout_other = 0;
768 if(data->rtt.rto > 0)
769 rto = data->rtt.rto;
772 slabhash_insert(infra->hosts, e->hash, e, e->data, NULL);
773 else { lock_rw_unlock(&e->lock); }
778 struct sockaddr_storage* addr, socklen_t addrlen, uint8_t* nm,
782 struct lruhash_entry* e = infra_lookup_nottl(infra, addr, addrlen,
784 struct infra_data* data;
785 long long ttl = -2;
786 if(!e) return -1;
787 data = (struct infra_data*)e->data;
788 if(data->ttl >= timenow) {
789 ttl = (long long)(data->ttl - timenow);
790 memmove(rtt, &data->rtt, sizeof(*rtt));
791 if(timenow < data->probedelay)
792 *delay = (int)(data->probedelay - timenow);
795 *tA = (int)data->timeout_A;
796 *tAAAA = (int)data->timeout_AAAA;
797 *tother = (int)data->timeout_other;
798 lock_rw_unlock(&e->lock);
803 infra_edns_update(struct infra_cache* infra, struct sockaddr_storage* addr,
807 struct lruhash_entry* e = infra_lookup_nottl(infra, addr, addrlen,
809 struct infra_data* data;
812 if(!(e = new_entry(infra, addr, addrlen, nm, nmlen, timenow)))
815 } else if(((struct infra_data*)e->data)->ttl < timenow) {
819 data = (struct infra_data*)e->data;
821 if(!(edns_version == -1 && (data->edns_version != -1 &&
822 data->edns_lame_known))) {
823 data->edns_version = edns_version;
824 data->edns_lame_known = 1;
828 slabhash_insert(infra->hosts, e->hash, e, e->data, NULL);
829 else { lock_rw_unlock(&e->lock); }
835 struct sockaddr_storage* addr, socklen_t addrlen,
840 struct lruhash_entry* e = infra_lookup_nottl(infra, addr, addrlen,
844 host = (struct infra_data*)e->data;
845 *rtt = rtt_unclamped(&host->rtt);
846 if(host->rtt.rto >= PROBE_MAXRTO && timenow >= host->probedelay
847 && infra->infra_keep_probing) {
851 } else if(host->rtt.rto >= PROBE_MAXRTO && timenow < host->probedelay
852 && rtt_notimeout(&host->rtt)*4 <= host->rtt.rto) {
856 if(host->timeout_A >= TIMEOUT_COUNT_MAX)
860 if(host->timeout_AAAA >= TIMEOUT_COUNT_MAX)
864 if(host->timeout_other >= TIMEOUT_COUNT_MAX)
870 if(timenow > host->ttl) {
871 /* see if this can be a re-probe of an unresponsive server */
872 if(host->rtt.rto >= USEFUL_SERVER_TOP_TIMEOUT) {
873 lock_rw_unlock(&e->lock);
880 lock_rw_unlock(&e->lock);
884 if(host->lame_type_A && qtype == LDNS_RR_TYPE_A) {
885 lock_rw_unlock(&e->lock);
890 } else if(host->lame_other && qtype != LDNS_RR_TYPE_A) {
891 lock_rw_unlock(&e->lock);
896 } else if(host->isdnsseclame) {
897 lock_rw_unlock(&e->lock);
902 } else if(host->rec_lame) {
903 lock_rw_unlock(&e->lock);
910 lock_rw_unlock(&e->lock);
922 name_tree_lookup(&infra->domain_limits, name, namelen, labs,
926 if(d->node.labs == labs && d->lim != -1)
927 return d->lim; /* exact match */
930 if(d->node.labs == labs)
931 d = (struct domain_limit_data*)d->node.parent;
933 if(d->below != -1)
934 return d->below;
935 d = (struct domain_limit_data*)d->node.parent;
944 + lock_get_mem(&key->entry.lock);
951 return sockaddr_cmp_addr(&k1->addr, k1->addrlen,
952 &k2->addr, k2->addrlen);
960 lock_rw_destroy(&key->entry.lock);
964 /** find data item in array, for write access, caller unlocks */
974 return slabhash_lookup(infra->domain_rates, h, &key, wr);
977 /** find data item in array for ip addresses */
979 struct sockaddr_storage* addr, socklen_t addrlen, int wr)
982 hashvalue_type h = hash_addr(addr, addrlen, 0);
984 key.addr = *addr;
987 return slabhash_lookup(infra->client_ip_rates, h, &key, wr);
990 /** create rate data item for name, number 1 in now */
1002 k->namelen = namelen;
1003 k->name = memdup(name, namelen);
1004 if(!k->name) {
1009 lock_rw_init(&k->entry.lock);
1010 k->entry.hash = h;
1011 k->entry.key = k;
1012 k->entry.data = d;
1013 d->qps[0] = 1;
1014 d->timestamp[0] = timenow;
1015 slabhash_insert(infra->domain_rates, h, &k->entry, d, NULL);
1018 /** create rate data item for ip address */
1020 struct sockaddr_storage* addr, socklen_t addrlen, time_t timenow,
1023 hashvalue_type h = hash_addr(addr, addrlen, 0);
1031 k->addr = *addr;
1032 k->addrlen = addrlen;
1033 lock_rw_init(&k->entry.lock);
1034 k->entry.hash = h;
1035 k->entry.key = k;
1036 k->entry.data = d;
1037 d->qps[0] = 1;
1038 d->timestamp[0] = timenow;
1039 d->mesh_wait = mesh_wait;
1040 slabhash_insert(infra->client_ip_rates, h, &k->entry, d, NULL);
1045 static int* infra_rate_find_second_or_none(void* data, time_t t, int should_add)
1047 struct rate_data* d = (struct rate_data*)data;
1050 if(d->timestamp[i] == t)
1051 return &(d->qps[i]);
1057 if(d->timestamp[i] < d->timestamp[oldest])
1060 d->timestamp[oldest] = t;
1061 d->qps[oldest] = 0;
1062 return &(d->qps[oldest]);
1067 static int* infra_rate_give_second(void* data, time_t t)
1069 return infra_rate_find_second_or_none(data, t, 1);
1074 static int* infra_rate_get_second(void* data, time_t t)
1076 return infra_rate_find_second_or_none(data, t, 0);
1079 int infra_rate_max(void* data, time_t now, int backoff)
1081 struct rate_data* d = (struct rate_data*)data;
1085 if(now-d->timestamp[i] <= RATE_WINDOW &&
1086 d->qps[i] > max) {
1087 max = d->qps[i];
1090 if(now == d->timestamp[i]) {
1091 return d->qps[i];
1116 int premax = infra_rate_max(entry->data, timenow, backoff);
1117 int* cur = infra_rate_give_second(entry->data, timenow);
1119 max = infra_rate_max(entry->data, timenow, backoff);
1120 lock_rw_unlock(&entry->lock);
1126 dname_str(qinfo->qname, qnm);
1127 sldns_wire2str_type_buf(qinfo->qtype, ts, sizeof(ts));
1128 sldns_wire2str_class_buf(qinfo->qclass, cs, sizeof(cs));
1131 addr_to_str((struct sockaddr_storage *)&replylist->remote_addr,
1132 replylist->remote_addrlen, ip, sizeof(ip));
1155 cur = infra_rate_get_second(entry->data, timenow);
1158 lock_rw_unlock(&entry->lock);
1162 (*cur)--;
1163 lock_rw_unlock(&entry->lock);
1183 max = infra_rate_max(entry->data, timenow, backoff);
1184 lock_rw_unlock(&entry->lock);
1192 size_t s = sizeof(*infra) + slabhash_get_mem(infra->hosts);
1193 if(infra->domain_rates) s += slabhash_get_mem(infra->domain_rates);
1194 if(infra->client_ip_rates) s += slabhash_get_mem(infra->client_ip_rates);
1201 check_ip_ratelimit(struct sockaddr_storage* addr, socklen_t addrlen,
1214 addr_to_str(addr, addrlen, client_ip, sizeof(client_ip));
1220 sldns_buffer_limit(buffer)-LDNS_HEADER_SIZE,
1222 if(strlen(qnm)>0 && qnm[strlen(qnm)-1]=='\n')
1223 qnm[strlen(qnm)-1] = 0; /*remove newline*/
1241 struct sockaddr_storage* addr, socklen_t addrlen, time_t timenow,
1252 entry = infra_find_ip_ratedata(infra, addr, addrlen, 1);
1254 int premax = infra_rate_max(entry->data, timenow, backoff);
1255 int* cur = infra_rate_give_second(entry->data, timenow);
1257 max = infra_rate_max(entry->data, timenow, backoff);
1258 lock_rw_unlock(&entry->lock);
1259 return check_ip_ratelimit(addr, addrlen, buffer, premax, max,
1264 infra_ip_create_ratedata(infra, addr, addrlen, timenow, 0);
1272 if(cfg->wait_limit == 0)
1275 entry = infra_find_ip_ratedata(infra, &rep->client_addr,
1276 rep->client_addrlen, 0);
1280 struct rate_data* d = (struct rate_data*)entry->data;
1281 int mesh_wait = d->mesh_wait;
1282 lock_rw_unlock(&entry->lock);
1286 tree = &infra->wait_limits_cookie_netblock;
1287 else tree = &infra->wait_limits_netblock;
1289 &rep->client_addr, rep->client_addrlen);
1291 if(w->limit != -1 && mesh_wait > w->limit)
1296 if(mesh_wait > (cookie_valid?cfg->wait_limit_cookie:
1297 cfg->wait_limit))
1308 if(cfg->wait_limit == 0)
1312 entry = infra_find_ip_ratedata(infra, &rep->client_addr,
1313 rep->client_addrlen, 1);
1315 struct rate_data* d = (struct rate_data*)entry->data;
1316 d->mesh_wait++;
1317 lock_rw_unlock(&entry->lock);
1322 infra_ip_create_ratedata(infra, &rep->client_addr,
1323 rep->client_addrlen, timenow, 1);
1330 if(cfg->wait_limit == 0)
1333 entry = infra_find_ip_ratedata(infra, &rep->client_addr,
1334 rep->client_addrlen, 1);
1336 struct rate_data* d = (struct rate_data*)entry->data;
1337 if(d->mesh_wait > 0)
1338 d->mesh_wait--;
1339 lock_rw_unlock(&entry->lock);