Deleted Added
sdiff udiff text old ( 266114 ) new ( 276605 )
full compact
worker.c (266114) worker.c (276605)
1/*
2 * daemon/worker.c - worker that handles a pending list of requests.
3 *
4 * Copyright (c) 2007, NLnet Labs. All rights reserved.
5 *
6 * This software is open source.
7 *
8 * Redistribution and use in source and binary forms, with or without

--- 763 unchanged lines hidden (view full) ---

772{
773 struct worker* worker = (struct worker*)arg;
774 int ret;
775 hashvalue_t h;
776 struct lruhash_entry* e;
777 struct query_info qinfo;
778 struct edns_data edns;
779 enum acl_access acl;
1/*
2 * daemon/worker.c - worker that handles a pending list of requests.
3 *
4 * Copyright (c) 2007, NLnet Labs. All rights reserved.
5 *
6 * This software is open source.
7 *
8 * Redistribution and use in source and binary forms, with or without

--- 763 unchanged lines hidden (view full) ---

772{
773 struct worker* worker = (struct worker*)arg;
774 int ret;
775 hashvalue_t h;
776 struct lruhash_entry* e;
777 struct query_info qinfo;
778 struct edns_data edns;
779 enum acl_access acl;
780 int rc = 0;
780
781 if(error != NETEVENT_NOERROR) {
782 /* some bad tcp query DNS formats give these error calls */
783 verbose(VERB_ALGO, "handle request called with err=%d", error);
784 return 0;
785 }
781
782 if(error != NETEVENT_NOERROR) {
783 /* some bad tcp query DNS formats give these error calls */
784 verbose(VERB_ALGO, "handle request called with err=%d", error);
785 return 0;
786 }
787#ifdef USE_DNSTAP
788 if(worker->dtenv.log_client_query_messages)
789 dt_msg_send_client_query(&worker->dtenv, &repinfo->addr, c->type,
790 c->buffer);
791#endif
786 acl = acl_list_lookup(worker->daemon->acl, &repinfo->addr,
787 repinfo->addrlen);
788 if((ret=deny_refuse_all(c, acl, worker, repinfo)) != -1)
789 {
792 acl = acl_list_lookup(worker->daemon->acl, &repinfo->addr,
793 repinfo->addrlen);
794 if((ret=deny_refuse_all(c, acl, worker, repinfo)) != -1)
795 {
796 if(ret == 1)
797 goto send_reply;
790 return ret;
791 }
792 if((ret=worker_check_request(c->buffer, worker)) != 0) {
793 verbose(VERB_ALGO, "worker check request: bad query.");
794 log_addr(VERB_CLIENT,"from",&repinfo->addr, repinfo->addrlen);
795 if(ret != -1) {
796 LDNS_QR_SET(sldns_buffer_begin(c->buffer));
797 LDNS_RCODE_SET(sldns_buffer_begin(c->buffer), ret);

--- 7 unchanged lines hidden (view full) ---

805 if(!query_info_parse(&qinfo, c->buffer)) {
806 verbose(VERB_ALGO, "worker parse request: formerror.");
807 log_addr(VERB_CLIENT,"from",&repinfo->addr, repinfo->addrlen);
808 sldns_buffer_rewind(c->buffer);
809 LDNS_QR_SET(sldns_buffer_begin(c->buffer));
810 LDNS_RCODE_SET(sldns_buffer_begin(c->buffer),
811 LDNS_RCODE_FORMERR);
812 server_stats_insrcode(&worker->stats, c->buffer);
798 return ret;
799 }
800 if((ret=worker_check_request(c->buffer, worker)) != 0) {
801 verbose(VERB_ALGO, "worker check request: bad query.");
802 log_addr(VERB_CLIENT,"from",&repinfo->addr, repinfo->addrlen);
803 if(ret != -1) {
804 LDNS_QR_SET(sldns_buffer_begin(c->buffer));
805 LDNS_RCODE_SET(sldns_buffer_begin(c->buffer), ret);

--- 7 unchanged lines hidden (view full) ---

813 if(!query_info_parse(&qinfo, c->buffer)) {
814 verbose(VERB_ALGO, "worker parse request: formerror.");
815 log_addr(VERB_CLIENT,"from",&repinfo->addr, repinfo->addrlen);
816 sldns_buffer_rewind(c->buffer);
817 LDNS_QR_SET(sldns_buffer_begin(c->buffer));
818 LDNS_RCODE_SET(sldns_buffer_begin(c->buffer),
819 LDNS_RCODE_FORMERR);
820 server_stats_insrcode(&worker->stats, c->buffer);
813 return 1;
821 goto send_reply;
814 }
815 if(worker->env.cfg->log_queries) {
816 char ip[128];
817 addr_to_str(&repinfo->addr, repinfo->addrlen, ip, sizeof(ip));
818 log_nametypeclass(0, ip, qinfo.qname, qinfo.qtype, qinfo.qclass);
819 }
820 if(qinfo.qtype == LDNS_RR_TYPE_AXFR ||
821 qinfo.qtype == LDNS_RR_TYPE_IXFR) {
822 verbose(VERB_ALGO, "worker request: refused zone transfer.");
823 log_addr(VERB_CLIENT,"from",&repinfo->addr, repinfo->addrlen);
824 sldns_buffer_rewind(c->buffer);
825 LDNS_QR_SET(sldns_buffer_begin(c->buffer));
826 LDNS_RCODE_SET(sldns_buffer_begin(c->buffer),
827 LDNS_RCODE_REFUSED);
828 if(worker->stats.extended) {
829 worker->stats.qtype[qinfo.qtype]++;
830 server_stats_insrcode(&worker->stats, c->buffer);
831 }
822 }
823 if(worker->env.cfg->log_queries) {
824 char ip[128];
825 addr_to_str(&repinfo->addr, repinfo->addrlen, ip, sizeof(ip));
826 log_nametypeclass(0, ip, qinfo.qname, qinfo.qtype, qinfo.qclass);
827 }
828 if(qinfo.qtype == LDNS_RR_TYPE_AXFR ||
829 qinfo.qtype == LDNS_RR_TYPE_IXFR) {
830 verbose(VERB_ALGO, "worker request: refused zone transfer.");
831 log_addr(VERB_CLIENT,"from",&repinfo->addr, repinfo->addrlen);
832 sldns_buffer_rewind(c->buffer);
833 LDNS_QR_SET(sldns_buffer_begin(c->buffer));
834 LDNS_RCODE_SET(sldns_buffer_begin(c->buffer),
835 LDNS_RCODE_REFUSED);
836 if(worker->stats.extended) {
837 worker->stats.qtype[qinfo.qtype]++;
838 server_stats_insrcode(&worker->stats, c->buffer);
839 }
832 return 1;
840 goto send_reply;
833 }
834 if((ret=parse_edns_from_pkt(c->buffer, &edns)) != 0) {
835 verbose(VERB_ALGO, "worker parse edns: formerror.");
836 log_addr(VERB_CLIENT,"from",&repinfo->addr, repinfo->addrlen);
837 sldns_buffer_rewind(c->buffer);
838 LDNS_QR_SET(sldns_buffer_begin(c->buffer));
839 LDNS_RCODE_SET(sldns_buffer_begin(c->buffer), ret);
840 server_stats_insrcode(&worker->stats, c->buffer);
841 }
842 if((ret=parse_edns_from_pkt(c->buffer, &edns)) != 0) {
843 verbose(VERB_ALGO, "worker parse edns: formerror.");
844 log_addr(VERB_CLIENT,"from",&repinfo->addr, repinfo->addrlen);
845 sldns_buffer_rewind(c->buffer);
846 LDNS_QR_SET(sldns_buffer_begin(c->buffer));
847 LDNS_RCODE_SET(sldns_buffer_begin(c->buffer), ret);
848 server_stats_insrcode(&worker->stats, c->buffer);
841 return 1;
849 goto send_reply;
842 }
843 if(edns.edns_present && edns.edns_version != 0) {
844 edns.ext_rcode = (uint8_t)(EDNS_RCODE_BADVERS>>4);
845 edns.edns_version = EDNS_ADVERTISED_VERSION;
846 edns.udp_size = EDNS_ADVERTISED_SIZE;
847 edns.bits &= EDNS_DO;
848 verbose(VERB_ALGO, "query with bad edns version.");
849 log_addr(VERB_CLIENT,"from",&repinfo->addr, repinfo->addrlen);
850 error_encode(c->buffer, EDNS_RCODE_BADVERS&0xf, &qinfo,
850 }
851 if(edns.edns_present && edns.edns_version != 0) {
852 edns.ext_rcode = (uint8_t)(EDNS_RCODE_BADVERS>>4);
853 edns.edns_version = EDNS_ADVERTISED_VERSION;
854 edns.udp_size = EDNS_ADVERTISED_SIZE;
855 edns.bits &= EDNS_DO;
856 verbose(VERB_ALGO, "query with bad edns version.");
857 log_addr(VERB_CLIENT,"from",&repinfo->addr, repinfo->addrlen);
858 error_encode(c->buffer, EDNS_RCODE_BADVERS&0xf, &qinfo,
851 *(uint16_t*)(void *)sldns_buffer_begin(c->buffer),
859 *(uint16_t*)(void *)sldns_buffer_begin(c->buffer),
852 sldns_buffer_read_u16_at(c->buffer, 2), NULL);
853 attach_edns_record(c->buffer, &edns);
860 sldns_buffer_read_u16_at(c->buffer, 2), NULL);
861 attach_edns_record(c->buffer, &edns);
854 return 1;
862 goto send_reply;
855 }
856 if(edns.edns_present && edns.udp_size < NORMAL_UDP_SIZE &&
857 worker->daemon->cfg->harden_short_bufsize) {
858 verbose(VERB_QUERY, "worker request: EDNS bufsize %d ignored",
859 (int)edns.udp_size);
860 log_addr(VERB_CLIENT,"from",&repinfo->addr, repinfo->addrlen);
861 edns.udp_size = NORMAL_UDP_SIZE;
862 }

--- 11 unchanged lines hidden (view full) ---

874 LDNS_QR_SET(sldns_buffer_begin(c->buffer));
875 LDNS_TC_SET(sldns_buffer_begin(c->buffer));
876 LDNS_RCODE_SET(sldns_buffer_begin(c->buffer),
877 LDNS_RCODE_SERVFAIL);
878 sldns_buffer_set_position(c->buffer, LDNS_HEADER_SIZE);
879 sldns_buffer_write_at(c->buffer, 4,
880 (uint8_t*)"\0\0\0\0\0\0\0\0", 8);
881 sldns_buffer_flip(c->buffer);
863 }
864 if(edns.edns_present && edns.udp_size < NORMAL_UDP_SIZE &&
865 worker->daemon->cfg->harden_short_bufsize) {
866 verbose(VERB_QUERY, "worker request: EDNS bufsize %d ignored",
867 (int)edns.udp_size);
868 log_addr(VERB_CLIENT,"from",&repinfo->addr, repinfo->addrlen);
869 edns.udp_size = NORMAL_UDP_SIZE;
870 }

--- 11 unchanged lines hidden (view full) ---

882 LDNS_QR_SET(sldns_buffer_begin(c->buffer));
883 LDNS_TC_SET(sldns_buffer_begin(c->buffer));
884 LDNS_RCODE_SET(sldns_buffer_begin(c->buffer),
885 LDNS_RCODE_SERVFAIL);
886 sldns_buffer_set_position(c->buffer, LDNS_HEADER_SIZE);
887 sldns_buffer_write_at(c->buffer, 4,
888 (uint8_t*)"\0\0\0\0\0\0\0\0", 8);
889 sldns_buffer_flip(c->buffer);
882 return 1;
890 goto send_reply;
883 }
884 if(worker->stats.extended)
885 server_stats_insquery(&worker->stats, c, qinfo.qtype,
886 qinfo.qclass, &edns, repinfo);
887 if(c->type != comm_udp)
888 edns.udp_size = 65535; /* max size for TCP replies */
889 if(qinfo.qclass == LDNS_RR_CLASS_CH && answer_chaos(worker, &qinfo,
890 &edns, c->buffer)) {
891 server_stats_insrcode(&worker->stats, c->buffer);
891 }
892 if(worker->stats.extended)
893 server_stats_insquery(&worker->stats, c, qinfo.qtype,
894 qinfo.qclass, &edns, repinfo);
895 if(c->type != comm_udp)
896 edns.udp_size = 65535; /* max size for TCP replies */
897 if(qinfo.qclass == LDNS_RR_CLASS_CH && answer_chaos(worker, &qinfo,
898 &edns, c->buffer)) {
899 server_stats_insrcode(&worker->stats, c->buffer);
892 return 1;
900 goto send_reply;
893 }
894 if(local_zones_answer(worker->daemon->local_zones, &qinfo, &edns,
895 c->buffer, worker->scratchpad)) {
896 regional_free_all(worker->scratchpad);
897 if(sldns_buffer_limit(c->buffer) == 0) {
898 comm_point_drop_reply(repinfo);
899 return 0;
900 }
901 server_stats_insrcode(&worker->stats, c->buffer);
901 }
902 if(local_zones_answer(worker->daemon->local_zones, &qinfo, &edns,
903 c->buffer, worker->scratchpad)) {
904 regional_free_all(worker->scratchpad);
905 if(sldns_buffer_limit(c->buffer) == 0) {
906 comm_point_drop_reply(repinfo);
907 return 0;
908 }
909 server_stats_insrcode(&worker->stats, c->buffer);
902 return 1;
910 goto send_reply;
903 }
904
905 /* We've looked in our local zones. If the answer isn't there, we
906 * might need to bail out based on ACLs now. */
907 if((ret=deny_refuse_non_local(c, acl, worker, repinfo)) != -1)
908 {
911 }
912
913 /* We've looked in our local zones. If the answer isn't there, we
914 * might need to bail out based on ACLs now. */
915 if((ret=deny_refuse_non_local(c, acl, worker, repinfo)) != -1)
916 {
917 if(ret == 1)
918 goto send_reply;
909 return ret;
910 }
911
912 /* If this request does not have the recursion bit set, verify
913 * ACLs allow the snooping. */
914 if(!(LDNS_RD_WIRE(sldns_buffer_begin(c->buffer))) &&
915 acl != acl_allow_snoop ) {
916 sldns_buffer_set_limit(c->buffer, LDNS_HEADER_SIZE);
917 sldns_buffer_write_at(c->buffer, 4,
918 (uint8_t*)"\0\0\0\0\0\0\0\0", 8);
919 LDNS_QR_SET(sldns_buffer_begin(c->buffer));
920 LDNS_RCODE_SET(sldns_buffer_begin(c->buffer),
921 LDNS_RCODE_REFUSED);
922 sldns_buffer_flip(c->buffer);
923 server_stats_insrcode(&worker->stats, c->buffer);
924 log_addr(VERB_ALGO, "refused nonrec (cache snoop) query from",
925 &repinfo->addr, repinfo->addrlen);
919 return ret;
920 }
921
922 /* If this request does not have the recursion bit set, verify
923 * ACLs allow the snooping. */
924 if(!(LDNS_RD_WIRE(sldns_buffer_begin(c->buffer))) &&
925 acl != acl_allow_snoop ) {
926 sldns_buffer_set_limit(c->buffer, LDNS_HEADER_SIZE);
927 sldns_buffer_write_at(c->buffer, 4,
928 (uint8_t*)"\0\0\0\0\0\0\0\0", 8);
929 LDNS_QR_SET(sldns_buffer_begin(c->buffer));
930 LDNS_RCODE_SET(sldns_buffer_begin(c->buffer),
931 LDNS_RCODE_REFUSED);
932 sldns_buffer_flip(c->buffer);
933 server_stats_insrcode(&worker->stats, c->buffer);
934 log_addr(VERB_ALGO, "refused nonrec (cache snoop) query from",
935 &repinfo->addr, repinfo->addrlen);
926 return 1;
936 goto send_reply;
927 }
937 }
928 h = query_info_hash(&qinfo);
938 h = query_info_hash(&qinfo, sldns_buffer_read_u16_at(c->buffer, 2));
929 if((e=slabhash_lookup(worker->env.msg_cache, h, &qinfo, 0))) {
930 /* answer from cache - we have acquired a readlock on it */
931 if(answer_from_cache(worker, &qinfo,
932 (struct reply_info*)e->data,
933 *(uint16_t*)(void *)sldns_buffer_begin(c->buffer),
934 sldns_buffer_read_u16_at(c->buffer, 2), repinfo,
935 &edns)) {
936 /* prefetch it if the prefetch TTL expired */
937 if(worker->env.cfg->prefetch && *worker->env.now >=
938 ((struct reply_info*)e->data)->prefetch_ttl) {
939 time_t leeway = ((struct reply_info*)e->
940 data)->ttl - *worker->env.now;
941 lock_rw_unlock(&e->lock);
942 reply_and_prefetch(worker, &qinfo,
943 sldns_buffer_read_u16_at(c->buffer, 2),
944 repinfo, leeway);
939 if((e=slabhash_lookup(worker->env.msg_cache, h, &qinfo, 0))) {
940 /* answer from cache - we have acquired a readlock on it */
941 if(answer_from_cache(worker, &qinfo,
942 (struct reply_info*)e->data,
943 *(uint16_t*)(void *)sldns_buffer_begin(c->buffer),
944 sldns_buffer_read_u16_at(c->buffer, 2), repinfo,
945 &edns)) {
946 /* prefetch it if the prefetch TTL expired */
947 if(worker->env.cfg->prefetch && *worker->env.now >=
948 ((struct reply_info*)e->data)->prefetch_ttl) {
949 time_t leeway = ((struct reply_info*)e->
950 data)->ttl - *worker->env.now;
951 lock_rw_unlock(&e->lock);
952 reply_and_prefetch(worker, &qinfo,
953 sldns_buffer_read_u16_at(c->buffer, 2),
954 repinfo, leeway);
945 return 0;
955 rc = 0;
956 goto send_reply_rc;
946 }
947 lock_rw_unlock(&e->lock);
957 }
958 lock_rw_unlock(&e->lock);
948 return 1;
959 goto send_reply;
949 }
950 verbose(VERB_ALGO, "answer from the cache failed");
951 lock_rw_unlock(&e->lock);
952 }
953 if(!LDNS_RD_WIRE(sldns_buffer_begin(c->buffer))) {
954 if(answer_norec_from_cache(worker, &qinfo,
955 *(uint16_t*)(void *)sldns_buffer_begin(c->buffer),
956 sldns_buffer_read_u16_at(c->buffer, 2), repinfo,
957 &edns)) {
960 }
961 verbose(VERB_ALGO, "answer from the cache failed");
962 lock_rw_unlock(&e->lock);
963 }
964 if(!LDNS_RD_WIRE(sldns_buffer_begin(c->buffer))) {
965 if(answer_norec_from_cache(worker, &qinfo,
966 *(uint16_t*)(void *)sldns_buffer_begin(c->buffer),
967 sldns_buffer_read_u16_at(c->buffer, 2), repinfo,
968 &edns)) {
958 return 1;
969 goto send_reply;
959 }
960 verbose(VERB_ALGO, "answer norec from cache -- "
961 "need to validate or not primed");
962 }
963 sldns_buffer_rewind(c->buffer);
964 server_stats_querymiss(&worker->stats, worker);
965
966 if(verbosity >= VERB_CLIENT) {
967 if(c->type == comm_udp)
968 log_addr(VERB_CLIENT, "udp request from",
969 &repinfo->addr, repinfo->addrlen);
970 else log_addr(VERB_CLIENT, "tcp request from",
971 &repinfo->addr, repinfo->addrlen);
972 }
973
974 /* grab a work request structure for this new request */
975 mesh_new_client(worker->env.mesh, &qinfo,
976 sldns_buffer_read_u16_at(c->buffer, 2),
970 }
971 verbose(VERB_ALGO, "answer norec from cache -- "
972 "need to validate or not primed");
973 }
974 sldns_buffer_rewind(c->buffer);
975 server_stats_querymiss(&worker->stats, worker);
976
977 if(verbosity >= VERB_CLIENT) {
978 if(c->type == comm_udp)
979 log_addr(VERB_CLIENT, "udp request from",
980 &repinfo->addr, repinfo->addrlen);
981 else log_addr(VERB_CLIENT, "tcp request from",
982 &repinfo->addr, repinfo->addrlen);
983 }
984
985 /* grab a work request structure for this new request */
986 mesh_new_client(worker->env.mesh, &qinfo,
987 sldns_buffer_read_u16_at(c->buffer, 2),
977 &edns, repinfo, *(uint16_t*)(void *)sldns_buffer_begin(c->buffer));
988 &edns, repinfo, *(uint16_t*)(void *)sldns_buffer_begin(c->buffer));
978 worker_mem_report(worker, NULL);
979 return 0;
989 worker_mem_report(worker, NULL);
990 return 0;
991
992send_reply:
993 rc = 1;
994send_reply_rc:
995#ifdef USE_DNSTAP
996 if(worker->dtenv.log_client_response_messages)
997 dt_msg_send_client_response(&worker->dtenv, &repinfo->addr,
998 c->type, c->buffer);
999#endif
1000 return rc;
980}
981
982void
983worker_sighandler(int sig, void* arg)
984{
1001}
1002
1003void
1004worker_sighandler(int sig, void* arg)
1005{
985 /* note that log, print, syscalls here give race conditions. */
986 /* we still print DETAIL logs, because this is extensive per message
987 * logging anyway, and the operator may then have an interest
988 * in the cause for unbound to exit */
1006 /* note that log, print, syscalls here give race conditions.
1007 * And cause hangups if the log-lock is held by the application. */
989 struct worker* worker = (struct worker*)arg;
990 switch(sig) {
991#ifdef SIGHUP
992 case SIGHUP:
1008 struct worker* worker = (struct worker*)arg;
1009 switch(sig) {
1010#ifdef SIGHUP
1011 case SIGHUP:
993 verbose(VERB_QUERY, "caught signal SIGHUP");
994 comm_base_exit(worker->base);
995 break;
996#endif
997 case SIGINT:
1012 comm_base_exit(worker->base);
1013 break;
1014#endif
1015 case SIGINT:
998 verbose(VERB_QUERY, "caught signal SIGINT");
999 worker->need_to_exit = 1;
1000 comm_base_exit(worker->base);
1001 break;
1002#ifdef SIGQUIT
1003 case SIGQUIT:
1016 worker->need_to_exit = 1;
1017 comm_base_exit(worker->base);
1018 break;
1019#ifdef SIGQUIT
1020 case SIGQUIT:
1004 verbose(VERB_QUERY, "caught signal SIGQUIT");
1005 worker->need_to_exit = 1;
1006 comm_base_exit(worker->base);
1007 break;
1008#endif
1009 case SIGTERM:
1021 worker->need_to_exit = 1;
1022 comm_base_exit(worker->base);
1023 break;
1024#endif
1025 case SIGTERM:
1010 verbose(VERB_QUERY, "caught signal SIGTERM");
1011 worker->need_to_exit = 1;
1012 comm_base_exit(worker->base);
1013 break;
1014 default:
1026 worker->need_to_exit = 1;
1027 comm_base_exit(worker->base);
1028 break;
1029 default:
1015 log_err("unknown signal: %d, ignored", sig);
1030 /* unknown signal, ignored */
1016 break;
1017 }
1018}
1019
1020/** restart statistics timer for worker, if enabled */
1021static void
1022worker_restart_timer(struct worker* worker)
1023{

--- 61 unchanged lines hidden (view full) ---

1085 seed = 0;
1086 log_err("could not init random numbers.");
1087 tube_delete(worker->cmd);
1088 free(worker->ports);
1089 free(worker);
1090 return NULL;
1091 }
1092 seed = 0;
1031 break;
1032 }
1033}
1034
1035/** restart statistics timer for worker, if enabled */
1036static void
1037worker_restart_timer(struct worker* worker)
1038{

--- 61 unchanged lines hidden (view full) ---

1100 seed = 0;
1101 log_err("could not init random numbers.");
1102 tube_delete(worker->cmd);
1103 free(worker->ports);
1104 free(worker);
1105 return NULL;
1106 }
1107 seed = 0;
1108#ifdef USE_DNSTAP
1109 if(daemon->cfg->dnstap) {
1110 log_assert(daemon->dtenv != NULL);
1111 memcpy(&worker->dtenv, daemon->dtenv, sizeof(struct dt_env));
1112 if(!dt_init(&worker->dtenv))
1113 fatal_exit("dt_init failed");
1114 }
1115#endif
1093 return worker;
1094}
1095
1096int
1097worker_init(struct worker* worker, struct config_file *cfg,
1098 struct listen_port* ports, int do_sigs)
1099{
1116 return worker;
1117}
1118
1119int
1120worker_init(struct worker* worker, struct config_file *cfg,
1121 struct listen_port* ports, int do_sigs)
1122{
1123#ifdef USE_DNSTAP
1124 struct dt_env* dtenv = &worker->dtenv;
1125#else
1126 void* dtenv = NULL;
1127#endif
1100 worker->need_to_exit = 0;
1101 worker->base = comm_base_create(do_sigs);
1102 if(!worker->base) {
1103 log_err("could not create event handling base");
1104 worker_delete(worker);
1105 return 0;
1106 }
1107 comm_base_set_slow_accept_handlers(worker->base, &worker_stop_accept,

--- 32 unchanged lines hidden (view full) ---

1140#ifdef UB_ON_WINDOWS
1141 wsvc_setup_worker(worker);
1142#endif /* UB_ON_WINDOWS */
1143 } else { /* !do_sigs */
1144 worker->comsig = NULL;
1145 }
1146 worker->front = listen_create(worker->base, ports,
1147 cfg->msg_buffer_size, (int)cfg->incoming_num_tcp,
1128 worker->need_to_exit = 0;
1129 worker->base = comm_base_create(do_sigs);
1130 if(!worker->base) {
1131 log_err("could not create event handling base");
1132 worker_delete(worker);
1133 return 0;
1134 }
1135 comm_base_set_slow_accept_handlers(worker->base, &worker_stop_accept,

--- 32 unchanged lines hidden (view full) ---

1168#ifdef UB_ON_WINDOWS
1169 wsvc_setup_worker(worker);
1170#endif /* UB_ON_WINDOWS */
1171 } else { /* !do_sigs */
1172 worker->comsig = NULL;
1173 }
1174 worker->front = listen_create(worker->base, ports,
1175 cfg->msg_buffer_size, (int)cfg->incoming_num_tcp,
1148 worker->daemon->listen_sslctx, worker_handle_request, worker);
1176 worker->daemon->listen_sslctx, dtenv, worker_handle_request,
1177 worker);
1149 if(!worker->front) {
1150 log_err("could not create listening sockets");
1151 worker_delete(worker);
1152 return 0;
1153 }
1154 worker->back = outside_network_create(worker->base,
1155 cfg->msg_buffer_size, (size_t)cfg->outgoing_num_ports,
1156 cfg->out_ifs, cfg->num_out_ifs, cfg->do_ip4, cfg->do_ip6,
1157 cfg->do_tcp?cfg->outgoing_num_tcp:0,
1158 worker->daemon->env->infra_cache, worker->rndstate,
1159 cfg->use_caps_bits_for_id, worker->ports, worker->numports,
1160 cfg->unwanted_threshold, &worker_alloc_cleanup, worker,
1178 if(!worker->front) {
1179 log_err("could not create listening sockets");
1180 worker_delete(worker);
1181 return 0;
1182 }
1183 worker->back = outside_network_create(worker->base,
1184 cfg->msg_buffer_size, (size_t)cfg->outgoing_num_ports,
1185 cfg->out_ifs, cfg->num_out_ifs, cfg->do_ip4, cfg->do_ip6,
1186 cfg->do_tcp?cfg->outgoing_num_tcp:0,
1187 worker->daemon->env->infra_cache, worker->rndstate,
1188 cfg->use_caps_bits_for_id, worker->ports, worker->numports,
1189 cfg->unwanted_threshold, &worker_alloc_cleanup, worker,
1161 cfg->do_udp, worker->daemon->connect_sslctx, cfg->delay_close);
1190 cfg->do_udp, worker->daemon->connect_sslctx, cfg->delay_close,
1191 dtenv);
1162 if(!worker->back) {
1163 log_err("could not create outgoing sockets");
1164 worker_delete(worker);
1165 return 0;
1166 }
1167 /* start listening to commands */
1168 if(!tube_setup_bg_listen(worker->cmd, worker->base,
1169 &worker_handle_control_cmd, worker)) {

--- 118 unchanged lines hidden (view full) ---

1288 alloc_clear(&worker->alloc);
1289 regional_destroy(worker->scratchpad);
1290 free(worker);
1291}
1292
1293struct outbound_entry*
1294worker_send_query(uint8_t* qname, size_t qnamelen, uint16_t qtype,
1295 uint16_t qclass, uint16_t flags, int dnssec, int want_dnssec,
1192 if(!worker->back) {
1193 log_err("could not create outgoing sockets");
1194 worker_delete(worker);
1195 return 0;
1196 }
1197 /* start listening to commands */
1198 if(!tube_setup_bg_listen(worker->cmd, worker->base,
1199 &worker_handle_control_cmd, worker)) {

--- 118 unchanged lines hidden (view full) ---

1318 alloc_clear(&worker->alloc);
1319 regional_destroy(worker->scratchpad);
1320 free(worker);
1321}
1322
1323struct outbound_entry*
1324worker_send_query(uint8_t* qname, size_t qnamelen, uint16_t qtype,
1325 uint16_t qclass, uint16_t flags, int dnssec, int want_dnssec,
1296 struct sockaddr_storage* addr, socklen_t addrlen, uint8_t* zone,
1297 size_t zonelen, struct module_qstate* q)
1326 int nocaps, struct sockaddr_storage* addr, socklen_t addrlen,
1327 uint8_t* zone, size_t zonelen, struct module_qstate* q)
1298{
1299 struct worker* worker = q->env->worker;
1300 struct outbound_entry* e = (struct outbound_entry*)regional_alloc(
1301 q->region, sizeof(*e));
1302 if(!e)
1303 return NULL;
1304 e->qstate = q;
1305 e->qsent = outnet_serviced_query(worker->back, qname,
1328{
1329 struct worker* worker = q->env->worker;
1330 struct outbound_entry* e = (struct outbound_entry*)regional_alloc(
1331 q->region, sizeof(*e));
1332 if(!e)
1333 return NULL;
1334 e->qstate = q;
1335 e->qsent = outnet_serviced_query(worker->back, qname,
1306 qnamelen, qtype, qclass, flags, dnssec, want_dnssec,
1336 qnamelen, qtype, qclass, flags, dnssec, want_dnssec, nocaps,
1307 q->env->cfg->tcp_upstream, q->env->cfg->ssl_upstream, addr,
1308 addrlen, zone, zonelen, worker_handle_service_reply, e,
1309 worker->back->udp_buff);
1310 if(!e->qsent) {
1311 return NULL;
1312 }
1313 return e;
1314}

--- 6 unchanged lines hidden (view full) ---

1321 slabhash_clear(worker->env.msg_cache);
1322}
1323
1324void worker_stats_clear(struct worker* worker)
1325{
1326 server_stats_init(&worker->stats, worker->env.cfg);
1327 mesh_stats_clear(worker->env.mesh);
1328 worker->back->unwanted_replies = 0;
1337 q->env->cfg->tcp_upstream, q->env->cfg->ssl_upstream, addr,
1338 addrlen, zone, zonelen, worker_handle_service_reply, e,
1339 worker->back->udp_buff);
1340 if(!e->qsent) {
1341 return NULL;
1342 }
1343 return e;
1344}

--- 6 unchanged lines hidden (view full) ---

1351 slabhash_clear(worker->env.msg_cache);
1352}
1353
1354void worker_stats_clear(struct worker* worker)
1355{
1356 server_stats_init(&worker->stats, worker->env.cfg);
1357 mesh_stats_clear(worker->env.mesh);
1358 worker->back->unwanted_replies = 0;
1359 worker->back->num_tcp_outgoing = 0;
1329}
1330
1331void worker_start_accept(void* arg)
1332{
1333 struct worker* worker = (struct worker*)arg;
1334 listen_start_accept(worker->front);
1335 if(worker->thread_num == 0)
1336 daemon_remote_start_accept(worker->daemon->rc);

--- 7 unchanged lines hidden (view full) ---

1344 daemon_remote_stop_accept(worker->daemon->rc);
1345}
1346
1347/* --- fake callbacks for fptr_wlist to work --- */
1348struct outbound_entry* libworker_send_query(uint8_t* ATTR_UNUSED(qname),
1349 size_t ATTR_UNUSED(qnamelen), uint16_t ATTR_UNUSED(qtype),
1350 uint16_t ATTR_UNUSED(qclass), uint16_t ATTR_UNUSED(flags),
1351 int ATTR_UNUSED(dnssec), int ATTR_UNUSED(want_dnssec),
1360}
1361
1362void worker_start_accept(void* arg)
1363{
1364 struct worker* worker = (struct worker*)arg;
1365 listen_start_accept(worker->front);
1366 if(worker->thread_num == 0)
1367 daemon_remote_start_accept(worker->daemon->rc);

--- 7 unchanged lines hidden (view full) ---

1375 daemon_remote_stop_accept(worker->daemon->rc);
1376}
1377
1378/* --- fake callbacks for fptr_wlist to work --- */
1379struct outbound_entry* libworker_send_query(uint8_t* ATTR_UNUSED(qname),
1380 size_t ATTR_UNUSED(qnamelen), uint16_t ATTR_UNUSED(qtype),
1381 uint16_t ATTR_UNUSED(qclass), uint16_t ATTR_UNUSED(flags),
1382 int ATTR_UNUSED(dnssec), int ATTR_UNUSED(want_dnssec),
1352 struct sockaddr_storage* ATTR_UNUSED(addr),
1383 int ATTR_UNUSED(nocaps), struct sockaddr_storage* ATTR_UNUSED(addr),
1353 socklen_t ATTR_UNUSED(addrlen), uint8_t* ATTR_UNUSED(zone),
1354 size_t ATTR_UNUSED(zonelen), struct module_qstate* ATTR_UNUSED(q))
1355{
1356 log_assert(0);
1357 return 0;
1358}
1359
1360int libworker_handle_reply(struct comm_point* ATTR_UNUSED(c),

--- 61 unchanged lines hidden --- 		1384 socklen_t ATTR_UNUSED(addrlen), uint8_t* ATTR_UNUSED(zone),
1385 size_t ATTR_UNUSED(zonelen), struct module_qstate* ATTR_UNUSED(q))
1386{
1387 log_assert(0);
1388 return 0;
1389}
1390
1391int libworker_handle_reply(struct comm_point* ATTR_UNUSED(c),

--- 61 unchanged lines hidden ---