sdns.h

Go to the documentation of this file.

 
#include <stdint.h>
 
#ifndef __SDNS_H
#define __SDNS_H
 
#define TO_OUTPUT(A,B) do{if (NULL == A) {fprintf(stdout, B);}else{strcpy(A,B);}}while(0);
 
#define UDP_PAYLOAD_SIZE 1232   
#define DNS_HEADER_LENGTH 12    
 
// define some error code constant
#define SDNS_ERROR_MEMORY_ALLOC_FAILED -1                
#define SDNS_ERROR_BUFFER_TOO_SHORT -2                  
#define SDNS_ERROR_QNAME_IS_NULL -3                     
#define SDNS_ERROR_HOSTNAME_TOO_LONG -4                 
#define SDNS_ERROR_WRONG_LABEL_SPECIFIED -5             
#define SDNS_ERROR_BUFFER_IS_NULL -6                    
#define SDNS_ERROR_BUFFER_IS_SMALL -7                   
#define SDNS_ERROR_INVALID_DNS_PACKET -8                
#define SDNS_ERROR_MORE_THAN_ONE_QUESTION_FOUND -9      
#define SDNS_ERROR_RR_NULL -10                          
// these two are success code for encoding label
#define SDNS_ERROR_ELSIMPLE -11                         
#define SDNS_ERROR_ELCOMPRESSED -12                     
 
#define SDNS_ERROR_LABEL_MAX_63 -13                     
#define SDNS_ERROR_ILLEGAL_COMPRESSION -14              
#define SDNS_ERROR_RR_SECTION_MALFORMED -15             
#define SDNS_ERROR_INVALID_HEX_VALUE -16               
#define SDNS_ERROR_WRONG_INPUT_PARAMETER -17           
#define SDNS_ERROR_NSID_NOT_FOUND        -18           
#define SDNS_ERROR_CLIENT_COOKIE_NOT_FOUND   -19       
#define SDNS_ERROR_CHARACTER_STRING_TOO_LONG -20       
#define SDNS_ERROR_NO_ANSWER_FOUND           -21       
#define SDNS_ERROR_CAN_NOT_READ_SECTION      -22       
#define SDNS_ERROR_INVALID_IPv6_FOUND        -23       
#define SDNS_ERROR_NO_AUTHORITY_FOUND        -24       
#define SDNS_ERROR_NO_ADDITIONAL_FOUND       -25       
#define SDNS_ERROR_ADDITIONAL_RR_OPT        -26       
// define the section types
#define DNS_SECTION_ANSWER 1                           
#define DNS_SECTION_AUTHORITY 2                        
#define DNS_SECTION_ADDITIONAL 3                       
#define DNS_SECTION_QUESTION 4                         
 
// define DNS masks
#define SDNS_QR_MASK     0x8000
#define SDNS_OPCODE_MASK 0x7800
#define SDNS_AA_MASK     0x0400
#define SDNS_TC_MASK     0x0200
#define SDNS_RD_MASK     0x0100
#define SDNS_RA_MASK     0x0080
#define SDNS_Z_MASK      0x0040
#define SDNS_AD_MASK     0x0020
#define SDNS_CD_MASK     0x0010
#define SDNS_RCODE_MASK  0x000F
 
 
 
typedef enum{
    sdns_opcode_Query=0,                
    sdns_opcode_IQuery=1,               
    sdns_opcode_Status=2,               
    sdns_opcode_Notify=4,               
    sdns_opcode_Update=5,               
    sdns_opcode_DSO=6                   
} sdns_opcode;
 
 
 
typedef enum{
    sdns_rcode_NoError=0,           
    sdns_rcode_FormErr=1,           
    sdns_rcode_ServFail=2,          
    sdns_rcode_NXDomain=3,          
    sdns_rcode_NotImp=4,            
    sdns_rcode_Refused=5,           
    sdns_rcode_YXDomain=6,          
    sdns_rcode_YXRRSet=7,           
    sdns_rcode_NXRRSet=8,           
    sdns_rcode_NotAuth=9,           
    sdns_rcode_NotZone=10,          
    sdns_rcode_DSOTYPENI=11,        
    sdns_rcode_BADVERS=16,          
    sdns_rcode_BADSIG=16,           
    sdns_rcode_BADKEY=17,           
    sdns_rcode_BADTIME=18,          
    sdns_rcode_BADMODE=19,          
    sdns_rcode_BADNAME=20,          
    sdns_rcode_BADALG=21,           
    sdns_rcode_BADTRUNC=22,         
    sdns_rcode_BADCOOKIE=23,        
    sdns_rcode_Reserved=65535       
} sdns_rcode;
 
