RepoMirrors/haproxy
1
0
Fork 0
mirror of http://git.haproxy.org/git/haproxy.git/ synced 2025-01-31 18:41:39 +00:00
Code Issues Packages Projects Releases Wiki Activity
f5b8adc5c0
haproxy/include/proto/dns.h

69 lines
3.4 KiB
C
Raw Normal View History

MEDIUM: dns: implement a DNS resolver Implementation of a DNS client in HAProxy to perform name resolution to IP addresses. It relies on the freshly created UDP client to perform the DNS resolution. For now, all UDP socket calls are performed in the DNS layer, but this might change later when the protocols are extended to be more suited to datagram mode. A new section called 'resolvers' is introduced thanks to this patch. It is used to describe DNS servers IP address and also many parameters.
2015-04-13 21:40:55 +00:00
/*
* include/proto/dns.h
* This file provides functions related to DNS protocol
*
* Copyright (C) 2014 Baptiste Assmann <bedis9@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation, version 2.1
* exclusively.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef _PROTO_DNS_H
#define _PROTO_DNS_H
#include <types/dns.h>
#include <types/proto_udp.h>
CLEANUP/MINOR: dns: dns_str_to_dn_label() only needs a const char The string is an input, let's constify it.
2015-07-22 14:42:43 +00:00
char *dns_str_to_dn_label(const char *string, char *dn, int dn_len);
MEDIUM: dns: implement a DNS resolver Implementation of a DNS client in HAProxy to perform name resolution to IP addresses. It relies on the freshly created UDP client to perform the DNS resolution. For now, all UDP socket calls are performed in the DNS layer, but this might change later when the protocols are extended to be more suited to datagram mode. A new section called 'resolvers' is introduced thanks to this patch. It is used to describe DNS servers IP address and also many parameters.
2015-04-13 21:40:55 +00:00
int dns_str_to_dn_label_len(const char *string);
MINOR: dns: Handle SRV records. Make it so for each server, instead of specifying a hostname, one can use a SRV label. When doing so, haproxy will first resolve the SRV label, then use the resulting hostnames, as well as port and weight (priority is ignored right now), to each server using the SRV label. It is resolved periodically, and any server disappearing from the SRV records will be removed, and any server appearing will be added, assuming there're free servers in haproxy.
2017-08-04 16:35:36 +00:00
void dns_dn_label_to_str(char *dn, char *str, int dn_len);
MEDIUM: dns: implement a DNS resolver Implementation of a DNS client in HAProxy to perform name resolution to IP addresses. It relies on the freshly created UDP client to perform the DNS resolution. For now, all UDP socket calls are performed in the DNS layer, but this might change later when the protocols are extended to be more suited to datagram mode. A new section called 'resolvers' is introduced thanks to this patch. It is used to describe DNS servers IP address and also many parameters.
2015-04-13 21:40:55 +00:00
int dns_hostname_validation(const char *string, char **err);
MINOR: dns: enabled edns0 extension and make accpeted payload size tunable Edns extensions may be used to negotiate some settings between a DNS client and a server. For now we only use it to announce the maximum response payload size accpeted by HAProxy. This size can be set through a configuration parameter in the resolvers section. If not set, it defaults to 512 bytes.
2017-08-13 22:13:01 +00:00
int dns_build_query(int query_id, int query_type, unsigned int accepted_payload_size, char *hostname_dn, int hostname_dn_len, char *buf, int bufsize);
MEDIUM: dns: implement a DNS resolver Implementation of a DNS client in HAProxy to perform name resolution to IP addresses. It relies on the freshly created UDP client to perform the DNS resolution. For now, all UDP socket calls are performed in the DNS layer, but this might change later when the protocols are extended to be more suited to datagram mode. A new section called 'resolvers' is introduced thanks to this patch. It is used to describe DNS servers IP address and also many parameters.
2015-04-13 21:40:55 +00:00
struct task *dns_process_resolve(struct task *t);
MINOR: dns: give ability to dns_init_resolvers() to close a socket when requested The function dns_init_resolvers() is used to initialize socket used to send DNS queries. This patch gives the function the ability to close a socket before re-opening it. [wt: this needs to be backported to 1.7 for next fix]
2017-02-02 21:44:15 +00:00
int dns_init_resolvers(int close_socket);
MEDIUM: dns: implement a DNS resolver Implementation of a DNS client in HAProxy to perform name resolution to IP addresses. It relies on the freshly created UDP client to perform the DNS resolution. For now, all UDP socket calls are performed in the DNS layer, but this might change later when the protocols are extended to be more suited to datagram mode. A new section called 'resolvers' is introduced thanks to this patch. It is used to describe DNS servers IP address and also many parameters.
2015-04-13 21:40:55 +00:00
uint16_t dns_rnd16(void);
MINOR: dns: Maximum DNS udp payload set to 8192 Following up DNS extension introduction, this patch aims at making the computation of the maximum number of records in DNS response dynamic. This computation is based on the announced payload size accepted by HAProxy.
2017-08-18 21:35:08 +00:00
int dns_validate_dns_response(unsigned char *resp, unsigned char *bufend, struct dns_resolution *resolution, int max_answer_records);
MINOR: dns: new snr_check_ip_callback function In the process of breaking links between dns_* functions and other structures (mainly server and a bit of resolution), the function dns_get_ip_from_response needs to be reworked: it now can call "callback" functions based on resolution's owner type to allow modifying the way the response is processed. For now, main purpose of the callback function is to check that an IP address is not already affected to an element of the same type. For now, only server type has a callback.
2017-05-03 13:43:12 +00:00
int dns_get_ip_from_response(struct dns_response_packet *dns_p,
REORG: dns: dns_option structure, storage of hostname_dn This patch introduces a some re-organisation around the DNS code in HAProxy. 1. make the dns_* functions less dependent on 'struct server' and 'struct resolution'. With this in mind, the following changes were performed: - 'struct dns_options' has been removed from 'struct resolution' (well, we might need it back at some point later, we'll see) ==> we'll use the 'struct dns_options' from the owner of the resolution - dns_get_ip_from_response(): takes a 'struct dns_options' instead of 'struct resolution' ==> so the caller can pass its own dns options to get the most appropriate IP from the response - dns_process_resolve(): struct dns_option is deduced from new resolution->requester_type parameter 2. add hostname_dn and hostname_dn_len into struct server In order to avoid recomputing a server's hostname into its domain name format (and use a trash buffer to store the result), it is safer to compute it once at configuration parsing and to store it into the struct server. In the mean time, the struct resolution linked to the server doesn't need anymore to store the hostname in domain name format. A simple pointer to the server one will make the trick. The function srv_alloc_dns_resolution() properly manages everything for us: memory allocation, pointer updates, etc... 3. move resolvers pointer into struct server This patch makes the pointer to struct dns_resolvers from struct dns_resolution obsolete. Purpose is to make the resolution as "neutral" as possible and since the requester is already linked to the resolvers, then we don't need this information anymore in the resolution itself.
2017-05-03 10:12:02 +00:00
struct dns_options *dns_opts, void *currentip,
MEDIUM: dns: extract options DNS selection preferences are actually declared inline in the struct server. There are copied from the server struct to the dns_resolution struct for each resolution. Next patchs adds new preferences options, and it is not a good way to copy all the configuration information before each dns resolution. This patch extract the configuration preference from the struct server and declares a new dedicated struct. Only a pointer to this new striuict will be copied before each dns resolution.
2016-02-17 20:25:09 +00:00
short currentip_sin_family,
MINOR: dns: new snr_check_ip_callback function In the process of breaking links between dns_* functions and other structures (mainly server and a bit of resolution), the function dns_get_ip_from_response needs to be reworked: it now can call "callback" functions based on resolution's owner type to allow modifying the way the response is processed. For now, main purpose of the callback function is to check that an IP address is not already affected to an element of the same type. For now, only server type has a callback.
2017-05-03 13:43:12 +00:00
void **newip, short *newip_sin_family,
void *owner);
MEDIUM: dns: implement a DNS resolver Implementation of a DNS client in HAProxy to perform name resolution to IP addresses. It relies on the freshly created UDP client to perform the DNS resolution. For now, all UDP socket calls are performed in the DNS layer, but this might change later when the protocols are extended to be more suited to datagram mode. A new section called 'resolvers' is introduced thanks to this patch. It is used to describe DNS servers IP address and also many parameters.
2015-04-13 21:40:55 +00:00
void dns_resolve_send(struct dgram_conn *dgram);
void dns_resolve_recv(struct dgram_conn *dgram);
int dns_send_query(struct dns_resolution *resolution);
void dns_print_current_resolutions(struct dns_resolvers *resolvers);
void dns_update_resolvers_timeout(struct dns_resolvers *resolvers);
void dns_reset_resolution(struct dns_resolution *resolution);
MAJOR/REORG: dns: DNS resolution task and requester queues This patch is a major upgrade of the internal run-time DNS resolver in HAProxy and it brings the following 2 main changes: 1. DNS resolution task Up to now, DNS resolution was triggered by the health check task. From now, DNS resolution task is autonomous. It is started by HAProxy right after the scheduler is available and it is woken either when a network IO occurs for one of its nameserver or when a timeout is matched. From now, this means we can enable DNS resolution for a server without enabling health checking. 2. Introduction of a dns_requester structure Up to now, DNS resolution was purposely made for resolving server hostnames. The idea, is to ensure that any HAProxy internal object should be able to trigger a DNS resolution. For this purpose, 2 things has to be done: - clean up the DNS code from the server structure (this was already quite clean actually) and clean up the server's callbacks from manipulating too much DNS resolution - create an agnostic structure which allows linking a DNS resolution and a requester of any type (using obj_type enum) 3. Manage requesters through queues Up to now, there was an uniq relationship between a resolution and it's owner (aka the requester now). It's a shame, because in some cases, multiple objects may share the same hostname and may benefit from a resolution being performed by a third party. This patch introduces the notion of queues, which are basically lists of either currently running resolution or waiting ones. The resolutions are now available as a pool, which belongs to the resolvers. The pool has has a default size of 64 resolutions per resolvers and is allocated at configuration parsing.
2017-05-22 13:17:15 +00:00
void dns_resolution_free(struct dns_resolvers *resolvers, struct dns_resolution *resolution);
void dns_rm_requester_from_resolution(struct dns_requester *requester, struct dns_resolution *resolution);
MEDIUM: dns: implement a DNS resolver Implementation of a DNS client in HAProxy to perform name resolution to IP addresses. It relies on the freshly created UDP client to perform the DNS resolution. For now, all UDP socket calls are performed in the DNS layer, but this might change later when the protocols are extended to be more suited to datagram mode. A new section called 'resolvers' is introduced thanks to this patch. It is used to describe DNS servers IP address and also many parameters.
2015-04-13 21:40:55 +00:00
int dns_check_resolution_queue(struct dns_resolvers *resolvers);
MINOR: fix the return type for dns_response_get_query_id() function This function should return a 16-bit type as that is the type for dns header id. Also because it is doing an uint16 unpack big-endian operation. Backport: can be backported to 1.6 Signed-off-by: Thiago Farina <tfarina@chromium.org> Signed-off-by: Baptiste Assmann <bedis9@gmail.com>
2016-01-20 22:46:34 +00:00
unsigned short dns_response_get_query_id(unsigned char *resp);
MINOR: dns: functions to manage memory for a DNS resolution structure A couple of new functions to allocate and free memory for a DNS resolution structure. Main purpose is to to make the code related to DNS more consistent. They allocate or free memory for the structure itself. Later, if needed, they should also allocate / free the buffers, etc, used by this structure. They don't set/unset any parameters, this is the role of the caller. This patch also implement calls to these function eveywhere it is required.
2017-05-03 08:11:44 +00:00
struct dns_resolution *dns_alloc_resolution(void);
void dns_free_resolution(struct dns_resolution *resolution);
MINOR: dns: implement a LRU cache for DNS resolutions Introduction of a DNS response LRU cache in HAProxy. When a positive response is received from a DNS server, HAProxy stores it in the struct resolution and then also populates a LRU cache with the response. For now, the key in the cache is a XXHASH64 of the hostname in the domain name format concatened to the query type in string format.
2017-05-04 07:05:00 +00:00
struct chunk *dns_cache_key(int query_type, char *hostname_dn, int hostname_dn_len, struct chunk *buf);
struct lru64 *dns_cache_lookup(int query_type, char *hostname_dn, int hostname_dn_len, int valid_period, void *cache_domain);
MAJOR/REORG: dns: DNS resolution task and requester queues This patch is a major upgrade of the internal run-time DNS resolver in HAProxy and it brings the following 2 main changes: 1. DNS resolution task Up to now, DNS resolution was triggered by the health check task. From now, DNS resolution task is autonomous. It is started by HAProxy right after the scheduler is available and it is woken either when a network IO occurs for one of its nameserver or when a timeout is matched. From now, this means we can enable DNS resolution for a server without enabling health checking. 2. Introduction of a dns_requester structure Up to now, DNS resolution was purposely made for resolving server hostnames. The idea, is to ensure that any HAProxy internal object should be able to trigger a DNS resolution. For this purpose, 2 things has to be done: - clean up the DNS code from the server structure (this was already quite clean actually) and clean up the server's callbacks from manipulating too much DNS resolution - create an agnostic structure which allows linking a DNS resolution and a requester of any type (using obj_type enum) 3. Manage requesters through queues Up to now, there was an uniq relationship between a resolution and it's owner (aka the requester now). It's a shame, because in some cases, multiple objects may share the same hostname and may benefit from a resolution being performed by a third party. This patch introduces the notion of queues, which are basically lists of either currently running resolution or waiting ones. The resolutions are now available as a pool, which belongs to the resolvers. The pool has has a default size of 64 resolutions per resolvers and is allocated at configuration parsing.
2017-05-22 13:17:15 +00:00
int dns_link_resolution(void *requester, int requester_type, struct dns_resolution *resolution);
struct dns_resolution *dns_resolution_list_get(struct dns_resolvers *resolvers, char *hostname_dn, int query_type);
int dns_trigger_resolution(struct dns_resolution *resolution);
int dns_alloc_resolution_pool(struct dns_resolvers *resolvers);
void dump_dns_config(void);
/*
* erases all information of a dns_requester structure
*/
#define dns_clear_requester(requester) memset(requester, '\0', sizeof(*requester));
MEDIUM: dns: implement a DNS resolver Implementation of a DNS client in HAProxy to perform name resolution to IP addresses. It relies on the freshly created UDP client to perform the DNS resolution. For now, all UDP socket calls are performed in the DNS layer, but this might change later when the protocols are extended to be more suited to datagram mode. A new section called 'resolvers' is introduced thanks to this patch. It is used to describe DNS servers IP address and also many parameters.
2015-04-13 21:40:55 +00:00
#endif // _PROTO_DNS_H
Reference in New Issue Copy Permalink