mirror of
https://github.com/oxen-io/lokinet
synced 2023-12-14 06:53:00 +01:00
152 lines
3.5 KiB
C++
152 lines
3.5 KiB
C++
#ifndef LLARP_DNS_HPP
|
|
#define LLARP_DNS_HPP
|
|
|
|
#include <dns.h>
|
|
#include <sys/types.h> // for uint & ssize_t
|
|
|
|
#ifndef _WIN32
|
|
#include <sys/socket.h>
|
|
#endif
|
|
|
|
#include <dns/rectypes.hpp>
|
|
#include <net/net.hpp> // for llarp::Addr , llarp::huint32_t
|
|
|
|
#include <map>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#define LLARP_DNS_RECTYPE_A 1
|
|
#define LLARP_DNS_RECTYPE_NS 2
|
|
#define LLARP_DNS_RECTYPE_CNAME 5
|
|
#define LLARP_DNS_RECTYPE_SOA 6
|
|
#define LLARP_DNS_RECTYPE_PTR 12
|
|
#define LLARP_DNS_RECTYPE_MX 15
|
|
#define LLARP_DNS_RECTYPE_TXT 16
|
|
|
|
struct dnsc_answer_request;
|
|
struct dnsd_context;
|
|
|
|
// dnsc can work over any UDP socket
|
|
// however we can't ignore udp->user
|
|
// we need to be able to reference the request (being a request or response)
|
|
// bottom line is we can't use udp->user
|
|
// so we'll need to track all incoming and outgoing requests
|
|
struct dns_tracker
|
|
{
|
|
// uint c_responses;
|
|
uint32_t c_requests;
|
|
// request has to be a pointer
|
|
std::unordered_map< uint32_t, std::unique_ptr< dnsc_answer_request > >
|
|
client_request;
|
|
// FIXME: support multiple dns server contexts
|
|
dnsd_context *dnsd;
|
|
// rn we need 1 tracker per DNSd and each DNSd needs it's own IP
|
|
// actually we can bind once and use the tracker to sort
|
|
// but no way to tell what DNSd they want...
|
|
// std::map< llarp::Addr, std::unique_ptr< dnsc_answer_request > > dnsds;
|
|
// std::map< uint, dnsd_question_request * > daemon_request;
|
|
};
|
|
|
|
// protocol parsing/writing structures & functions
|
|
struct dns_msg_header
|
|
{
|
|
uint16_t id;
|
|
|
|
uint8_t qr : 1;
|
|
uint8_t opcode : 4;
|
|
uint8_t aa : 1;
|
|
uint8_t tc : 1;
|
|
uint8_t rd : 1;
|
|
|
|
uint8_t ra : 1;
|
|
uint8_t z : 1;
|
|
uint8_t ad : 1;
|
|
uint8_t cd : 1;
|
|
uint8_t rcode : 4;
|
|
|
|
uint16_t
|
|
fields() const
|
|
{
|
|
return (qr << 15) | (opcode << 14) | (aa << 10) | (tc << 9)
|
|
| (rd << 8) << (ra << 7) | (z << 6) | rcode;
|
|
}
|
|
|
|
uint16_t qdCount;
|
|
uint16_t anCount;
|
|
uint16_t nsCount;
|
|
uint16_t arCount;
|
|
};
|
|
|
|
struct dns_msg_question
|
|
{
|
|
std::string name;
|
|
uint16_t type;
|
|
uint16_t qClass;
|
|
};
|
|
|
|
struct dns_msg_answer
|
|
{
|
|
std::string name;
|
|
uint16_t type;
|
|
uint16_t aClass;
|
|
uint32_t ttl;
|
|
uint16_t rdLen;
|
|
std::vector< byte_t > rData;
|
|
std::unique_ptr< llarp::dns::record > record;
|
|
};
|
|
|
|
struct dns_packet
|
|
{
|
|
struct dns_msg_header header;
|
|
std::vector< std::unique_ptr< dns_msg_question > > questions;
|
|
std::vector< std::unique_ptr< dns_msg_answer > > answers;
|
|
std::vector< std::unique_ptr< dns_msg_answer > > auth_rrs;
|
|
std::vector< std::unique_ptr< dns_msg_answer > > additional_rrs;
|
|
};
|
|
|
|
std::vector< byte_t >
|
|
packet2bytes(dns_packet &in);
|
|
|
|
std::string
|
|
getDNSstring(const char *const buffer, uint32_t *pos);
|
|
|
|
void
|
|
code_domain(char *&buffer, const std::string &domain) throw();
|
|
|
|
void
|
|
vcode_domain(std::vector< byte_t > &bytes, const std::string &domain) throw();
|
|
|
|
void
|
|
vput16bits(std::vector< byte_t > &bytes, uint16_t value) throw();
|
|
|
|
void
|
|
vput32bits(std::vector< byte_t > &bytes, uint32_t value) throw();
|
|
|
|
extern "C"
|
|
{
|
|
uint16_t
|
|
get16bits(const char *&buffer) throw();
|
|
|
|
uint32_t
|
|
get32bits(const char *&buffer) throw();
|
|
|
|
bool
|
|
decode_hdr(llarp_buffer_t *buffer, dns_msg_header *hdr);
|
|
|
|
dns_msg_question *
|
|
decode_question(const char *buffer, uint32_t *pos);
|
|
|
|
dns_msg_answer *
|
|
decode_answer(const char *const buffer, uint32_t *pos);
|
|
|
|
void
|
|
put16bits(char *&buffer, uint16_t value) throw();
|
|
|
|
void
|
|
put32bits(char *&buffer, uint32_t value) throw();
|
|
|
|
void
|
|
llarp_handle_dns_recvfrom(struct llarp_udp_io *udp,
|
|
const struct sockaddr *addr, ManagedBuffer buf);
|
|
}
|
|
#endif
|