typedef struct {
    char * qname;                   
    uint16_t qtype;                 
    uint16_t qclass;                
} sdns_question;
 
 
struct _sdns_opt_rdata{
    uint16_t option_code;               
    uint16_t option_length;             
    char * option_data;                 
    struct _sdns_opt_rdata * next;      
};
 
typedef struct _sdns_opt_rdata sdns_opt_rdata;      
 
 
 
typedef struct{
    uint32_t extended_rcode :8;         
    uint32_t version        :8;         
    uint32_t DO             :1;         
    uint32_t Z              :15;        
} sdns_opt_ttl;
 
 
struct _sdns_rr{
    char * name;                     
    uint16_t type;                  
    union {
        uint16_t class;             
        uint16_t udp_size;          
    };
    union {
        uint32_t ttl;               
        sdns_opt_ttl opt_ttl;       
    };
    uint16_t rdlength;              
    union {
        char * rdata;               
        sdns_opt_rdata * opt_rdata; 
        void * psdns_rr;   
    };
    uint8_t decoded;       
    struct _sdns_rr * next;     
};
 
typedef struct _sdns_rr sdns_rr;            
 
typedef enum {
    sdns_rr_type_A=1,               
    sdns_rr_type_NS=2,              
    sdns_rr_type_MD=3,              
    sdns_rr_type_MF=4,              
    sdns_rr_type_CNAME=5,           
    sdns_rr_type_SOA=6,             
    sdns_rr_type_MB=7,              
    sdns_rr_type_MG=8,              
    sdns_rr_type_MR=9,              
    sdns_rr_type_NULL=10,           
    sdns_rr_type_WKS=11,            
    sdns_rr_type_PTR=12,            
    sdns_rr_type_HINFO=13,          
    sdns_rr_type_MINFO=14,          
    sdns_rr_type_MX=15,             
    sdns_rr_type_TXT=16,            
    sdns_rr_type_RP=17,             
    sdns_rr_type_AFSDB=18,          
    sdns_rr_type_X25=19,            
    sdns_rr_type_ISDN=20,           
    sdns_rr_type_RT=21,             
    sdns_rr_type_NSAP=22,           
    sdns_rr_type_NSAP_PTR=23,       
    sdns_rr_type_SIG=24,            
    sdns_rr_type_KEY=25,            
    sdns_rr_type_PX=26,             
    sdns_rr_type_GPOS=27,           
    sdns_rr_type_AAAA=28,           
    sdns_rr_type_LOC=29,            
    sdns_rr_type_NXT=30,            
    sdns_rr_type_EID=31,            
    sdns_rr_type_NIMLOC=32,         
    sdns_rr_type_SRV=33,            
    sdns_rr_type_ATMA=34,           
    sdns_rr_type_NAPTR=35,          
    sdns_rr_type_KX=36,             
    sdns_rr_type_CERT=37,           
    sdns_rr_type_A6=38,             
    sdns_rr_type_DNAME=39,          
    sdns_rr_type_SINK=40,           
    sdns_rr_type_OPT=41,            
    sdns_rr_type_APL=42,            
    sdns_rr_type_DS=43,             
    sdns_rr_type_SSHFP=44,          
    sdns_rr_type_IPSECKEY=45,       
    sdns_rr_type_RRSIG=46,          
    sdns_rr_type_NSEC=47,           
    sdns_rr_type_DNSKEY=48,         
    sdns_rr_type_DHCID=49,          
    sdns_rr_type_NSEC3=50,          
    sdns_rr_type_NSEC3PARAM=51,     
    sdns_rr_type_TLSA=52,           
    sdns_rr_type_SMIMEA=53,         
    sdns_rr_type_HIP=55,            
    sdns_rr_type_NINFO=56,          
    sdns_rr_type_RKEY=57,           
    sdns_rr_type_TALINK=58,         
    sdns_rr_type_CDS=59,            
    sdns_rr_type_CDNSKEY=60,        
    sdns_rr_type_OPENPGPKEY=61,     
    sdns_rr_type_CSYNC=62,          
    sdns_rr_type_ZONEMD=63,         
    sdns_rr_type_SVCB=64,           
    sdns_rr_type_HTTPS=65,          
    sdns_rr_type_SPF=99,            
    sdns_rr_type_UINFO=100,         
    sdns_rr_type_UID=101,           
    sdns_rr_type_GID=102,           
    sdns_rr_type_UNSPEC=103,        
    sdns_rr_type_NID=104,           
    sdns_rr_type_L32=105,           
    sdns_rr_type_L64=106,           
    sdns_rr_type_LP=107,            
    sdns_rr_type_EUI48=108,         
    sdns_rr_type_EUI64=109,         
    sdns_rr_type_TKEY=249,          
    sdns_rr_type_TSIG=250,          
    sdns_rr_type_IXFR=251,          
    sdns_rr_type_AXFR=252,          
    sdns_rr_type_MAILB=253,         
    sdns_rr_type_MAILA=254,         
    sdns_rr_type_star=255,          
    sdns_rr_type_URI=256,           
    sdns_rr_type_CAA=257,           
    sdns_rr_type_AVC=258,           
    sdns_rr_type_DOA=259,           
    sdns_rr_type_AMTRELAY=260,      
    sdns_rr_type_RESINFO=261,       
    sdns_rr_type_WALLET=262,        
    sdns_rr_type_TA=32768,          
    sdns_rr_type_DLV=32769          
} sdns_rr_type;
 
 
typedef enum{
   sdns_edns0_option_code_Reserved0=0,              
   sdns_edns0_option_code_LLQ=1,                    
   sdns_edns0_option_code_Update_Lease=2,           
   sdns_edns0_option_code_NSID=3,                   
   sdns_edns0_option_code_Reserved4=4,              
   sdns_edns0_option_code_DAU=5,                    
   sdns_edns0_option_code_DHU=6,                    
   sdns_edns0_option_code_N3U=7,                    
   sdns_edns0_option_code_edns_client_subnet=8,     
   sdns_edns0_option_code_EDNS_EXPIRE=9,            
   sdns_edns0_option_code_COOKIE=10,                
   sdns_edns0_option_code_edns_tcp_keepalive=11,    
   sdns_edns0_option_code_Padding=12,               
   sdns_edns0_option_code_CHAIN=13,                 
   sdns_edns0_option_code_edns_key_tag=14,          
   sdns_edns0_option_code_Extended_DNS_Error=15,    
   sdns_edns0_option_code_EDNS_Client_Tag=16,       
   sdns_edns0_option_code_EDNS_Server_Tag=17,       
   sdns_edns0_option_code_Report_Channel=18,        
   sdns_edns0_option_code_Umbrella_Ident=20292,     
   sdns_edns0_option_code_DeviceID=26946            
} sdns_edns0_option_code;
 
