Try to qualify relative names in the DNS resolver using the DHCP Domain
Name. For example:
DHCP Domain Name: etherboot.org
(Relative) Name: www
yields:
www.etherboot.org
Names that are already qualified are not affected.
---
src/include/gpxe/settings.h | 1 +
src/net/udp/dns.c | 49 ++++++++++++++++++++++++++++++++++++++++++-
2 files changed, 49 insertions(+), 1 deletions(-)
diff --git a/src/include/gpxe/settings.h b/src/include/gpxe/settings.h
index 37c01b0..7505150 100644
--- a/src/include/gpxe/settings.h
+++ b/src/include/gpxe/settings.h
@@ -215,6 +215,7 @@ extern struct setting ip_setting __setting;
extern struct setting netmask_setting __setting;
extern struct setting gateway_setting __setting;
extern struct setting dns_setting __setting;
+extern struct setting domain_setting __setting;
extern struct setting hostname_setting __setting;
extern struct setting filename_setting __setting;
extern struct setting root_path_setting __setting;
diff --git a/src/net/udp/dns.c b/src/net/udp/dns.c
index 1bcdbc7..de7ac5c 100644
--- a/src/net/udp/dns.c
+++ b/src/net/udp/dns.c
@@ -22,6 +22,7 @@
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
+#include <stdio.h>
#include <errno.h>
#include <byteswap.h>
#include <gpxe/refcnt.h>
@@ -180,6 +181,36 @@ static union dns_rr_info * dns_find_rr ( struct
dns_request *dns,
}
/**
+ * Append DHCP domain name if available and name is not fully qualified
+ *
+ * @v string Name as a NUL-terminated string
+ * @ret fqdn Fully-qualified domain name, malloc''d copy
+ *
+ * The caller must free fqdn which is allocated even if the name is already
+ * fully qualified.
+ */
+static char * dns_qualify_name ( const char *string ) {
+ char *fqdn;
+ char domain[256]; /* local domain */
+
+ /* Already fully-qualified? */
+ if ( strchr ( string, ''.'' ) )
+ goto treat_as_fqdn;
+
+ /* Get local domain DHCP option */
+ if ( fetch_string_setting ( NULL, &domain_setting,
+ domain, sizeof domain ) <= 0 )
+ goto treat_as_fqdn;
+
+ /* Append local domain to name */
+ asprintf ( &fqdn, "%s.%s", string, domain );
+ return fqdn;
+
+treat_as_fqdn:
+ return strdup ( string );
+}
+
+/**
* Convert a standard NUL-terminated string to a DNS name
*
* @v string Name as a NUL-terminated string
@@ -452,6 +483,7 @@ static struct xfer_interface_operations
dns_socket_operations = {
static int dns_resolv ( struct resolv_interface *resolv,
const char *name, struct sockaddr *sa ) {
struct dns_request *dns;
+ char *fqdn = NULL;
int rc;
/* Fail immediately if no DNS servers */
@@ -461,6 +493,11 @@ static int dns_resolv ( struct resolv_interface *resolv,
return -ENXIO;
}
+ /* Ensure fully-qualified domain name if DHCP option was given */
+ fqdn = dns_qualify_name ( name );
+ if ( ! fqdn )
+ return -ENOMEM;
+
/* Allocate DNS structure */
dns = zalloc ( sizeof ( *dns ) );
if ( ! dns )
@@ -474,7 +511,7 @@ static int dns_resolv ( struct resolv_interface *resolv,
dns->query.dns.flags = htons ( DNS_FLAG_QUERY | DNS_FLAG_OPCODE_QUERY |
DNS_FLAG_RD );
dns->query.dns.qdcount = htons ( 1 );
- dns->qinfo = ( void * ) dns_make_name ( name, dns->query.payload );
+ dns->qinfo = ( void * ) dns_make_name ( fqdn, dns->query.payload );
dns->qinfo->qtype = htons ( DNS_TYPE_A );
dns->qinfo->qclass = htons ( DNS_CLASS_IN );
@@ -493,10 +530,12 @@ static int dns_resolv ( struct resolv_interface *resolv,
/* Attach parent interface, mortalise self, and return */
resolv_plug_plug ( &dns->resolv, resolv );
ref_put ( &dns->refcnt );
+ free ( fqdn );
return 0;
err:
ref_put ( &dns->refcnt );
+ free ( fqdn );
return rc;
}
@@ -521,6 +560,14 @@ struct setting dns_setting __setting = {
.type = &setting_type_ipv4,
};
+/** Domain name setting */
+struct setting domain_setting __setting = {
+ .name = "domain",
+ .description = "Local domain",
+ .tag = DHCP_DOMAIN_NAME,
+ .type = &setting_type_string,
+};
+
/**
* Apply nameserver setting
*
--
1.5.6.5
------=_Part_18453_5249765.1227777980812
Content-Type: text/x-diff; name=domain.diff
Content-Transfer-Encoding: base64
X-Attachment-Id: f_fo17zmhd0
Content-Disposition: attachment; filename=domain.diff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------=_Part_18453_5249765.1227777980812--