lokinet/include/llarp/dns.h

#ifndef LLARP_DNS_H_
#define LLARP_DNS_H_

#include <sys/types.h> // for uint & ssize_t
#include <llarp/ev.h>

/**
 * dns.h
 *
 * dns client/server
 */

#include <mutex>
typedef std::mutex mtx_t;
typedef std::lock_guard< mtx_t > lock_t;

// fwd declr
struct dns_query;
struct dnsc_context;

typedef bool (*intercept_query_hook)(struct dnsc_context *, const dns_query *);

struct dnsc_context
{
  /// DNS server hostname to use
  //char *server;
  /// DNS server port to use
  //uint port;
  /// Target: DNS server hostname/port to use
  // FIXME: ipv6 it
  sockaddr *server;
  // where to create the new sockets
  struct llarp_ev_loop *netloop;
  // FIXME: UDP socket pooling (or maybe at the libev level)
};

struct dnsd_context
{
  /// DNS daemon port to listen on
  struct llarp_udp_io udp;
  dnsc_context client;
  /// custom data for intercept query hook
  void *user;
  /// hook function for intercepting dns requests
  intercept_query_hook intercept;
};

/// initialize dns subsystem and bind socket
/// returns true on bind success otherwise returns false
bool
llarp_dnsc_init(struct dnsc_context *dnsc, struct llarp_ev_loop *netloop,
               const char *dnsc_hostname, uint16_t dnsc_port);

bool
llarp_dnsc_stop(struct dnsc_context *dnsc);

bool
llarp_dnsc_unbind(struct dns_client_request *request);

bool
llarp_dnsc_bind(struct llarp_ev_loop *netloop, struct dns_client_request *request);

/// initialize dns subsystem and bind socket
/// returns true on bind success otherwise returns false
bool
llarp_dnsd_init(struct dnsd_context *dns, struct llarp_ev_loop *netloop,
                const char *dnsd_ifname, uint16_t dnsd_port,
                const char *dnsc_hostname, uint16_t dnsc_port);

#define DNC_BUF_SIZE 512

struct dns_query
{
  uint16_t length;
  char * url;
  unsigned char request[DNC_BUF_SIZE];
  uint16_t reqType;
};

struct dns_client_request;

// should we pass by llarp::Addr
// not as long as we're supporting raw
typedef void(*resolve_dns_hook_func)(dns_client_request *request);

// FIXME: separate generic from llarp
struct dns_client_request
{
  /// sock type
  void *sock; // pts to udp...
  /// customizeable (used for outer request)
  void *user;
  /// storage
  dns_query query;
  /// hook
  resolve_dns_hook_func resolved;
  /// result
  bool found;
  struct sockaddr result;
  /// Source: UDP port to use
  // FIXME: separate socket for now
  struct llarp_udp_io udp;
};

bool
llarp_dnsc_bind(struct llarp_ev_loop *netloop,
                struct dns_client_request *request);

struct sockaddr *resolveHost(const char *url);
bool llarp_resolve_host(struct dnsc_context *dns, const char *url,
                        resolve_dns_hook_func resolved, void *user);
void
llarp_host_resolved(dns_client_request *request);

void
llarp_handle_recvfrom(struct llarp_udp_io *udp, const struct sockaddr *saddr,
                const void *buf, ssize_t sz);

void
raw_handle_recvfrom(int *sockfd, const struct sockaddr *saddr,
           const void *buf, ssize_t sz);

#endif