typedef enum{
    sdns_rr_class_IN=1,           
    sdns_rr_class_CS=2,           
    sdns_rr_class_CH=3,           
    sdns_rr_class_HS=4            
} sdns_rr_class;
 
 
typedef enum{
    sdns_q_class_IN=1,           
    sdns_q_class_CS=2,           
    sdns_q_class_CH=3,           
    sdns_q_class_HS=4,           
    sdns_q_class_STAR=255        
} sdns_q_class;
 
 
typedef struct {
    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 qdcount;         
    uint16_t ancount;         
    uint16_t nscount;         
    uint16_t arcount;         
} sdns_header;
 
typedef enum {
    sdns_ede_code_Other_Error=0,                         
    sdns_ede_code_Unsupported_DNSKEY_Algorithm=1,        
    sdns_ede_code_Unsupported_DS_Digest_Type=2,          
    sdns_ede_code_Stale_Answer=3,                        
    sdns_ede_code_Forged_Answer=4,                       
    sdns_ede_code_DNSSEC_Indeterminate=5,                
    sdns_ede_code_DNSSEC_Bogus=6,                        
    sdns_ede_code_Signature_Expired=7,                   
    sdns_ede_code_Signature_Not_Yet_Valid=8,             
    sdns_ede_code_DNSKEY_Missing=9,                      
    sdns_ede_code_RRSIGs_Missing=10,                     
    sdns_ede_code_No_Zone_Key_Bit_Set=11,                
    sdns_ede_code_NSEC_Missing=12,                       
    sdns_ede_code_Cached_Error=13,                       
    sdns_ede_code_Not_Ready=14,                          
    sdns_ede_code_Blocked=15,                            
    sdns_ede_code_Censored=16,                           
    sdns_ede_code_Filtered=17,                           
    sdns_ede_code_Prohibited=18,                         
    sdns_ede_code_Stale_NXDomain_Answer=19,              
    sdns_ede_code_Not_Authoritative=20,                  
    sdns_ede_code_Not_Supported=21,                      
    sdns_ede_code_No_Reachable_Authority=22,             
    sdns_ede_code_Network_Error=23,                      
    sdns_ede_code_Invalid_Data=24,                       
    sdns_ede_code_Signature_Expired_before_Valid=25,     
    sdns_ede_code_Too_Early=26,                          
    sdns_ede_code_Unsupported_NSEC3_Iterations_Value=27, 
    sdns_ede_code_Unable_to_conform_to_policy=28,        
    sdns_ede_code_Synthesized=29                         
}sdns_ede_code;
 
