ail/dns.hpp

   1 #pragma once
   2
   3 #include <string>
   4 #include <vector>
   5
   6 #include <boost/asio.hpp>
   7 #include <boost/function.hpp>
   8 #include <boost/thread/mutex.hpp>
   9
  10 #include <ail/types.hpp>
  11 #include <ail/memory.hpp>
  12
  13 namespace ail
  14 {
  15         struct dns_question
  16         {
  17                 std::string name;
  18                 ulong
  19                         type,
  20                         dns_class;
  21         };
  22
  23         struct dns_answer
  24         {
  25                 std::string name;
  26                 ulong
  27                         type,
  28                         dns_class;
  29
  30                 ulong time_to_live;
  31
  32                 bool is_ip, is_unknown;
  33                 std::string
  34                         address,
  35                         other_data;
  36         };
  37
  38         typedef std::vector<dns_question> question_vector;
  39         typedef std::vector<dns_answer> answer_vector;
  40
  41         struct dns_lookup_result
  42         {
  43                 bool success;
  44                 std::string
  45                         name,
  46                         error_message,
  47                         address;
  48
  49                 question_vector questions;
  50                 answer_vector
  51                         answers,
  52                         authoritative_nameservers,
  53                         additional_records;
  54         };
  55
  56         typedef boost::function<void (dns_lookup_result & result)> dns_lookup_handler_type;
  57
  58         struct dns_request
  59         {
  60                 ushort transaction_id;
  61                 std::string name;
  62                 dns_lookup_handler_type lookup_handler;
  63                 char * buffer;
  64
  65                 bool operator==(dns_request const & other) const;
  66         };
  67
  68         class dns_client
  69         {
  70         public:
  71                 dns_client(boost::asio::io_service & io_service, std::string const & server, ushort port);
  72
  73                 void lookup(std::string const & name, dns_lookup_handler_type lookup_handler);
  74
  75         private:
  76                 std::string server;
  77                 ulong port;
  78
  79                 boost::asio::io_service & io_service;
  80
  81                 boost::asio::ip::udp::resolver resolver;
  82                 boost::asio::ip::udp::socket socket;
  83
  84                 bool got_endpoint;
  85                 boost::asio::ip::udp::endpoint endpoint;
  86
  87                 boost::mutex mutex;
  88
  89                 ushort current_id;
  90
  91                 typedef std::vector<dns_request> request_vector;
  92
  93                 request_vector pending_requests;
  94
  95                 void resolve_event(boost::system::error_code const & error, boost::asio::ip::udp::resolver::iterator endpoint_iterator, dns_request & request);
  96                 void receive_event(boost::system::error_code const & error, std::size_t bytes_received, char * receive_buffer);
  97                 void send_event(boost::system::error_code const & error, std::size_t bytes_received, dns_request & request);
  98
  99                 void global_error(std::string const & message);
 100                 void error_occured(dns_request & request, std::string const & message);
 101
 102                 void receive_data();
 103                 void send_dns_request(dns_request & request);
 104                 void erase_request(dns_request & request);
 105                 bool get_request(ushort transaction_id, request_vector::iterator & output);
 106
 107                 dns_question read_question(bit_reader & reader);
 108                 dns_answer read_answer(bit_reader & reader);
 109                 std::string read_name(bit_reader & reader);
 110                 void continue_processing(char * receive_buffer);
 111         };
 112 }