#include "dnsd.hpp" #include #include #include "ev.hpp" #include "llarp/net.hpp" #include "logger.hpp" #ifdef _WIN32 #define wmin(x, y) (((x) < (y)) ? (x) : (y)) #define MIN wmin #endif dns_tracker dns_udp_tracker; ssize_t raw_sendto_dns_hook_func(void *sock, const struct sockaddr *from, const void *buffer, size_t length) { int *fd = (int *)sock; // how do we get to these?? socklen_t addrLen = sizeof(struct sockaddr_in); #ifdef _WIN32 return sendto(*fd, (const char *)buffer, length, 0, from, addrLen); #else return sendto(*fd, buffer, length, 0, from, addrLen); #endif } ssize_t llarp_sendto_dns_hook_func(void *sock, const struct sockaddr *from, const void *buffer, size_t length) { struct llarp_udp_io *udp = (struct llarp_udp_io *)sock; if(!udp) { llarp::LogWarn("couldnt cast to udp"); return 0; } // llarp::LogInfo("hook sending ", udp, " bytes: ", length); // udp seems ok // this call isn't calling the function... // llarp::ev_io * evio = static_cast< llarp::ev_io * >(udp->impl); // printf("ev_io[%x]\n", evio); return llarp_ev_udp_sendto(udp, from, buffer, length); } bool forward_dns_request(std::string request) { return true; } // FIXME: we need an DNS answer not a sockaddr // otherwise ttl, type and class can't be relayed correctly void writesend_dnss_response(struct sockaddr *hostRes, const struct sockaddr *from, dnsd_question_request *request) { // lock_t lock(m_dnsd2_Mutex); if(!hostRes) { llarp::LogWarn("Failed to resolve"); // FIXME: actually return correct packet return; } const size_t BUFFER_SIZE = 1024; char buf[BUFFER_SIZE]; memset(buf, 0, BUFFER_SIZE); char *write_buffer = buf; char *bufferBegin = buf; // build header put16bits(write_buffer, request->id); int fields = (1 << 15); // QR => message type, 1 = response fields += (0 << 14); // I think opcode is always 0 fields += 0; // response code (3 => not found, 0 = Ok) put16bits(write_buffer, fields); put16bits(write_buffer, 1); // QD (number of questions) put16bits(write_buffer, 1); // AN (number of answers) put16bits(write_buffer, 0); // NS (number of auth RRs) put16bits(write_buffer, 0); // AR (number of Additional RRs) // code question code_domain(write_buffer, request->question.name); put16bits(write_buffer, request->question.type); put16bits(write_buffer, request->question.qClass); // code answer code_domain(write_buffer, request->question.name); // com, type=6, ttl=0 put16bits(write_buffer, request->question.type); put16bits(write_buffer, request->question.qClass); put32bits(write_buffer, 1); // ttl // has to be a string of 4 bytes struct sockaddr_in *sin = (struct sockaddr_in *)hostRes; unsigned char *ip = (unsigned char *)&sin->sin_addr.s_addr; put16bits(write_buffer, 4); // rdLength *write_buffer++ = ip[0]; *write_buffer++ = ip[1]; *write_buffer++ = ip[2]; *write_buffer++ = ip[3]; uint out_bytes = write_buffer - bufferBegin; llarp::LogDebug("Sending ", out_bytes, " bytes"); // struct llarp_udp_io *udp = (struct llarp_udp_io *)request->user; request->hook(request->user, from, buf, out_bytes); } void handle_dnsc_result(dnsc_answer_request *client_request) { // llarp::LogInfo("phase2 client ", client_request); // writesend_dnss_response(struct sockaddr *hostRes, const struct sockaddr // *from, dnsd_question_request *request) dnsd_question_request *server_request = (dnsd_question_request *)client_request->user; // llarp::Addr test(*server_request->from); // llarp::LogInfo("server request sock ", server_request->from, " is ", test); // llarp::LogInfo("phase2 server ", server_request); writesend_dnss_response( client_request->found ? &client_request->result : nullptr, server_request->from, server_request); llarp_host_resolved(client_request); } // our generic version void handle_recvfrom(const char *buffer, ssize_t nbytes, const struct sockaddr *from, dnsd_question_request *request) { // lock_t lock(m_dnsd_Mutex); const size_t HDR_OFFSET = 12; const char *p_buffer = buffer; int rcode = (buffer[3] & 0x0F); llarp::LogDebug("dnsd rcode ", rcode); dns_msg_header *msg = decode_hdr(p_buffer); // llarp::LogInfo("DNS_MSG size", sizeof(dns_msg)); p_buffer += HDR_OFFSET; request->id = msg->id; std::string m_qName = ""; int length = *p_buffer++; // llarp::LogInfo("qNamLen", length); while(length != 0) { for(int i = 0; i < length; i++) { char c = *p_buffer++; m_qName.append(1, c); } length = *p_buffer++; if(length != 0) m_qName.append(1, '.'); } request->question.name = m_qName; request->question.type = get16bits(p_buffer); request->question.qClass = get16bits(p_buffer); // request->m_qName = m_qName; // request->m_qType = request->question.type; // request->m_qClass = request->question.qClass; llarp::LogDebug("qName ", request->question.name); llarp::LogDebug("qType ", request->question.type); llarp::LogDebug("qClass ", request->question.qClass); /* llarp::Addr test(*request->from); llarp::LogInfo("DNS request from ", test); llarp::Addr test2(from); llarp::LogInfo("DNS request from ", test2); */ if(request->context->intercept) { sockaddr *intercept = request->context->intercept(request->question.name, request->context); // if(!forward_dns_request(m_qName)) if(intercept != nullptr) { // told that hook will handle overrides sockaddr *fromCopy = new sockaddr(*from); writesend_dnss_response(intercept, fromCopy, request); return; } } sockaddr *hostRes = nullptr; if(request->llarp) { // llarp::Addr anIp; // llarp::LogInfo("Checking server request ", request); struct llarp_udp_io *udp = (struct llarp_udp_io *)request->user; struct dns_tracker *tracker = (struct dns_tracker *)udp->user; dnsd_context *dnsd = tracker->dnsd; // dnsd_context *dnsd = (dnsd_context *)udp->user; // llarp::LogInfo("Server request UDP ", request->user); // llarp::LogInfo("server request hook ", request->hook); // llarp::LogInfo("UDP ", udp); // hostRes = llarp_resolveHost(udp->parent, m_qName.c_str()); llarp_resolve_host(&dnsd->client, m_qName.c_str(), &handle_dnsc_result, (void *)request); } else { hostRes = raw_resolve_host(m_qName.c_str()); llarp::Addr anIp(*hostRes); llarp::LogDebug("DNSc got ", anIp); // writesend_dnss_response(struct sockaddr *hostRes, const struct sockaddr // *from, dnsd_question_request *request) sockaddr *fromCopy = new sockaddr(*from); writesend_dnss_response(hostRes, fromCopy, request); } } void llarp_handle_dnsd_recvfrom(struct llarp_udp_io *udp, const struct sockaddr *paddr, const void *buf, ssize_t sz) { // lock_t lock(m_dnsd3_Mutex); // llarp_link *link = static_cast< llarp_link * >(udp->user); llarp::LogDebug("llarp Received Bytes ", sz); dnsd_question_request *llarp_dns_request = new dnsd_question_request; // llarp::LogInfo("Creating server request ", &llarp_dns_request); // llarp::LogInfo("Server UDP address ", udp); llarp_dns_request->context = dns_udp_tracker.dnsd; // make a copy of the sockaddr llarp_dns_request->from = new sockaddr(*paddr); llarp_dns_request->user = (void *)udp; llarp_dns_request->llarp = true; // set sock hook llarp_dns_request->hook = &llarp_sendto_dns_hook_func; // llarp::LogInfo("Server request's UDP ", llarp_dns_request->user); handle_recvfrom((char *)buf, sz, llarp_dns_request->from, llarp_dns_request); } void raw_handle_recvfrom(int *sockfd, const struct sockaddr *saddr, const void *buf, ssize_t sz) { llarp::LogInfo("raw Received Bytes ", sz); dnsd_question_request *llarp_dns_request = new dnsd_question_request; llarp_dns_request->from = (struct sockaddr *)saddr; llarp_dns_request->user = (void *)sockfd; llarp_dns_request->llarp = false; llarp_dns_request->hook = &raw_sendto_dns_hook_func; handle_recvfrom((char *)buf, sz, saddr, llarp_dns_request); } bool llarp_dnsd_init(struct dnsd_context *dnsd, struct llarp_ev_loop *netloop, const char *dnsd_ifname, uint16_t dnsd_port, const char *dnsc_hostname, uint16_t dnsc_port) { struct sockaddr_in bindaddr; bindaddr.sin_addr.s_addr = inet_addr("0.0.0.0"); bindaddr.sin_family = AF_INET; bindaddr.sin_port = htons(dnsd_port); dnsd->udp.user = &dns_udp_tracker; dnsd->udp.recvfrom = &llarp_handle_dns_recvfrom; dnsd->udp.tick = nullptr; dns_udp_tracker.dnsd = dnsd; dnsd->intercept = nullptr; // configure dns client if(!llarp_dnsc_init(&dnsd->client, &dnsd->udp, dnsc_hostname, dnsc_port)) { llarp::LogError("Couldnt init dns client"); return false; } return llarp_ev_add_udp(netloop, &dnsd->udp, (const sockaddr *)&bindaddr) != -1; }