typedef struct {
    sdns_header header;             
    sdns_question question;         
    sdns_rr *answer;                
    sdns_rr *authority;             
    sdns_rr *additional;            
} sdns_message;
 
typedef struct {
    uint32_t address;           
} sdns_rr_A;
 
typedef struct {
    char * address;             
} sdns_rr_AAAA;
 
typedef struct {
    uint8_t len;        
    char * content;     
} txt_data;
 
struct _sdns_rr_TXT {
   txt_data character_string;   
   struct _sdns_rr_TXT * next;  
};
 
typedef struct _sdns_rr_TXT sdns_rr_TXT;
 
 
typedef struct {
    char * mname;           
    char * rname;           
    uint32_t serial;        
    uint32_t refresh;       
    uint32_t retry;         
    uint32_t expire;        
    uint32_t minimum;       
} sdns_rr_SOA;
 
 
typedef struct {
    uint16_t preference;        
    char * exchange;            
}sdns_rr_MX;
 
typedef struct{
    char * NSDNAME;             
}sdns_rr_NS;
 
 
typedef struct{
    char * PTRDNAME;            
}sdns_rr_PTR;
 
typedef struct{
    char * CNAME;               
}sdns_rr_CNAME;
 
typedef struct {                
    uint16_t inf_code;          
    char * extra_text;          
    uint16_t extra_text_len;    
}sdns_rr_OPT_EDE;
 
typedef struct{
    uint16_t type_covered;          
    uint8_t algorithm;              
    uint8_t labels;                 
    uint32_t original_ttl;          
    uint32_t signature_expiration;  
    uint32_t signature_inception;   
    uint16_t key_tag;               
    char * signers_name;            
    char * signature;               
    uint16_t signature_len;         
}sdns_rr_RRSIG;
 
 
typedef struct{
    uint16_t Priority;         
    uint16_t Weight;           
    uint16_t Port;             
    char * Target;             
}sdns_rr_SRV;
 
typedef struct{
    uint16_t Priority;      
    uint16_t Weight;        
    char * Target;          
    uint16_t target_len;    
} sdns_rr_URI;
 
typedef struct{
    uint16_t Preference;        
    char * NodeId;              
} sdns_rr_NID;
 
typedef struct{
    uint8_t cpu_len;            
    char * cpu;                 
    uint8_t os_len;             
    char * os;                  
}sdns_rr_HINFO;
 
typedef struct{
    uint16_t Preference;   
    uint32_t Locator32;    
}sdns_rr_L32;
 
 
typedef struct{
    uint16_t Preference;    
    char * Locator64;       
}sdns_rr_L64;
 
 
typedef struct{
    uint16_t Preference;    
    char * FQDN;            
}sdns_rr_LP;
 
 
typedef struct{
    uint8_t flag;           
    char * tag;             
    uint8_t tag_len;        
    uint16_t value_len;     
    char * value;           
}sdns_rr_CAA;
 
 
typedef struct {
    sdns_message * msg;         
    char * raw;                 
    uint16_t raw_len;           
    char * cursor;              
    int err;                    
}sdns_context;
 
 
 
// list of function declarations
 
