2014-07-16 00:26:02 +02:00
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
/***
This file is part of systemd .
Copyright 2014 Lennart Poettering
systemd 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 ; either version 2.1 of the License , or
( at your option ) any later version .
systemd 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 systemd ; If not , see < http : //www.gnu.org/licenses/>.
* * */
2015-10-27 03:01:06 +01:00
# include "alloc-util.h"
2014-12-10 19:00:46 +01:00
# include "bus-common-errors.h"
2014-07-16 00:26:02 +02:00
# include "bus-util.h"
2015-06-02 20:49:43 +02:00
# include "dns-domain.h"
2014-08-01 16:14:59 +02:00
# include "resolved-bus.h"
2014-08-14 01:00:15 +02:00
# include "resolved-def.h"
2014-07-16 00:26:02 +02:00
2014-07-16 20:15:47 +02:00
static int reply_query_state ( DnsQuery * q ) {
_cleanup_free_ char * ip = NULL ;
const char * name ;
2014-07-16 00:26:02 +02:00
int r ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
if ( q - > request_address_valid ) {
2014-07-16 20:15:47 +02:00
r = in_addr_to_string ( q - > request_family , & q - > request_address , & ip ) ;
if ( r < 0 )
return r ;
2014-07-16 00:26:02 +02:00
2014-07-16 20:15:47 +02:00
name = ip ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
} else
2015-11-24 01:25:24 +01:00
name = dns_question_first_name ( q - > question ) ;
2014-07-16 20:15:47 +02:00
switch ( q - > state ) {
2014-07-16 00:26:02 +02:00
2014-07-31 17:46:40 +02:00
case DNS_TRANSACTION_NO_SERVERS :
2014-07-16 22:50:41 +02:00
return sd_bus_reply_method_errorf ( q - > request , BUS_ERROR_NO_NAME_SERVERS , " No appropriate name servers or networks for name found " ) ;
2014-07-16 00:26:02 +02:00
2014-07-31 17:46:40 +02:00
case DNS_TRANSACTION_TIMEOUT :
2014-07-16 20:15:47 +02:00
return sd_bus_reply_method_errorf ( q - > request , SD_BUS_ERROR_TIMEOUT , " Query timed out " ) ;
2014-07-16 00:26:02 +02:00
2014-07-31 17:46:40 +02:00
case DNS_TRANSACTION_ATTEMPTS_MAX_REACHED :
2014-07-16 20:15:47 +02:00
return sd_bus_reply_method_errorf ( q - > request , SD_BUS_ERROR_TIMEOUT , " All attempts to contact name servers or networks failed " ) ;
2014-08-06 16:32:17 +02:00
case DNS_TRANSACTION_INVALID_REPLY :
return sd_bus_reply_method_errorf ( q - > request , BUS_ERROR_INVALID_REPLY , " Received invalid reply " ) ;
2014-07-31 17:46:40 +02:00
case DNS_TRANSACTION_RESOURCES :
2014-07-16 20:15:47 +02:00
return sd_bus_reply_method_errorf ( q - > request , BUS_ERROR_NO_RESOURCES , " Not enough resources " ) ;
2014-08-06 16:32:17 +02:00
case DNS_TRANSACTION_ABORTED :
return sd_bus_reply_method_errorf ( q - > request , BUS_ERROR_ABORTED , " Query aborted " ) ;
2014-07-16 00:26:02 +02:00
2014-07-31 17:46:40 +02:00
case DNS_TRANSACTION_FAILURE : {
2014-07-16 00:26:02 +02:00
_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL ;
2014-07-22 21:48:41 +02:00
if ( q - > answer_rcode = = DNS_RCODE_NXDOMAIN )
2014-07-16 20:15:47 +02:00
sd_bus_error_setf ( & error , _BUS_ERROR_DNS " NXDOMAIN " , " '%s' not found " , name ) ;
2014-07-16 00:26:02 +02:00
else {
const char * rc , * n ;
2014-07-16 20:15:47 +02:00
char p [ 3 ] ; /* the rcode is 4 bits long */
2014-07-16 00:26:02 +02:00
2014-07-22 21:48:41 +02:00
rc = dns_rcode_to_string ( q - > answer_rcode ) ;
2014-07-16 00:26:02 +02:00
if ( ! rc ) {
2014-07-22 21:48:41 +02:00
sprintf ( p , " %i " , q - > answer_rcode ) ;
2014-07-16 00:26:02 +02:00
rc = p ;
}
2015-02-03 02:05:59 +01:00
n = strjoina ( _BUS_ERROR_DNS , rc ) ;
2014-07-16 20:15:47 +02:00
sd_bus_error_setf ( & error , n , " Could not resolve '%s', server or network returned error %s " , name , rc ) ;
2014-07-16 00:26:02 +02:00
}
2014-07-16 20:15:47 +02:00
return sd_bus_reply_method_error ( q - > request , & error ) ;
2014-07-16 00:26:02 +02:00
}
2014-07-31 17:46:40 +02:00
case DNS_TRANSACTION_NULL :
case DNS_TRANSACTION_PENDING :
case DNS_TRANSACTION_SUCCESS :
2014-07-16 22:09:00 +02:00
default :
2014-07-16 20:15:47 +02:00
assert_not_reached ( " Impossible state " ) ;
}
}
2014-07-16 00:26:02 +02:00
2015-08-17 23:54:08 +02:00
static int append_address ( sd_bus_message * reply , DnsResourceRecord * rr , int ifindex ) {
2014-07-16 22:09:00 +02:00
int r ;
assert ( reply ) ;
assert ( rr ) ;
2015-08-17 23:54:08 +02:00
r = sd_bus_message_open_container ( reply , ' r ' , " iiay " ) ;
if ( r < 0 )
return r ;
r = sd_bus_message_append ( reply , " i " , ifindex ) ;
2014-07-16 22:09:00 +02:00
if ( r < 0 )
return r ;
2014-07-22 21:48:41 +02:00
if ( rr - > key - > type = = DNS_TYPE_A ) {
2014-07-18 16:09:30 +02:00
r = sd_bus_message_append ( reply , " i " , AF_INET ) ;
2014-07-16 22:09:00 +02:00
if ( r < 0 )
return r ;
r = sd_bus_message_append_array ( reply , ' y ' , & rr - > a . in_addr , sizeof ( struct in_addr ) ) ;
2014-07-22 21:48:41 +02:00
} else if ( rr - > key - > type = = DNS_TYPE_AAAA ) {
2014-07-18 16:09:30 +02:00
r = sd_bus_message_append ( reply , " i " , AF_INET6 ) ;
2014-07-16 22:09:00 +02:00
if ( r < 0 )
return r ;
r = sd_bus_message_append_array ( reply , ' y ' , & rr - > aaaa . in6_addr , sizeof ( struct in6_addr ) ) ;
2014-07-22 21:48:41 +02:00
} else
return - EAFNOSUPPORT ;
2014-07-16 22:09:00 +02:00
if ( r < 0 )
return r ;
r = sd_bus_message_close_container ( reply ) ;
if ( r < 0 )
return r ;
return 0 ;
}
2014-07-16 20:15:47 +02:00
static void bus_method_resolve_hostname_complete ( DnsQuery * q ) {
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
_cleanup_ ( dns_resource_record_unrefp ) DnsResourceRecord * canonical = NULL ;
2014-07-16 20:15:47 +02:00
_cleanup_bus_message_unref_ sd_bus_message * reply = NULL ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
unsigned added = 0 ;
2014-08-14 01:00:15 +02:00
int r ;
2014-07-16 00:26:02 +02:00
2014-07-16 20:15:47 +02:00
assert ( q ) ;
2014-07-16 00:26:02 +02:00
2014-07-31 17:46:40 +02:00
if ( q - > state ! = DNS_TRANSACTION_SUCCESS ) {
2014-07-16 20:15:47 +02:00
r = reply_query_state ( q ) ;
goto finish ;
}
2014-07-16 00:26:02 +02:00
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
r = dns_query_process_cname ( q ) ;
if ( r = = - ELOOP ) {
2015-11-24 01:25:24 +01:00
r = sd_bus_reply_method_errorf ( q - > request , BUS_ERROR_CNAME_LOOP , " CNAME loop detected, or CNAME resolving disabled on '%s' " , dns_question_first_name ( q - > question ) ) ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
goto finish ;
}
if ( r < 0 )
goto finish ;
if ( r > 0 ) /* This was a cname, and the query was restarted. */
return ;
2014-07-16 20:15:47 +02:00
r = sd_bus_message_new_method_return ( q - > request , & reply ) ;
if ( r < 0 )
goto finish ;
2014-07-16 00:26:02 +02:00
2015-08-17 23:54:08 +02:00
r = sd_bus_message_open_container ( reply , ' a ' , " (iiay) " ) ;
2014-08-14 01:00:15 +02:00
if ( r < 0 )
goto finish ;
2014-07-16 22:09:00 +02:00
2014-07-30 17:52:58 +02:00
if ( q - > answer ) {
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
DnsResourceRecord * rr ;
int ifindex ;
2014-07-30 17:52:58 +02:00
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
DNS_ANSWER_FOREACH_IFINDEX ( rr , ifindex , q - > answer ) {
2015-11-25 20:47:27 +01:00
r = dns_question_matches_rr ( q - > question , rr , DNS_SEARCH_DOMAIN_NAME ( q - > answer_search_domain ) ) ;
2014-07-16 22:09:00 +02:00
if ( r < 0 )
2014-07-30 19:23:27 +02:00
goto finish ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
if ( r = = 0 )
2014-07-30 17:52:58 +02:00
continue ;
2014-07-16 00:26:02 +02:00
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
r = append_address ( reply , rr , ifindex ) ;
2014-07-30 17:52:58 +02:00
if ( r < 0 )
goto finish ;
2014-07-16 00:26:02 +02:00
2014-07-30 17:52:58 +02:00
if ( ! canonical )
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
canonical = dns_resource_record_ref ( rr ) ;
2014-07-16 22:50:41 +02:00
2014-07-30 17:52:58 +02:00
added + + ;
}
2014-07-16 22:09:00 +02:00
}
2014-07-16 00:26:02 +02:00
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
if ( added < = 0 ) {
2015-11-24 01:25:24 +01:00
r = sd_bus_reply_method_errorf ( q - > request , BUS_ERROR_NO_SUCH_RR , " '%s' does not have any RR of the requested type " , dns_question_first_name ( q - > question ) ) ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
goto finish ;
2014-07-16 00:26:02 +02:00
}
2014-07-16 20:15:47 +02:00
r = sd_bus_message_close_container ( reply ) ;
if ( r < 0 )
goto finish ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
/* Return the precise spelling and uppercasing and CNAME target reported by the server */
2014-07-16 22:50:41 +02:00
assert ( canonical ) ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
r = sd_bus_message_append (
reply , " st " ,
DNS_RESOURCE_KEY_NAME ( canonical - > key ) ,
SD_RESOLVED_FLAGS_MAKE ( q - > answer_protocol , q - > answer_family ) ) ;
2014-07-16 22:50:41 +02:00
if ( r < 0 )
goto finish ;
2014-07-16 20:15:47 +02:00
r = sd_bus_send ( q - > manager - > bus , reply , NULL ) ;
2014-07-16 00:26:02 +02:00
finish :
2014-07-30 19:23:27 +02:00
if ( r < 0 ) {
2014-11-28 13:19:16 +01:00
log_error_errno ( r , " Failed to send hostname reply: %m " ) ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
sd_bus_reply_method_errno ( q - > request , r , NULL ) ;
2014-07-30 19:23:27 +02:00
}
2014-07-16 00:26:02 +02:00
dns_query_free ( q ) ;
}
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
static int check_ifindex_flags ( int ifindex , uint64_t * flags , uint64_t ok , sd_bus_error * error ) {
2014-08-14 01:00:15 +02:00
assert ( flags ) ;
if ( ifindex < 0 )
return sd_bus_error_setf ( error , SD_BUS_ERROR_INVALID_ARGS , " Invalid interface index " ) ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
if ( * flags & ~ ( SD_RESOLVED_PROTOCOLS_ALL | SD_RESOLVED_NO_CNAME | ok ) )
2014-08-14 01:00:15 +02:00
return sd_bus_error_setf ( error , SD_BUS_ERROR_INVALID_ARGS , " Invalid flags parameter " ) ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
if ( ( * flags & SD_RESOLVED_PROTOCOLS_ALL ) = = 0 ) /* If no protocol is enabled, enable all */
* flags | = SD_RESOLVED_PROTOCOLS_ALL ;
2014-08-14 01:00:15 +02:00
return 0 ;
}
2015-04-29 18:35:10 +02:00
static int bus_method_resolve_hostname ( sd_bus_message * message , void * userdata , sd_bus_error * error ) {
2014-07-22 21:48:41 +02:00
_cleanup_ ( dns_question_unrefp ) DnsQuestion * question = NULL ;
2014-07-16 00:26:02 +02:00
Manager * m = userdata ;
const char * hostname ;
2014-08-14 01:00:15 +02:00
int family , ifindex ;
uint64_t flags ;
2014-07-16 00:26:02 +02:00
DnsQuery * q ;
int r ;
assert ( message ) ;
assert ( m ) ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
assert_cc ( sizeof ( int ) = = sizeof ( int32_t ) ) ;
2014-08-14 01:00:15 +02:00
r = sd_bus_message_read ( message , " isit " , & ifindex , & hostname , & family , & flags ) ;
2014-07-16 00:26:02 +02:00
if ( r < 0 )
return r ;
if ( ! IN_SET ( family , AF_INET , AF_INET6 , AF_UNSPEC ) )
2014-07-18 16:09:30 +02:00
return sd_bus_error_setf ( error , SD_BUS_ERROR_INVALID_ARGS , " Unknown address family %i " , family ) ;
2014-07-16 00:26:02 +02:00
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
r = dns_name_is_valid ( hostname ) ;
2014-07-31 19:53:59 +02:00
if ( r < 0 )
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
return r ;
if ( r = = 0 )
2014-07-16 00:26:02 +02:00
return sd_bus_error_setf ( error , SD_BUS_ERROR_INVALID_ARGS , " Invalid hostname '%s' " , hostname ) ;
2015-11-25 20:47:27 +01:00
r = check_ifindex_flags ( ifindex , & flags , SD_RESOLVED_NO_SEARCH , error ) ;
2014-08-14 01:00:15 +02:00
if ( r < 0 )
return r ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
r = dns_question_new_address ( & question , family , hostname ) ;
if ( r < 0 )
return r ;
2014-07-16 00:26:02 +02:00
2014-08-14 01:00:15 +02:00
r = dns_query_new ( m , & q , question , ifindex , flags ) ;
2014-07-16 00:26:02 +02:00
if ( r < 0 )
return r ;
q - > request = sd_bus_message_ref ( message ) ;
q - > request_family = family ;
q - > complete = bus_method_resolve_hostname_complete ;
2015-04-29 19:10:09 +02:00
r = dns_query_bus_track ( q , message ) ;
2014-08-06 16:32:55 +02:00
if ( r < 0 )
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
goto fail ;
2014-08-06 16:32:55 +02:00
2014-07-17 19:38:37 +02:00
r = dns_query_go ( q ) ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
if ( r < 0 )
goto fail ;
2014-07-16 00:26:02 +02:00
return 1 ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
fail :
dns_query_free ( q ) ;
return r ;
2014-07-16 00:26:02 +02:00
}
static void bus_method_resolve_address_complete ( DnsQuery * q ) {
2014-07-16 20:15:47 +02:00
_cleanup_bus_message_unref_ sd_bus_message * reply = NULL ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
DnsResourceRecord * rr ;
unsigned added = 0 ;
int ifindex , r ;
2014-07-16 00:26:02 +02:00
assert ( q ) ;
2014-07-31 17:46:40 +02:00
if ( q - > state ! = DNS_TRANSACTION_SUCCESS ) {
2014-07-16 20:15:47 +02:00
r = reply_query_state ( q ) ;
goto finish ;
}
2014-07-16 00:26:02 +02:00
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
/* We don't process CNAME for PTR lookups. */
2014-07-16 20:15:47 +02:00
r = sd_bus_message_new_method_return ( q - > request , & reply ) ;
if ( r < 0 )
goto finish ;
2014-07-16 00:26:02 +02:00
2015-08-17 23:54:08 +02:00
r = sd_bus_message_open_container ( reply , ' a ' , " (is) " ) ;
2014-07-16 20:15:47 +02:00
if ( r < 0 )
goto finish ;
2014-07-16 00:26:02 +02:00
2014-07-30 17:52:58 +02:00
if ( q - > answer ) {
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
DNS_ANSWER_FOREACH_IFINDEX ( rr , ifindex , q - > answer ) {
2015-11-25 20:47:27 +01:00
r = dns_question_matches_rr ( q - > question , rr , NULL ) ;
2014-07-30 17:52:58 +02:00
if ( r < 0 )
2014-07-30 19:23:27 +02:00
goto finish ;
2014-07-30 17:52:58 +02:00
if ( r = = 0 )
continue ;
2014-07-16 00:26:02 +02:00
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
r = sd_bus_message_append ( reply , " (is) " , ifindex , rr - > ptr . name ) ;
2014-07-30 17:52:58 +02:00
if ( r < 0 )
goto finish ;
2014-07-16 00:26:02 +02:00
2014-07-30 17:52:58 +02:00
added + + ;
}
2014-07-16 20:15:47 +02:00
}
2014-07-16 00:26:02 +02:00
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
if ( added < = 0 ) {
2014-07-16 20:15:47 +02:00
_cleanup_free_ char * ip = NULL ;
2014-07-16 00:26:02 +02:00
2014-07-16 20:15:47 +02:00
in_addr_to_string ( q - > request_family , & q - > request_address , & ip ) ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
r = sd_bus_reply_method_errorf ( q - > request , BUS_ERROR_NO_SUCH_RR , " Address '%s' does not have any RR of requested type " , strna ( ip ) ) ;
2014-07-16 20:15:47 +02:00
goto finish ;
2014-07-16 00:26:02 +02:00
}
2014-07-16 20:15:47 +02:00
r = sd_bus_message_close_container ( reply ) ;
if ( r < 0 )
goto finish ;
2014-07-16 00:26:02 +02:00
2014-08-14 01:00:15 +02:00
r = sd_bus_message_append ( reply , " t " , SD_RESOLVED_FLAGS_MAKE ( q - > answer_protocol , q - > answer_family ) ) ;
if ( r < 0 )
goto finish ;
2014-07-16 20:15:47 +02:00
r = sd_bus_send ( q - > manager - > bus , reply , NULL ) ;
2014-07-16 00:26:02 +02:00
finish :
2014-07-30 19:23:27 +02:00
if ( r < 0 ) {
2014-11-28 13:19:16 +01:00
log_error_errno ( r , " Failed to send address reply: %m " ) ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
sd_bus_reply_method_errno ( q - > request , r , NULL ) ;
2014-07-30 19:23:27 +02:00
}
2014-07-16 00:26:02 +02:00
dns_query_free ( q ) ;
}
2015-04-29 18:35:10 +02:00
static int bus_method_resolve_address ( sd_bus_message * message , void * userdata , sd_bus_error * error ) {
2014-07-22 21:48:41 +02:00
_cleanup_ ( dns_question_unrefp ) DnsQuestion * question = NULL ;
2014-07-16 00:26:02 +02:00
Manager * m = userdata ;
2014-07-22 21:48:41 +02:00
int family , ifindex ;
2014-08-14 01:00:15 +02:00
uint64_t flags ;
2014-07-16 00:26:02 +02:00
const void * d ;
DnsQuery * q ;
size_t sz ;
int r ;
assert ( message ) ;
assert ( m ) ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
assert_cc ( sizeof ( int ) = = sizeof ( int32_t ) ) ;
2014-08-14 01:00:15 +02:00
r = sd_bus_message_read ( message , " ii " , & ifindex , & family ) ;
2014-07-16 00:26:02 +02:00
if ( r < 0 )
return r ;
if ( ! IN_SET ( family , AF_INET , AF_INET6 ) )
2014-07-18 16:09:30 +02:00
return sd_bus_error_setf ( error , SD_BUS_ERROR_INVALID_ARGS , " Unknown address family %i " , family ) ;
2014-07-16 00:26:02 +02:00
r = sd_bus_message_read_array ( message , ' y ' , & d , & sz ) ;
if ( r < 0 )
return r ;
2014-07-18 16:09:30 +02:00
if ( sz ! = FAMILY_ADDRESS_SIZE ( family ) )
2014-07-16 00:26:02 +02:00
return sd_bus_error_setf ( error , SD_BUS_ERROR_INVALID_ARGS , " Invalid address size " ) ;
2014-08-14 01:00:15 +02:00
r = sd_bus_message_read ( message , " t " , & flags ) ;
if ( r < 0 )
return r ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
r = check_ifindex_flags ( ifindex , & flags , 0 , error ) ;
2014-07-22 21:48:41 +02:00
if ( r < 0 )
return r ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
r = dns_question_new_reverse ( & question , family , d ) ;
2014-07-16 00:26:02 +02:00
if ( r < 0 )
return r ;
2015-11-25 20:47:27 +01:00
r = dns_query_new ( m , & q , question , ifindex , flags | SD_RESOLVED_NO_SEARCH ) ;
2014-07-16 00:26:02 +02:00
if ( r < 0 )
return r ;
q - > request = sd_bus_message_ref ( message ) ;
q - > request_family = family ;
memcpy ( & q - > request_address , d , sz ) ;
q - > complete = bus_method_resolve_address_complete ;
2015-04-29 19:10:09 +02:00
r = dns_query_bus_track ( q , message ) ;
2014-08-06 16:32:55 +02:00
if ( r < 0 )
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
goto fail ;
2014-08-06 16:32:55 +02:00
2014-07-17 19:38:37 +02:00
r = dns_query_go ( q ) ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
if ( r < 0 )
goto fail ;
2014-07-16 00:26:02 +02:00
return 1 ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
fail :
dns_query_free ( q ) ;
return r ;
}
static int bus_message_append_rr ( sd_bus_message * m , DnsResourceRecord * rr , int ifindex ) {
_cleanup_ ( dns_packet_unrefp ) DnsPacket * p = NULL ;
size_t start ;
int r ;
assert ( m ) ;
assert ( rr ) ;
r = sd_bus_message_open_container ( m , ' r ' , " iqqay " ) ;
if ( r < 0 )
return r ;
r = sd_bus_message_append ( m , " iqq " ,
ifindex ,
rr - > key - > class ,
rr - > key - > type ) ;
if ( r < 0 )
return r ;
r = dns_packet_new ( & p , DNS_PROTOCOL_DNS , 0 ) ;
if ( r < 0 )
return r ;
p - > refuse_compression = true ;
r = dns_packet_append_rr ( p , rr , & start ) ;
if ( r < 0 )
return r ;
r = sd_bus_message_append_array ( m , ' y ' , DNS_PACKET_DATA ( p ) + start , p - > size - start ) ;
if ( r < 0 )
return r ;
return sd_bus_message_close_container ( m ) ;
2014-07-16 00:26:02 +02:00
}
2014-07-30 19:23:27 +02:00
static void bus_method_resolve_record_complete ( DnsQuery * q ) {
_cleanup_bus_message_unref_ sd_bus_message * reply = NULL ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
unsigned added = 0 ;
2014-07-30 19:23:27 +02:00
int r ;
assert ( q ) ;
2014-07-31 17:46:40 +02:00
if ( q - > state ! = DNS_TRANSACTION_SUCCESS ) {
2014-07-30 19:23:27 +02:00
r = reply_query_state ( q ) ;
goto finish ;
}
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
r = dns_query_process_cname ( q ) ;
if ( r = = - ELOOP ) {
2015-11-24 01:25:24 +01:00
r = sd_bus_reply_method_errorf ( q - > request , BUS_ERROR_CNAME_LOOP , " CNAME loop detected, or CNAME resolving disabled on '%s' " , dns_question_first_name ( q - > question ) ) ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
goto finish ;
}
if ( r < 0 )
goto finish ;
if ( r > 0 ) /* Following a CNAME */
return ;
2014-07-30 19:23:27 +02:00
r = sd_bus_message_new_method_return ( q - > request , & reply ) ;
if ( r < 0 )
goto finish ;
2015-08-17 23:54:08 +02:00
r = sd_bus_message_open_container ( reply , ' a ' , " (iqqay) " ) ;
2014-07-30 19:23:27 +02:00
if ( r < 0 )
goto finish ;
if ( q - > answer ) {
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
DnsResourceRecord * rr ;
int ifindex ;
2014-07-30 19:23:27 +02:00
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
DNS_ANSWER_FOREACH_IFINDEX ( rr , ifindex , q - > answer ) {
2015-11-25 20:47:27 +01:00
r = dns_question_matches_rr ( q - > question , rr , NULL ) ;
2014-07-30 19:23:27 +02:00
if ( r < 0 )
goto finish ;
if ( r = = 0 )
continue ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
r = bus_message_append_rr ( reply , rr , ifindex ) ;
2014-07-30 19:23:27 +02:00
if ( r < 0 )
goto finish ;
added + + ;
}
}
if ( added < = 0 ) {
2015-11-24 01:25:24 +01:00
r = sd_bus_reply_method_errorf ( q - > request , BUS_ERROR_NO_SUCH_RR , " Name '%s' does not have any RR of the requested type " , dns_question_first_name ( q - > question ) ) ;
2014-07-30 19:23:27 +02:00
goto finish ;
}
r = sd_bus_message_close_container ( reply ) ;
if ( r < 0 )
goto finish ;
2014-08-14 01:00:15 +02:00
r = sd_bus_message_append ( reply , " t " , SD_RESOLVED_FLAGS_MAKE ( q - > answer_protocol , q - > answer_family ) ) ;
if ( r < 0 )
goto finish ;
2014-07-30 19:23:27 +02:00
r = sd_bus_send ( q - > manager - > bus , reply , NULL ) ;
finish :
if ( r < 0 ) {
2014-11-28 13:19:16 +01:00
log_error_errno ( r , " Failed to send record reply: %m " ) ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
sd_bus_reply_method_errno ( q - > request , r , NULL ) ;
2014-07-30 19:23:27 +02:00
}
dns_query_free ( q ) ;
}
2015-04-29 18:35:10 +02:00
static int bus_method_resolve_record ( sd_bus_message * message , void * userdata , sd_bus_error * error ) {
2014-07-30 19:23:27 +02:00
_cleanup_ ( dns_resource_key_unrefp ) DnsResourceKey * key = NULL ;
_cleanup_ ( dns_question_unrefp ) DnsQuestion * question = NULL ;
Manager * m = userdata ;
uint16_t class , type ;
const char * name ;
2014-08-14 01:00:15 +02:00
int r , ifindex ;
uint64_t flags ;
DnsQuery * q ;
2014-07-30 19:23:27 +02:00
assert ( message ) ;
assert ( m ) ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
assert_cc ( sizeof ( int ) = = sizeof ( int32_t ) ) ;
2014-08-14 01:00:15 +02:00
r = sd_bus_message_read ( message , " isqqt " , & ifindex , & name , & class , & type , & flags ) ;
2014-07-30 19:23:27 +02:00
if ( r < 0 )
return r ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
r = dns_name_is_valid ( name ) ;
2014-07-31 19:53:59 +02:00
if ( r < 0 )
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
return r ;
if ( r = = 0 )
2014-07-31 19:53:59 +02:00
return sd_bus_error_setf ( error , SD_BUS_ERROR_INVALID_ARGS , " Invalid name '%s' " , name ) ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
r = check_ifindex_flags ( ifindex , & flags , 0 , error ) ;
2014-08-14 01:00:15 +02:00
if ( r < 0 )
return r ;
2014-07-30 19:23:27 +02:00
question = dns_question_new ( 1 ) ;
if ( ! question )
return - ENOMEM ;
key = dns_resource_key_new ( class , type , name ) ;
if ( ! key )
return - ENOMEM ;
r = dns_question_add ( question , key ) ;
if ( r < 0 )
return r ;
2015-11-25 20:47:27 +01:00
r = dns_query_new ( m , & q , question , ifindex , flags | SD_RESOLVED_NO_SEARCH ) ;
2014-07-30 19:23:27 +02:00
if ( r < 0 )
return r ;
q - > request = sd_bus_message_ref ( message ) ;
q - > complete = bus_method_resolve_record_complete ;
2015-04-29 19:10:09 +02:00
r = dns_query_bus_track ( q , message ) ;
2014-08-06 16:32:55 +02:00
if ( r < 0 )
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
goto fail ;
2014-08-06 16:32:55 +02:00
2014-07-30 19:23:27 +02:00
r = dns_query_go ( q ) ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
if ( r < 0 )
goto fail ;
return 1 ;
fail :
dns_query_free ( q ) ;
return r ;
}
static int append_srv ( DnsQuery * q , sd_bus_message * reply , DnsResourceRecord * rr ) {
_cleanup_ ( dns_resource_record_unrefp ) DnsResourceRecord * canonical = NULL ;
DnsQuery * aux ;
int r ;
assert ( q ) ;
assert ( reply ) ;
assert ( rr ) ;
assert ( rr - > key ) ;
if ( rr - > key - > type ! = DNS_TYPE_SRV )
return 0 ;
if ( ( q - > flags & SD_RESOLVED_NO_ADDRESS ) = = 0 ) {
/* First, let's see if we could find an appropriate A or AAAA
* record for the SRV record */
LIST_FOREACH ( auxiliary_queries , aux , q - > auxiliary_queries ) {
DnsResourceRecord * zz ;
if ( aux - > state ! = DNS_TRANSACTION_SUCCESS )
continue ;
if ( aux - > auxiliary_result ! = 0 )
continue ;
2015-11-24 01:25:24 +01:00
r = dns_name_equal ( dns_question_first_name ( aux - > question ) , rr - > srv . name ) ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
if ( r < 0 )
return r ;
if ( r = = 0 )
continue ;
DNS_ANSWER_FOREACH ( zz , aux - > answer ) {
2015-11-25 20:47:27 +01:00
r = dns_question_matches_rr ( aux - > question , zz , NULL ) ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
if ( r < 0 )
return r ;
if ( r = = 0 )
continue ;
canonical = dns_resource_record_ref ( zz ) ;
break ;
}
if ( canonical )
break ;
}
/* Is there are successful A/AAAA lookup for this SRV RR? If not, don't add it */
if ( ! canonical )
return 0 ;
}
r = sd_bus_message_open_container ( reply , ' r ' , " qqqsa(iiay)s " ) ;
if ( r < 0 )
return r ;
r = sd_bus_message_append (
reply ,
" qqqs " ,
rr - > srv . priority , rr - > srv . weight , rr - > srv . port , rr - > srv . name ) ;
if ( r < 0 )
return r ;
r = sd_bus_message_open_container ( reply , ' a ' , " (iiay) " ) ;
if ( r < 0 )
return r ;
if ( ( q - > flags & SD_RESOLVED_NO_ADDRESS ) = = 0 ) {
LIST_FOREACH ( auxiliary_queries , aux , q - > auxiliary_queries ) {
DnsResourceRecord * zz ;
int ifindex ;
if ( aux - > state ! = DNS_TRANSACTION_SUCCESS )
continue ;
if ( aux - > auxiliary_result ! = 0 )
continue ;
2015-11-24 01:25:24 +01:00
r = dns_name_equal ( dns_question_first_name ( aux - > question ) , rr - > srv . name ) ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
if ( r < 0 )
return r ;
if ( r = = 0 )
continue ;
DNS_ANSWER_FOREACH_IFINDEX ( zz , ifindex , aux - > answer ) {
2015-11-25 20:47:27 +01:00
r = dns_question_matches_rr ( aux - > question , zz , NULL ) ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
if ( r < 0 )
return r ;
if ( r = = 0 )
continue ;
r = append_address ( reply , zz , ifindex ) ;
if ( r < 0 )
return r ;
}
}
}
r = sd_bus_message_close_container ( reply ) ;
if ( r < 0 )
return r ;
/* Note that above we appended the hostname as encoded in the
* SRV , and here the canonical hostname this maps to . */
r = sd_bus_message_append ( reply , " s " , canonical ? DNS_RESOURCE_KEY_NAME ( canonical - > key ) : rr - > srv . name ) ;
if ( r < 0 )
return r ;
r = sd_bus_message_close_container ( reply ) ;
if ( r < 0 )
return r ;
return 1 ;
}
static int append_txt ( sd_bus_message * reply , DnsResourceRecord * rr ) {
DnsTxtItem * i ;
int r ;
assert ( reply ) ;
assert ( rr ) ;
assert ( rr - > key ) ;
if ( rr - > key - > type ! = DNS_TYPE_TXT )
return 0 ;
LIST_FOREACH ( items , i , rr - > txt . items ) {
if ( i - > length < = 0 )
continue ;
r = sd_bus_message_append_array ( reply , ' y ' , i - > data , i - > length ) ;
if ( r < 0 )
return r ;
}
return 1 ;
}
static void resolve_service_all_complete ( DnsQuery * q ) {
_cleanup_ ( dns_resource_record_unrefp ) DnsResourceRecord * canonical = NULL ;
_cleanup_ ( sd_bus_message_unrefp ) sd_bus_message * reply = NULL ;
_cleanup_free_ char * name = NULL , * type = NULL , * domain = NULL ;
DnsQuery * aux ;
unsigned added = false ;
int r ;
assert ( q ) ;
if ( q - > block_all_complete > 0 )
return ;
if ( ( q - > flags & SD_RESOLVED_NO_ADDRESS ) = = 0 ) {
DnsQuery * bad = NULL ;
bool have_success = false ;
LIST_FOREACH ( auxiliary_queries , aux , q - > auxiliary_queries ) {
switch ( aux - > state ) {
case DNS_TRANSACTION_PENDING :
/* If an auxiliary query is still pending, let's wait */
return ;
case DNS_TRANSACTION_SUCCESS :
if ( aux - > auxiliary_result = = 0 )
have_success = true ;
else
bad = aux ;
break ;
default :
bad = aux ;
break ;
}
}
if ( ! have_success ) {
/* We can only return one error, hence pick the last error we encountered */
assert ( bad ) ;
if ( bad - > state = = DNS_TRANSACTION_SUCCESS ) {
assert ( bad - > auxiliary_result ! = 0 ) ;
if ( bad - > auxiliary_result = = - ELOOP ) {
2015-11-24 01:25:24 +01:00
r = sd_bus_reply_method_errorf ( q - > request , BUS_ERROR_CNAME_LOOP , " CNAME loop detected, or CNAME resolving disabled on '%s' " , dns_question_first_name ( bad - > question ) ) ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
goto finish ;
}
r = bad - > auxiliary_result ;
goto finish ;
}
r = reply_query_state ( bad ) ;
goto finish ;
}
}
r = sd_bus_message_new_method_return ( q - > request , & reply ) ;
if ( r < 0 )
goto finish ;
r = sd_bus_message_open_container ( reply , ' a ' , " (qqqsa(iiay)s) " ) ;
if ( r < 0 )
goto finish ;
if ( q - > answer ) {
DnsResourceRecord * rr ;
DNS_ANSWER_FOREACH ( rr , q - > answer ) {
2015-11-25 20:47:27 +01:00
r = dns_question_matches_rr ( q - > question , rr , NULL ) ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
if ( r < 0 )
goto finish ;
if ( r = = 0 )
continue ;
r = append_srv ( q , reply , rr ) ;
if ( r < 0 )
goto finish ;
if ( r = = 0 ) /* not an SRV record */
continue ;
if ( ! canonical )
canonical = dns_resource_record_ref ( rr ) ;
added + + ;
}
}
if ( added < = 0 ) {
2015-11-24 01:25:24 +01:00
r = sd_bus_reply_method_errorf ( q - > request , BUS_ERROR_NO_SUCH_RR , " '%s' does not have any RR of the requested type " , dns_question_first_name ( q - > question ) ) ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
goto finish ;
}
r = sd_bus_message_close_container ( reply ) ;
if ( r < 0 )
goto finish ;
r = sd_bus_message_open_container ( reply , ' a ' , " ay " ) ;
if ( r < 0 )
goto finish ;
if ( q - > answer ) {
DnsResourceRecord * rr ;
DNS_ANSWER_FOREACH ( rr , q - > answer ) {
2015-11-25 20:47:27 +01:00
r = dns_question_matches_rr ( q - > question , rr , NULL ) ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
if ( r < 0 )
goto finish ;
if ( r = = 0 )
continue ;
r = append_txt ( reply , rr ) ;
if ( r < 0 )
goto finish ;
}
}
r = sd_bus_message_close_container ( reply ) ;
if ( r < 0 )
goto finish ;
assert ( canonical ) ;
r = dns_service_split ( DNS_RESOURCE_KEY_NAME ( canonical - > key ) , & name , & type , & domain ) ;
if ( r < 0 )
goto finish ;
r = sd_bus_message_append (
reply ,
" ssst " ,
name , type , domain ,
SD_RESOLVED_FLAGS_MAKE ( q - > answer_protocol , q - > answer_family ) ) ;
if ( r < 0 )
goto finish ;
r = sd_bus_send ( q - > manager - > bus , reply , NULL ) ;
finish :
if ( r < 0 ) {
log_error_errno ( r , " Failed to send service reply: %m " ) ;
sd_bus_reply_method_errno ( q - > request , r , NULL ) ;
}
dns_query_free ( q ) ;
}
static void resolve_service_hostname_complete ( DnsQuery * q ) {
int r ;
assert ( q ) ;
assert ( q - > auxiliary_for ) ;
if ( q - > state ! = DNS_TRANSACTION_SUCCESS ) {
resolve_service_all_complete ( q - > auxiliary_for ) ;
return ;
}
r = dns_query_process_cname ( q ) ;
if ( r > 0 ) /* This was a cname, and the query was restarted. */
return ;
/* This auxiliary lookup is finished or failed, let's see if all are finished now. */
q - > auxiliary_result = r ;
resolve_service_all_complete ( q - > auxiliary_for ) ;
}
static int resolve_service_hostname ( DnsQuery * q , DnsResourceRecord * rr , int ifindex ) {
_cleanup_ ( dns_question_unrefp ) DnsQuestion * question = NULL ;
DnsQuery * aux ;
int r ;
assert ( q ) ;
assert ( rr ) ;
assert ( rr - > key ) ;
assert ( rr - > key - > type = = DNS_TYPE_SRV ) ;
/* OK, we found an SRV record for the service. Let's resolve
* the hostname included in it */
r = dns_question_new_address ( & question , q - > request_family , rr - > srv . name ) ;
if ( r < 0 )
return r ;
2015-11-25 20:47:27 +01:00
r = dns_query_new ( q - > manager , & aux , question , ifindex , q - > flags | SD_RESOLVED_NO_SEARCH ) ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
if ( r < 0 )
return r ;
aux - > request_family = q - > request_family ;
aux - > complete = resolve_service_hostname_complete ;
r = dns_query_make_auxiliary ( aux , q ) ;
if ( r = = - EAGAIN ) {
/* Too many auxiliary lookups? If so, don't complain,
* let ' s just not add this one , we already have more
* than enough */
dns_query_free ( aux ) ;
return 0 ;
}
if ( r < 0 )
goto fail ;
/* Note that auxiliary queries do not track the original bus
* client , only the primary request does that . */
r = dns_query_go ( aux ) ;
if ( r < 0 )
goto fail ;
return 1 ;
fail :
dns_query_free ( aux ) ;
return r ;
}
static void bus_method_resolve_service_complete ( DnsQuery * q ) {
unsigned found = 0 ;
int r ;
assert ( q ) ;
if ( q - > state ! = DNS_TRANSACTION_SUCCESS ) {
r = reply_query_state ( q ) ;
goto finish ;
}
r = dns_query_process_cname ( q ) ;
if ( r = = - ELOOP ) {
2015-11-24 01:25:24 +01:00
r = sd_bus_reply_method_errorf ( q - > request , BUS_ERROR_CNAME_LOOP , " CNAME loop detected, or CNAME resolving disabled on '%s' " , dns_question_first_name ( q - > question ) ) ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
goto finish ;
}
if ( r < 0 )
goto finish ;
if ( r > 0 ) /* This was a cname, and the query was restarted. */
return ;
if ( q - > answer ) {
DnsResourceRecord * rr ;
int ifindex ;
DNS_ANSWER_FOREACH_IFINDEX ( rr , ifindex , q - > answer ) {
2015-11-25 20:47:27 +01:00
r = dns_question_matches_rr ( q - > question , rr , NULL ) ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
if ( r < 0 )
goto finish ;
if ( r = = 0 )
continue ;
if ( rr - > key - > type ! = DNS_TYPE_SRV )
continue ;
if ( ( q - > flags & SD_RESOLVED_NO_ADDRESS ) = = 0 ) {
q - > block_all_complete + + ;
r = resolve_service_hostname ( q , rr , ifindex ) ;
q - > block_all_complete - - ;
if ( r < 0 )
goto finish ;
}
found + + ;
}
}
if ( found < = 0 ) {
2015-11-24 01:25:24 +01:00
r = sd_bus_reply_method_errorf ( q - > request , BUS_ERROR_NO_SUCH_RR , " '%s' does not have any RR of the requested type " , dns_question_first_name ( q - > question ) ) ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
goto finish ;
}
/* Maybe we are already finished? check now... */
resolve_service_all_complete ( q ) ;
return ;
finish :
2014-07-30 19:23:27 +02:00
if ( r < 0 ) {
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
log_error_errno ( r , " Failed to send service reply: %m " ) ;
sd_bus_reply_method_errno ( q - > request , r , NULL ) ;
}
dns_query_free ( q ) ;
}
static int bus_method_resolve_service ( sd_bus_message * message , void * userdata , sd_bus_error * error ) {
_cleanup_ ( dns_question_unrefp ) DnsQuestion * question = NULL ;
const char * name , * type , * domain , * joined ;
_cleanup_free_ char * n = NULL ;
Manager * m = userdata ;
int family , ifindex ;
uint64_t flags ;
DnsQuery * q ;
int r ;
assert ( message ) ;
assert ( m ) ;
assert_cc ( sizeof ( int ) = = sizeof ( int32_t ) ) ;
r = sd_bus_message_read ( message , " isssit " , & ifindex , & name , & type , & domain , & family , & flags ) ;
if ( r < 0 )
2014-07-30 19:23:27 +02:00
return r ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
if ( ! IN_SET ( family , AF_INET , AF_INET6 , AF_UNSPEC ) )
return sd_bus_error_setf ( error , SD_BUS_ERROR_INVALID_ARGS , " Unknown address family %i " , family ) ;
if ( isempty ( name ) )
name = NULL ;
else {
if ( ! dns_service_name_is_valid ( name ) )
return sd_bus_error_setf ( error , SD_BUS_ERROR_INVALID_ARGS , " Invalid service name '%s' " , name ) ;
2014-07-30 19:23:27 +02:00
}
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
if ( isempty ( type ) )
type = NULL ;
else {
r = dns_srv_type_verify ( type ) ;
if ( r < 0 )
return r ;
if ( r = = 0 )
return sd_bus_error_setf ( error , SD_BUS_ERROR_INVALID_ARGS , " Invalid SRV service type '%s' " , type ) ;
}
r = dns_name_is_valid ( domain ) ;
if ( r < 0 )
return r ;
if ( r = = 0 )
return sd_bus_error_setf ( error , SD_BUS_ERROR_INVALID_ARGS , " Invalid domain '%s' " , domain ) ;
if ( name & & ! type )
return sd_bus_error_setf ( error , SD_BUS_ERROR_INVALID_ARGS , " Service name cannot be specified without service type. " ) ;
r = check_ifindex_flags ( ifindex , & flags , SD_RESOLVED_NO_TXT | SD_RESOLVED_NO_ADDRESS , error ) ;
if ( r < 0 )
return r ;
if ( type ) {
/* If the type is specified, we generate the full domain name to look up ourselves */
r = dns_service_join ( name , type , domain , & n ) ;
if ( r < 0 )
return r ;
joined = n ;
} else
/* If no type is specified, we assume the domain
* contains the full domain name to lookup already */
joined = domain ;
r = dns_question_new_service ( & question , joined , ! ( flags & SD_RESOLVED_NO_TXT ) ) ;
if ( r < 0 )
return r ;
2015-11-25 20:47:27 +01:00
r = dns_query_new ( m , & q , question , ifindex , flags | SD_RESOLVED_NO_SEARCH ) ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
if ( r < 0 )
return r ;
q - > request = sd_bus_message_ref ( message ) ;
q - > request_family = family ;
q - > complete = bus_method_resolve_service_complete ;
r = dns_query_bus_track ( q , message ) ;
if ( r < 0 )
goto fail ;
r = dns_query_go ( q ) ;
if ( r < 0 )
goto fail ;
2014-07-30 19:23:27 +02:00
return 1 ;
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
fail :
dns_query_free ( q ) ;
return r ;
2014-07-30 19:23:27 +02:00
}
2015-11-24 22:49:15 +01:00
static int append_dns_server ( sd_bus_message * reply , DnsServer * s ) {
int r ;
assert ( reply ) ;
assert ( s ) ;
r = sd_bus_message_open_container ( reply , ' r ' , " iiay " ) ;
if ( r < 0 )
return r ;
r = sd_bus_message_append ( reply , " ii " , s - > link ? s - > link - > ifindex : 0 , s - > family ) ;
if ( r < 0 )
return r ;
r = sd_bus_message_append_array ( reply , ' y ' , & s - > address , FAMILY_ADDRESS_SIZE ( s - > family ) ) ;
if ( r < 0 )
return r ;
return sd_bus_message_close_container ( reply ) ;
}
static int bus_property_get_dns_servers (
sd_bus * bus ,
const char * path ,
const char * interface ,
const char * property ,
sd_bus_message * reply ,
void * userdata ,
sd_bus_error * error ) {
Manager * m = userdata ;
unsigned c = 0 ;
DnsServer * s ;
Iterator i ;
Link * l ;
int r ;
assert ( reply ) ;
assert ( m ) ;
r = sd_bus_message_open_container ( reply , ' a ' , " (iiay) " ) ;
if ( r < 0 )
return r ;
LIST_FOREACH ( servers , s , m - > dns_servers ) {
r = append_dns_server ( reply , s ) ;
if ( r < 0 )
return r ;
c + + ;
}
HASHMAP_FOREACH ( l , m - > links , i ) {
LIST_FOREACH ( servers , s , l - > dns_servers ) {
r = append_dns_server ( reply , s ) ;
if ( r < 0 )
return r ;
c + + ;
}
}
if ( c = = 0 ) {
LIST_FOREACH ( servers , s , m - > fallback_dns_servers ) {
r = append_dns_server ( reply , s ) ;
if ( r < 0 )
return r ;
}
}
return sd_bus_message_close_container ( reply ) ;
}
static int bus_property_get_search_domains (
sd_bus * bus ,
const char * path ,
const char * interface ,
const char * property ,
sd_bus_message * reply ,
void * userdata ,
sd_bus_error * error ) {
Manager * m = userdata ;
DnsSearchDomain * d ;
Iterator i ;
Link * l ;
int r ;
assert ( reply ) ;
assert ( m ) ;
r = sd_bus_message_open_container ( reply , ' a ' , " (is) " ) ;
if ( r < 0 )
return r ;
LIST_FOREACH ( domains , d , m - > search_domains ) {
r = sd_bus_message_append ( reply , " (is) " , 0 , d - > name ) ;
if ( r < 0 )
return r ;
}
HASHMAP_FOREACH ( l , m - > links , i ) {
LIST_FOREACH ( domains , d , l - > search_domains ) {
r = sd_bus_message_append ( reply , " is " , l - > ifindex , d - > name ) ;
if ( r < 0 )
return r ;
}
}
return sd_bus_message_close_container ( reply ) ;
}
2014-07-16 00:26:02 +02:00
static const sd_bus_vtable resolve_vtable [ ] = {
SD_BUS_VTABLE_START ( 0 ) ,
2015-11-24 22:49:15 +01:00
SD_BUS_PROPERTY ( " LLMNRHostname " , " s " , NULL , offsetof ( Manager , llmnr_hostname ) , 0 ) ,
SD_BUS_PROPERTY ( " DNSServers " , " a(iiay) " , bus_property_get_dns_servers , 0 , 0 ) ,
SD_BUS_PROPERTY ( " SearchDomains " , " a(is) " , bus_property_get_search_domains , 0 , 0 ) ,
2015-08-17 23:54:08 +02:00
SD_BUS_METHOD ( " ResolveHostname " , " isit " , " a(iiay)st " , bus_method_resolve_hostname , SD_BUS_VTABLE_UNPRIVILEGED ) ,
SD_BUS_METHOD ( " ResolveAddress " , " iiayt " , " a(is)t " , bus_method_resolve_address , SD_BUS_VTABLE_UNPRIVILEGED ) ,
SD_BUS_METHOD ( " ResolveRecord " , " isqqt " , " a(iqqay)t " , bus_method_resolve_record , SD_BUS_VTABLE_UNPRIVILEGED ) ,
resolved: add ResolveService() bus call for resolving SRV and DNS-SD services
This also adds client-side support for this to systemd-resolve-host.
Note that the ResolveService() API can deal both with DNS-SD service
(consisting of service name, type and domain), as well as classic SRV
services (consisting just of a type and a domain), all exposed in the
same call.
This patch also reworks CNAME handling in order to reuse it between
hostname, RR and service lookups.
In contrast to Avahi and Bonjour, this new API will actually reolve the
A/AAAA RRs the SRV RRs point to in one go (unless this is explicitly
disabled). This normally comes for free, as these RRs are sent along
the SRV responses anyway, hence let's make use of that. This makes the
API considerably easier to use, as a single ResolveService() invocation
will return all necessary data to pick a server and connect() to it.
Note that this only implements the DNS-SD resolving step, it does not
implement DNS-SD browsing, as that makes sense primarily on mDNS, due to
its continuous nature.
2015-11-23 21:25:40 +01:00
SD_BUS_METHOD ( " ResolveService " , " isssit " , " a(qqqsa(iiay)s)aayssst " , bus_method_resolve_service , SD_BUS_VTABLE_UNPRIVILEGED ) ,
2014-07-16 00:26:02 +02:00
SD_BUS_VTABLE_END ,
} ;
static int on_bus_retry ( sd_event_source * s , usec_t usec , void * userdata ) {
Manager * m = userdata ;
assert ( s ) ;
assert ( m ) ;
m - > bus_retry_event_source = sd_event_source_unref ( m - > bus_retry_event_source ) ;
manager_connect_bus ( m ) ;
return 0 ;
}
2015-04-29 18:35:10 +02:00
static int match_prepare_for_sleep ( sd_bus_message * message , void * userdata , sd_bus_error * ret_error ) {
2014-08-06 16:59:48 +02:00
Manager * m = userdata ;
int b , r ;
2015-04-29 18:35:10 +02:00
assert ( message ) ;
assert ( m ) ;
2014-08-06 16:59:48 +02:00
r = sd_bus_message_read ( message , " b " , & b ) ;
if ( r < 0 ) {
2014-11-28 13:19:16 +01:00
log_debug_errno ( r , " Failed to parse PrepareForSleep signal: %m " ) ;
2014-08-06 16:59:48 +02:00
return 0 ;
}
if ( b )
return 0 ;
log_debug ( " Coming back from suspend, verifying all RRs... " ) ;
manager_verify_all ( m ) ;
return 0 ;
}
2014-07-16 00:26:02 +02:00
int manager_connect_bus ( Manager * m ) {
int r ;
assert ( m ) ;
if ( m - > bus )
return 0 ;
r = sd_bus_default_system ( & m - > bus ) ;
if ( r < 0 ) {
/* We failed to connect? Yuck, we must be in early
* boot . Let ' s try in 5 s again . As soon as we have
* kdbus we can stop doing this . . . */
2014-11-28 13:19:16 +01:00
log_debug_errno ( r , " Failed to connect to bus, trying again in 5s: %m " ) ;
2014-07-16 00:26:02 +02:00
r = sd_event_add_time ( m - > event , & m - > bus_retry_event_source , CLOCK_MONOTONIC , now ( CLOCK_MONOTONIC ) + 5 * USEC_PER_SEC , 0 , on_bus_retry , m ) ;
2014-11-28 18:50:43 +01:00
if ( r < 0 )
return log_error_errno ( r , " Failed to install bus reconnect time event: %m " ) ;
2014-07-16 00:26:02 +02:00
return 0 ;
}
2014-07-16 03:31:30 +02:00
r = sd_bus_add_object_vtable ( m - > bus , NULL , " /org/freedesktop/resolve1 " , " org.freedesktop.resolve1.Manager " , resolve_vtable , m ) ;
2014-11-28 18:50:43 +01:00
if ( r < 0 )
return log_error_errno ( r , " Failed to register object: %m " ) ;
2014-07-16 00:26:02 +02:00
r = sd_bus_request_name ( m - > bus , " org.freedesktop.resolve1 " , 0 ) ;
2014-11-28 18:50:43 +01:00
if ( r < 0 )
return log_error_errno ( r , " Failed to register name: %m " ) ;
2014-07-16 00:26:02 +02:00
r = sd_bus_attach_event ( m - > bus , m - > event , 0 ) ;
2014-11-28 18:50:43 +01:00
if ( r < 0 )
return log_error_errno ( r , " Failed to attach bus to event loop: %m " ) ;
2014-07-16 00:26:02 +02:00
2014-08-06 16:59:48 +02:00
r = sd_bus_add_match ( m - > bus , & m - > prepare_for_sleep_slot ,
" type='signal', "
" sender='org.freedesktop.login1', "
" interface='org.freedesktop.login1.Manager', "
" member='PrepareForSleep', "
" path='/org/freedesktop/login1' " ,
match_prepare_for_sleep ,
m ) ;
if ( r < 0 )
2014-11-28 13:19:16 +01:00
log_error_errno ( r , " Failed to add match for PrepareForSleep: %m " ) ;
2014-08-06 16:59:48 +02:00
2014-07-16 00:26:02 +02:00
return 0 ;
}