int sdns_make_query(sdns_context * ctx, sdns_rr_type qtype,
                     sdns_q_class cls, char * qname, int enable_edns0);
 
 
 
int sdns_to_wire(sdns_context * ctx);
 
 
int sdns_from_wire(sdns_context * ctx);
 
 
void sdns_error_string(int err, char ** err_buff);
 
 
 
sdns_context * sdns_init_context(void);
 
 
void sdns_free_context(sdns_context* ctx);
 
 
int sdns_add_answer_section(sdns_context * ctx, sdns_rr * rr);
 
 
int sdns_add_authority_section(sdns_context * ctx, sdns_rr * rr);
 
 
 
int sdns_add_additional_section(sdns_context * ctx, sdns_rr * rr);
 
 
 
 
int check_if_qtype_is_valid(uint16_t qtype);
 
int check_if_rrtype_is_valid(uint16_t qtype);
 
 
int check_if_qclass_is_valid(uint16_t qclass);
 
int check_if_rrclass_is_valid(uint16_t qclass);
 
sdns_message * sdns_init_message(void);
 
sdns_rr * sdns_init_rr(char * name, uint16_t type, uint16_t class, uint32_t ttl,
                       uint16_t rdlength, uint8_t decoded, void * rdata);
 
 
 
 
 
int sdns_create_edns_option(uint16_t, uint16_t, char *, sdns_opt_rdata**);
int sdns_add_edns(sdns_context * ctx, sdns_opt_rdata * opt);
sdns_opt_rdata * sdns_create_edns0_ede(uint16_t info_code, char * extra_text, uint16_t extra_text_len);
 
sdns_opt_rdata * sdns_create_edns0_nsid(char * nsid, uint16_t nsid_len);
 
// add whatever function you want to ends0 section
int sdns_ends0_option_code_to_text(sdns_edns0_option_code oc, char * buffer);
 
 
void * sdns_copy_rr_section(sdns_context *, sdns_rr*);
void * sdns_decode_rr_section(sdns_context *, sdns_rr *);
sdns_rr_A * sdns_decode_rr_A(sdns_context *, sdns_rr *);
sdns_rr_AAAA * sdns_decode_rr_AAAA(sdns_context *, sdns_rr *);
sdns_rr_TXT * sdns_decode_rr_TXT(sdns_context *, sdns_rr *);
sdns_rr_SOA * sdns_decode_rr_SOA(sdns_context *, sdns_rr *);
sdns_rr_MX * sdns_decode_rr_MX(sdns_context *, sdns_rr *);
sdns_rr_NS * sdns_decode_rr_NS(sdns_context * ctx, sdns_rr * rr);
sdns_rr_PTR * sdns_decode_rr_PTR(sdns_context * ctx, sdns_rr * rr);
sdns_rr_CNAME* sdns_decode_rr_CNAME(sdns_context * ctx, sdns_rr * rr);  
sdns_rr_RRSIG * sdns_decode_rr_RRSIG(sdns_context * ctx, sdns_rr * rr);
sdns_rr_SRV * sdns_decode_rr_SRV(sdns_context * ctx, sdns_rr * rr);
sdns_rr_HINFO * sdns_decode_rr_HINFO(sdns_context * ctx, sdns_rr * rr);
sdns_rr_URI * sdns_decode_rr_URI(sdns_context * ctx, sdns_rr* rr);
sdns_rr_NID * sdns_decode_rr_NID(sdns_context * ctx, sdns_rr* rr);
sdns_rr_L32 * sdns_decode_rr_L32(sdns_context * ctx, sdns_rr* rr);
sdns_rr_L64 * sdns_decode_rr_L64(sdns_context * ctx, sdns_rr* rr);
sdns_rr_LP * sdns_decode_rr_LP(sdns_context * ctx, sdns_rr* rr);
sdns_rr_CAA * sdns_decode_rr_CAA(sdns_context * ctx, sdns_rr * rr);
 
sdns_opt_rdata * sdns_decode_rr_OPT(sdns_context * ctx, sdns_rr * rr);
 
 
 
sdns_rr_A* sdns_init_rr_A(uint32_t ipaddress);
 
sdns_rr_AAAA* sdns_init_rr_AAAA(char * aaaa);
 
 
sdns_rr_TXT* sdns_init_rr_TXT(char * data, uint16_t data_len);
 
sdns_rr_SRV * sdns_init_rr_SRV(uint16_t Priority, uint16_t Weight, uint16_t Port, char * target);
 
 
sdns_rr_MX * sdns_init_rr_MX(uint16_t preference, char * exchange);
 
sdns_rr_NS * sdns_init_rr_NS(char * nsdname);
 
 
sdns_rr_PTR * sdns_init_rr_PTR(char * ptrdname);
 
 
sdns_rr_CNAME * sdns_init_rr_CNAME(char * cname);
 
sdns_rr_NID * sdns_init_rr_NID(uint16_t preference, char * nodid);
 
 
sdns_rr_L32 * sdns_init_rr_L32(uint16_t preference, uint32_t locator32);
 
 
sdns_rr_L64 * sdns_init_rr_L64(uint16_t preference, char * locator64);
 
 
sdns_rr_LP * sdns_init_rr_LP(uint16_t preference, char * fqdn);
 
sdns_rr_CAA * sdns_init_rr_CAA(uint8_t flag, char * tag, uint8_t tag_len, char * value, uint16_t value_len);
 
 
void sdns_free_opt_rdata(sdns_opt_rdata * opt);
sdns_opt_rdata * sdns_init_opt_rdata(void);
 
sdns_rr_SRV * sdns_init_SRV(uint16_t, uint16_t, uint16_t, char *);
sdns_rr_URI * sdns_init_rr_URI(uint16_t, uint16_t, char *, uint16_t);
sdns_rr_RRSIG * sdns_init_rr_RRSIG(uint16_t, uint8_t, uint8_t, uint32_t, uint32_t, uint32_t, uint8_t, char *, char *, uint16_t);
sdns_rr_HINFO * sdns_init_rr_HINFO(uint8_t cpu_len, char * cpu, uint8_t os_len, char * os);
sdns_rr_SOA * sdns_init_rr_SOA(char * mname, char * rname, uint32_t expire, uint32_t minimum,
                               uint32_t refresh, uint32_t retry, uint32_t serial);
 
void sdns_free_rr_A(sdns_rr_A * a);
 
void sdns_free_rr_MX(sdns_rr_MX * mx);
 
void sdns_free_rr_TXT(sdns_rr_TXT * txt);
 
 
void sdns_free_rr_AAAA(sdns_rr_AAAA * aaaa);
 
 
void sdns_free_rr_SOA(sdns_rr_SOA * soa);
 
 
void sdns_free_rr_NS(sdns_rr_NS* ns);
 
 
void sdns_free_rr_PTR(sdns_rr_PTR* ptr);
 
 
 
void sdns_free_rr_CNAME(sdns_rr_CNAME* cname);
 
 
void sdns_free_rr_RRSIG(sdns_rr_RRSIG* rrsig);
 
 
void sdns_free_rr_SRV(sdns_rr_SRV* srv);
 
 
void sdns_free_rr_HINFO(sdns_rr_HINFO * hinfo);
 
 
void sdns_free_rr_URI(sdns_rr_URI * uri);
 
 
void sdns_free_rr_NID(sdns_rr_NID * nid);
 
 
void sdns_free_rr_L32(sdns_rr_L32 * l32);
 
 
void sdns_free_rr_L64(sdns_rr_L64 * l64);
 
 
void sdns_free_rr_LP(sdns_rr_LP * lp);
 
void sdns_free_rr_CAA(sdns_rr_CAA * caa);
 
 
int sdns_create_edns_option(uint16_t, uint16_t, char *, sdns_opt_rdata**);
int sdns_add_edns(sdns_context * ctx, sdns_opt_rdata * opt);
 
 
 
sdns_opt_rdata * sdns_create_edns0_ede(uint16_t info_code, char * extra_text, uint16_t extra_text_len);
 
int sdns_ends0_option_code_to_text(sdns_edns0_option_code oc, char * buffer);
 
sdns_opt_rdata * sdns_create_edns0_cookie(char * client_cookie, char * server_cookie, uint8_t server_cookie_len);
 
void sdns_rr_type_to_string(uint16_t t, char * buff);
 
 
void sdns_class_to_string(uint16_t cls, char * buff);
 
 
int sdns_convert_type_to_int(char * type);
 
 
int sdns_convert_class_to_int(char * cls);
 
 
void sdns_free_section(sdns_rr * rr);
 
 
 
#endif