X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gio%2Fgthreadedresolver.c;h=9bb864c7fa0f8db04154bb9556995477febf349e;hb=f8d42cefbddf4930e40d6866e7002e556186763e;hp=7412bcdefe59b3d783f27c88374dc2dfd62d07dc;hpb=1b033919845cef366842373da9f1cfb56f522d01;p=platform%2Fupstream%2Fglib.git diff --git a/gio/gthreadedresolver.c b/gio/gthreadedresolver.c index 7412bcd..9bb864c 100644 --- a/gio/gthreadedresolver.c +++ b/gio/gthreadedresolver.c @@ -15,9 +15,7 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General - * Public License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place, Suite 330, - * Boston, MA 02111-1307, USA. + * Public License along with this library; if not, see . */ #include "config.h" @@ -31,348 +29,99 @@ #include "gnetworkingprivate.h" #include "gcancellable.h" -#include "gsimpleasyncresult.h" +#include "ginetaddress.h" +#include "ginetsocketaddress.h" +#include "gtask.h" #include "gsocketaddress.h" +#include "gsrvtarget.h" G_DEFINE_TYPE (GThreadedResolver, g_threaded_resolver, G_TYPE_RESOLVER) -static void threaded_resolver_thread (gpointer thread_data, gpointer pool_data); - static void g_threaded_resolver_init (GThreadedResolver *gtr) { - gtr->thread_pool = g_thread_pool_new (threaded_resolver_thread, gtr, - -1, FALSE, NULL); -} - -static void -finalize (GObject *object) -{ - GThreadedResolver *gtr = G_THREADED_RESOLVER (object); - - g_thread_pool_free (gtr->thread_pool, FALSE, FALSE); - - G_OBJECT_CLASS (g_threaded_resolver_parent_class)->finalize (object); -} - -/* A GThreadedResolverRequest represents a request in progress - * (usually, but see case 1). It is refcounted, to make sure that it - * doesn't get freed too soon. In particular, it can't be freed until - * (a) the resolver thread has finished resolving, (b) the calling - * thread has received an answer, and (c) no other thread could be in - * the process of trying to cancel it. - * - * The possibilities: - * - * 1. Synchronous non-cancellable request: in this case, the request - * is simply done in the calling thread, without using - * GThreadedResolverRequest at all. - * - * 2. Synchronous cancellable request: A req is created with a GCond, - * and 3 refs (for the resolution thread, the calling thread, and - * the cancellation signal handler). - * - * a. If the resolution completes successfully, the thread pool - * function (threaded_resolver_thread()) will call - * g_threaded_resolver_request_complete(), which will detach - * the "cancelled" signal handler (dropping one ref on req) - * and signal the GCond, and then unref the req. The calling - * thread receives the signal from the GCond, processes the - * response, and unrefs the req, causing it to be freed. - * - * b. If the resolution is cancelled before completing, - * request_cancelled() will call - * g_threaded_resolver_request_complete(), which will detach - * the signal handler (as above, unreffing the req), set - * req->error to indicate that it was cancelled, and signal - * the GCond. The calling thread receives the signal from the - * GCond, processes the response, and unrefs the req. - * Eventually, the resolver thread finishes resolving (or - * times out in the resolver) and calls - * g_threaded_resolver_request_complete() again, but - * _request_complete() does nothing this time since the - * request is already complete. The thread pool func then - * unrefs the req, causing it to be freed. - * - * 3. Asynchronous request: A req is created with a GSimpleAsyncResult - * (and no GCond). The calling thread's ref on req is set up to be - * automatically dropped when the async_result is freed. Two - * sub-possibilities: - * - * a. If the resolution completes, the thread pool function - * (threaded_resolver_thread()) will call - * g_threaded_resolver_request_complete(), which will detach - * the "cancelled" signal handler (if it was present) - * (unreffing the req), queue the async_result to complete in - * an idle handler, unref the async_result (which is still - * reffed by the idle handler though), and then unref the req. - * The main thread then invokes the async_result's callback - * and processes the response. When it finishes, the - * async_result drops the ref that was taken by - * g_simple_async_result_complete_in_idle(), which causes the - * async_result to be freed, which causes req to be unreffed - * and freed. - * - * b. If the resolution is cancelled, request_cancelled() will - * call g_threaded_resolver_request_complete(), which will - * detach the signal handler (as above, unreffing the req) set - * req->error to indicate that it was cancelled, and queue and - * unref the async_result. The main thread completes the - * async_request and unrefs it and the req, as above. - * Eventually, the resolver thread finishes resolving (or - * times out in the resolver) and calls - * g_threaded_resolver_request_complete() again, but - * _request_complete() does nothing this time since the - * request is already complete. The thread pool func then - * unrefs the req, causing it to be freed. - * - * g_threaded_resolver_request_complete() ensures that if the request - * completes and cancels "at the same time" that only one of the two - * conditions gets processed. - */ - -typedef struct _GThreadedResolverRequest GThreadedResolverRequest; -typedef void (*GThreadedResolverResolveFunc) (GThreadedResolverRequest *, GError **); -typedef void (*GThreadedResolverFreeFunc) (GThreadedResolverRequest *); - -struct _GThreadedResolverRequest { - GThreadedResolverResolveFunc resolve_func; - GThreadedResolverFreeFunc free_func; - - union { - struct { - gchar *hostname; - GList *addresses; - } name; - struct { - GInetAddress *address; - gchar *name; - } address; - struct { - gchar *rrname; - GList *targets; - } service; - } u; - - GCancellable *cancellable; - GError *error; - - GMutex *mutex; - guint ref_count; - - GCond *cond; - GSimpleAsyncResult *async_result; - gboolean complete; - -}; - -static void g_threaded_resolver_request_unref (GThreadedResolverRequest *req); -static void request_cancelled (GCancellable *cancellable, gpointer req); -static void request_cancelled_disconnect_notify (gpointer req, GClosure *closure); - -static GThreadedResolverRequest * -g_threaded_resolver_request_new (GThreadedResolverResolveFunc resolve_func, - GThreadedResolverFreeFunc free_func, - GCancellable *cancellable) -{ - GThreadedResolverRequest *req; - - req = g_slice_new0 (GThreadedResolverRequest); - req->resolve_func = resolve_func; - req->free_func = free_func; - - /* Initial refcount is 2; one for the caller and one for resolve_func */ - req->ref_count = 2; - - req->mutex = g_mutex_new (); - /* Initially locked; caller must unlock */ - g_mutex_lock (req->mutex); - - if (cancellable) - { - req->ref_count++; - req->cancellable = g_object_ref (cancellable); - g_signal_connect_data (cancellable, "cancelled", - G_CALLBACK (request_cancelled), req, - request_cancelled_disconnect_notify, 0); - } - - return req; -} - -static void -g_threaded_resolver_request_unref (GThreadedResolverRequest *req) -{ - guint ref_count; - - g_mutex_lock (req->mutex); - ref_count = --req->ref_count; - g_mutex_unlock (req->mutex); - if (ref_count > 0) - return; - - g_mutex_free (req->mutex); - - if (req->cond) - g_cond_free (req->cond); - - if (req->error) - g_error_free (req->error); - - if (req->free_func) - req->free_func (req); - - /* We don't have to free req->cancellable or req->async_result, - * since (if set), they must already have been freed by - * request_complete() in order to get here. - */ - - g_slice_free (GThreadedResolverRequest, req); } -static void -g_threaded_resolver_request_complete (GThreadedResolverRequest *req, - gboolean cancelled) +static GResolverError +g_resolver_error_from_addrinfo_error (gint err) { - g_mutex_lock (req->mutex); - if (req->complete) - { - /* The req was cancelled, and now it has finished resolving as - * well. But we have nowhere to send the result, so just return. - */ - g_mutex_unlock (req->mutex); - return; - } - - req->complete = TRUE; - g_mutex_unlock (req->mutex); - - if (req->cancellable) + switch (err) { - /* Possibly propagate a cancellation error */ - if (cancelled && !req->error) - g_cancellable_set_error_if_cancelled (req->cancellable, &req->error); - - /* Drop the signal handler's ref on @req */ - g_signal_handlers_disconnect_by_func (req->cancellable, request_cancelled, req); - g_object_unref (req->cancellable); - req->cancellable = NULL; - } + case EAI_FAIL: +#if defined(EAI_NODATA) && (EAI_NODATA != EAI_NONAME) + case EAI_NODATA: +#endif + case EAI_NONAME: + return G_RESOLVER_ERROR_NOT_FOUND; - if (req->cond) - g_cond_signal (req->cond); - else if (req->async_result) - { - if (req->error) - g_simple_async_result_set_from_error (req->async_result, req->error); - g_simple_async_result_complete_in_idle (req->async_result); + case EAI_AGAIN: + return G_RESOLVER_ERROR_TEMPORARY_FAILURE; - /* Drop our ref on the async_result, which will eventually cause - * it to drop its ref on req. - */ - g_object_unref (req->async_result); - req->async_result = NULL; + default: + return G_RESOLVER_ERROR_INTERNAL; } } -static void -request_cancelled (GCancellable *cancellable, - gpointer user_data) -{ - GThreadedResolverRequest *req = user_data; - - g_threaded_resolver_request_complete (req, TRUE); - - /* We can't actually cancel the resolver thread; it will eventually - * complete on its own and call request_complete() again, which will - * do nothing the second time. - */ -} - -static void -request_cancelled_disconnect_notify (gpointer req, - GClosure *closure) -{ - g_threaded_resolver_request_unref (req); -} +static struct addrinfo addrinfo_hints; static void -threaded_resolver_thread (gpointer thread_data, - gpointer pool_data) +do_lookup_by_name (GTask *task, + gpointer source_object, + gpointer task_data, + GCancellable *cancellable) { - GThreadedResolverRequest *req = thread_data; + const char *hostname = task_data; + struct addrinfo *res = NULL; + GList *addresses; + gint retval; - req->resolve_func (req, &req->error); - g_threaded_resolver_request_complete (req, FALSE); - g_threaded_resolver_request_unref (req); -} + retval = getaddrinfo (hostname, NULL, &addrinfo_hints, &res); -static void -resolve_sync (GThreadedResolver *gtr, - GThreadedResolverRequest *req, - GError **error) -{ - if (!req->cancellable || !gtr->thread_pool) + if (retval == 0) { - req->resolve_func (req, error); - g_mutex_unlock (req->mutex); - - g_threaded_resolver_request_complete (req, FALSE); - g_threaded_resolver_request_unref (req); - return; + struct addrinfo *ai; + GSocketAddress *sockaddr; + GInetAddress *addr; + + addresses = NULL; + for (ai = res; ai; ai = ai->ai_next) + { + sockaddr = g_socket_address_new_from_native (ai->ai_addr, ai->ai_addrlen); + if (!sockaddr || !G_IS_INET_SOCKET_ADDRESS (sockaddr)) + continue; + + addr = g_object_ref (g_inet_socket_address_get_address ((GInetSocketAddress *)sockaddr)); + addresses = g_list_prepend (addresses, addr); + g_object_unref (sockaddr); + } + + if (addresses != NULL) + { + addresses = g_list_reverse (addresses); + g_task_return_pointer (task, addresses, + (GDestroyNotify)g_resolver_free_addresses); + } + else + { + /* All addresses failed to be converted to GSocketAddresses. */ + g_task_return_new_error (task, + G_RESOLVER_ERROR, + G_RESOLVER_ERROR_NOT_FOUND, + _("Error resolving '%s': %s"), + hostname, + _("No valid addresses were found")); + } } - - req->cond = g_cond_new (); - g_thread_pool_push (gtr->thread_pool, req, &req->error); - if (!req->error) - g_cond_wait (req->cond, req->mutex); - g_mutex_unlock (req->mutex); - - if (req->error) + else { - g_propagate_error (error, req->error); - req->error = NULL; + g_task_return_new_error (task, + G_RESOLVER_ERROR, + g_resolver_error_from_addrinfo_error (retval), + _("Error resolving '%s': %s"), + hostname, gai_strerror (retval)); } -} - -static void -resolve_async (GThreadedResolver *gtr, - GThreadedResolverRequest *req, - GAsyncReadyCallback callback, - gpointer user_data, - gpointer tag) -{ - req->async_result = g_simple_async_result_new (G_OBJECT (gtr), - callback, user_data, tag); - g_simple_async_result_set_op_res_gpointer (req->async_result, req, - (GDestroyNotify)g_threaded_resolver_request_unref); - g_thread_pool_push (gtr->thread_pool, req, NULL); - g_mutex_unlock (req->mutex); -} - -static GThreadedResolverRequest * -resolve_finish (GResolver *resolver, - GAsyncResult *result, - gpointer tag, - GError **error) -{ - g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (resolver), tag), NULL); - - return g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result)); -} - -static void -do_lookup_by_name (GThreadedResolverRequest *req, - GError **error) -{ - struct addrinfo *res = NULL; - gint retval; - retval = getaddrinfo (req->u.name.hostname, NULL, - &_g_resolver_addrinfo_hints, &res); - req->u.name.addresses = - _g_resolver_addresses_from_addrinfo (req->u.name.hostname, res, retval, error); if (res) freeaddrinfo (res); } @@ -383,41 +132,33 @@ lookup_by_name (GResolver *resolver, GCancellable *cancellable, GError **error) { - GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver); - GThreadedResolverRequest *req; + GTask *task; GList *addresses; - req = g_threaded_resolver_request_new (do_lookup_by_name, NULL, cancellable); - req->u.name.hostname = (gchar *)hostname; - resolve_sync (gtr, req, error); + task = g_task_new (resolver, cancellable, NULL, NULL); + g_task_set_task_data (task, g_strdup (hostname), g_free); + g_task_set_return_on_cancel (task, TRUE); + g_task_run_in_thread_sync (task, do_lookup_by_name); + addresses = g_task_propagate_pointer (task, error); + g_object_unref (task); - addresses = req->u.name.addresses; - g_threaded_resolver_request_unref (req); return addresses; } static void -free_lookup_by_name (GThreadedResolverRequest *req) -{ - g_free (req->u.name.hostname); - if (req->u.name.addresses) - g_resolver_free_addresses (req->u.name.addresses); -} - -static void lookup_by_name_async (GResolver *resolver, const gchar *hostname, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { - GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver); - GThreadedResolverRequest *req; + GTask *task; - req = g_threaded_resolver_request_new (do_lookup_by_name, free_lookup_by_name, - cancellable); - req->u.name.hostname = g_strdup (hostname); - resolve_async (gtr, req, callback, user_data, lookup_by_name_async); + task = g_task_new (resolver, cancellable, callback, user_data); + g_task_set_task_data (task, g_strdup (hostname), g_free); + g_task_set_return_on_cancel (task, TRUE); + g_task_run_in_thread (task, do_lookup_by_name); + g_object_unref (task); } static GList * @@ -425,32 +166,48 @@ lookup_by_name_finish (GResolver *resolver, GAsyncResult *result, GError **error) { - GThreadedResolverRequest *req; - GList *addresses; + g_return_val_if_fail (g_task_is_valid (result, resolver), NULL); - req = resolve_finish (resolver, result, lookup_by_name_async, error); - addresses = req->u.name.addresses; - req->u.name.addresses = NULL; - return addresses; + return g_task_propagate_pointer (G_TASK (result), error); } static void -do_lookup_by_address (GThreadedResolverRequest *req, - GError **error) +do_lookup_by_address (GTask *task, + gpointer source_object, + gpointer task_data, + GCancellable *cancellable) { + GInetAddress *address = task_data; struct sockaddr_storage sockaddr; gsize sockaddr_size; + GSocketAddress *gsockaddr; gchar name[NI_MAXHOST]; gint retval; - _g_resolver_address_to_sockaddr (req->u.address.address, - &sockaddr, &sockaddr_size); + gsockaddr = g_inet_socket_address_new (address, 0); + g_socket_address_to_native (gsockaddr, (struct sockaddr *)&sockaddr, + sizeof (sockaddr), NULL); + sockaddr_size = g_socket_address_get_native_size (gsockaddr); + g_object_unref (gsockaddr); retval = getnameinfo ((struct sockaddr *)&sockaddr, sockaddr_size, name, sizeof (name), NULL, 0, NI_NAMEREQD); - req->u.address.name = _g_resolver_name_from_nameinfo (req->u.address.address, - name, retval, error); + if (retval == 0) + g_task_return_pointer (task, g_strdup (name), g_free); + else + { + gchar *phys; + + phys = g_inet_address_to_string (address); + g_task_return_new_error (task, + G_RESOLVER_ERROR, + g_resolver_error_from_addrinfo_error (retval), + _("Error reverse-resolving '%s': %s"), + phys ? phys : "(unknown)", + gai_strerror (retval)); + g_free (phys); + } } static gchar * @@ -459,42 +216,33 @@ lookup_by_address (GResolver *resolver, GCancellable *cancellable, GError **error) { - GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver); - GThreadedResolverRequest *req; + GTask *task; gchar *name; - req = g_threaded_resolver_request_new (do_lookup_by_address, NULL, cancellable); - req->u.address.address = address; - resolve_sync (gtr, req, error); + task = g_task_new (resolver, cancellable, NULL, NULL); + g_task_set_task_data (task, g_object_ref (address), g_object_unref); + g_task_set_return_on_cancel (task, TRUE); + g_task_run_in_thread_sync (task, do_lookup_by_address); + name = g_task_propagate_pointer (task, error); + g_object_unref (task); - name = req->u.address.name; - g_threaded_resolver_request_unref (req); return name; } static void -free_lookup_by_address (GThreadedResolverRequest *req) -{ - g_object_unref (req->u.address.address); - if (req->u.address.name) - g_free (req->u.address.name); -} - -static void lookup_by_address_async (GResolver *resolver, GInetAddress *address, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { - GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver); - GThreadedResolverRequest *req; - - req = g_threaded_resolver_request_new (do_lookup_by_address, - free_lookup_by_address, - cancellable); - req->u.address.address = g_object_ref (address); - resolve_async (gtr, req, callback, user_data, lookup_by_address_async); + GTask *task; + + task = g_task_new (resolver, cancellable, callback, user_data); + g_task_set_task_data (task, g_object_ref (address), g_object_unref); + g_task_set_return_on_cancel (task, TRUE); + g_task_run_in_thread (task, do_lookup_by_address); + g_object_unref (task); } static gchar * @@ -502,96 +250,671 @@ lookup_by_address_finish (GResolver *resolver, GAsyncResult *result, GError **error) { - GThreadedResolverRequest *req; - gchar *name; + g_return_val_if_fail (g_task_is_valid (result, resolver), NULL); - req = resolve_finish (resolver, result, lookup_by_address_async, error); - name = req->u.address.name; - req->u.address.name = NULL; - return name; + return g_task_propagate_pointer (G_TASK (result), error); +} + + +#if defined(G_OS_UNIX) + +#ifdef __BIONIC__ +/* Copy from bionic/libc/private/arpa_nameser_compat.h + * and bionic/libc/private/arpa_nameser.h */ +typedef struct { + unsigned id :16; /* query identification number */ +#if BYTE_ORDER == BIG_ENDIAN + /* fields in third byte */ + unsigned qr: 1; /* response flag */ + unsigned opcode: 4; /* purpose of message */ + unsigned aa: 1; /* authoritive answer */ + unsigned tc: 1; /* truncated message */ + unsigned rd: 1; /* recursion desired */ + /* fields in fourth byte */ + unsigned ra: 1; /* recursion available */ + unsigned unused :1; /* unused bits (MBZ as of 4.9.3a3) */ + unsigned ad: 1; /* authentic data from named */ + unsigned cd: 1; /* checking disabled by resolver */ + unsigned rcode :4; /* response code */ +#endif +#if BYTE_ORDER == LITTLE_ENDIAN || BYTE_ORDER == PDP_ENDIAN + /* fields in third byte */ + unsigned rd :1; /* recursion desired */ + unsigned tc :1; /* truncated message */ + unsigned aa :1; /* authoritive answer */ + unsigned opcode :4; /* purpose of message */ + unsigned qr :1; /* response flag */ + /* fields in fourth byte */ + unsigned rcode :4; /* response code */ + unsigned cd: 1; /* checking disabled by resolver */ + unsigned ad: 1; /* authentic data from named */ + unsigned unused :1; /* unused bits (MBZ as of 4.9.3a3) */ + unsigned ra :1; /* recursion available */ +#endif + /* remaining bytes */ + unsigned qdcount :16; /* number of question entries */ + unsigned ancount :16; /* number of answer entries */ + unsigned nscount :16; /* number of authority entries */ + unsigned arcount :16; /* number of resource entries */ +} HEADER; + +#define NS_INT32SZ 4 /* #/bytes of data in a uint32_t */ +#define NS_INT16SZ 2 /* #/bytes of data in a uint16_t */ + +#define NS_GET16(s, cp) do { \ + const u_char *t_cp = (const u_char *)(cp); \ + (s) = ((uint16_t)t_cp[0] << 8) \ + | ((uint16_t)t_cp[1]) \ + ; \ + (cp) += NS_INT16SZ; \ +} while (/*CONSTCOND*/0) + +#define NS_GET32(l, cp) do { \ + const u_char *t_cp = (const u_char *)(cp); \ + (l) = ((uint32_t)t_cp[0] << 24) \ + | ((uint32_t)t_cp[1] << 16) \ + | ((uint32_t)t_cp[2] << 8) \ + | ((uint32_t)t_cp[3]) \ + ; \ + (cp) += NS_INT32SZ; \ +} while (/*CONSTCOND*/0) + +#define GETSHORT NS_GET16 +#define GETLONG NS_GET32 + +#define C_IN 1 + +/* From bionic/libc/private/resolv_private.h */ +int dn_expand(const u_char *, const u_char *, const u_char *, char *, int); +#define dn_skipname __dn_skipname +int dn_skipname(const u_char *, const u_char *); + +/* From bionic/libc/private/arpa_nameser_compat.h */ +#define T_MX ns_t_mx +#define T_TXT ns_t_txt +#define T_SOA ns_t_soa +#define T_NS ns_t_ns + +/* From bionic/libc/private/arpa_nameser.h */ +typedef enum __ns_type { + ns_t_invalid = 0, /* Cookie. */ + ns_t_a = 1, /* Host address. */ + ns_t_ns = 2, /* Authoritative server. */ + ns_t_md = 3, /* Mail destination. */ + ns_t_mf = 4, /* Mail forwarder. */ + ns_t_cname = 5, /* Canonical name. */ + ns_t_soa = 6, /* Start of authority zone. */ + ns_t_mb = 7, /* Mailbox domain name. */ + ns_t_mg = 8, /* Mail group member. */ + ns_t_mr = 9, /* Mail rename name. */ + ns_t_null = 10, /* Null resource record. */ + ns_t_wks = 11, /* Well known service. */ + ns_t_ptr = 12, /* Domain name pointer. */ + ns_t_hinfo = 13, /* Host information. */ + ns_t_minfo = 14, /* Mailbox information. */ + ns_t_mx = 15, /* Mail routing information. */ + ns_t_txt = 16, /* Text strings. */ + ns_t_rp = 17, /* Responsible person. */ + ns_t_afsdb = 18, /* AFS cell database. */ + ns_t_x25 = 19, /* X_25 calling address. */ + ns_t_isdn = 20, /* ISDN calling address. */ + ns_t_rt = 21, /* Router. */ + ns_t_nsap = 22, /* NSAP address. */ + ns_t_nsap_ptr = 23, /* Reverse NSAP lookup (deprecated). */ + ns_t_sig = 24, /* Security signature. */ + ns_t_key = 25, /* Security key. */ + ns_t_px = 26, /* X.400 mail mapping. */ + ns_t_gpos = 27, /* Geographical position (withdrawn). */ + ns_t_aaaa = 28, /* Ip6 Address. */ + ns_t_loc = 29, /* Location Information. */ + ns_t_nxt = 30, /* Next domain (security). */ + ns_t_eid = 31, /* Endpoint identifier. */ + ns_t_nimloc = 32, /* Nimrod Locator. */ + ns_t_srv = 33, /* Server Selection. */ + ns_t_atma = 34, /* ATM Address */ + ns_t_naptr = 35, /* Naming Authority PoinTeR */ + ns_t_kx = 36, /* Key Exchange */ + ns_t_cert = 37, /* Certification record */ + ns_t_a6 = 38, /* IPv6 address (deprecates AAAA) */ + ns_t_dname = 39, /* Non-terminal DNAME (for IPv6) */ + ns_t_sink = 40, /* Kitchen sink (experimentatl) */ + ns_t_opt = 41, /* EDNS0 option (meta-RR) */ + ns_t_apl = 42, /* Address prefix list (RFC 3123) */ + ns_t_tkey = 249, /* Transaction key */ + ns_t_tsig = 250, /* Transaction signature. */ + ns_t_ixfr = 251, /* Incremental zone transfer. */ + ns_t_axfr = 252, /* Transfer zone of authority. */ + ns_t_mailb = 253, /* Transfer mailbox records. */ + ns_t_maila = 254, /* Transfer mail agent records. */ + ns_t_any = 255, /* Wildcard match. */ + ns_t_zxfr = 256, /* BIND-specific, nonstandard. */ + ns_t_max = 65536 +} ns_type; + +#endif /* __BIONIC__ */ + +static GVariant * +parse_res_srv (guchar *answer, + guchar *end, + guchar **p) +{ + gchar namebuf[1024]; + guint16 priority, weight, port; + + GETSHORT (priority, *p); + GETSHORT (weight, *p); + GETSHORT (port, *p); + *p += dn_expand (answer, end, *p, namebuf, sizeof (namebuf)); + + return g_variant_new ("(qqqs)", + priority, + weight, + port, + namebuf); } +static GVariant * +parse_res_soa (guchar *answer, + guchar *end, + guchar **p) +{ + gchar mnamebuf[1024]; + gchar rnamebuf[1024]; + guint32 serial, refresh, retry, expire, ttl; + + *p += dn_expand (answer, end, *p, mnamebuf, sizeof (mnamebuf)); + *p += dn_expand (answer, end, *p, rnamebuf, sizeof (rnamebuf)); + + GETLONG (serial, *p); + GETLONG (refresh, *p); + GETLONG (retry, *p); + GETLONG (expire, *p); + GETLONG (ttl, *p); + + return g_variant_new ("(ssuuuuu)", + mnamebuf, + rnamebuf, + serial, + refresh, + retry, + expire, + ttl); +} + +static GVariant * +parse_res_ns (guchar *answer, + guchar *end, + guchar **p) +{ + gchar namebuf[1024]; + + *p += dn_expand (answer, end, *p, namebuf, sizeof (namebuf)); + + return g_variant_new ("(s)", namebuf); +} + +static GVariant * +parse_res_mx (guchar *answer, + guchar *end, + guchar **p) +{ + gchar namebuf[1024]; + guint16 preference; + + GETSHORT (preference, *p); + + *p += dn_expand (answer, end, *p, namebuf, sizeof (namebuf)); + + return g_variant_new ("(qs)", + preference, + namebuf); +} + +static GVariant * +parse_res_txt (guchar *answer, + guchar *end, + guchar **p) +{ + GVariant *record; + GPtrArray *array; + guchar *at = *p; + gsize len; + + array = g_ptr_array_new_with_free_func (g_free); + while (at < end) + { + len = *(at++); + if (len > at - end) + break; + g_ptr_array_add (array, g_strndup ((gchar *)at, len)); + at += len; + } + + *p = at; + record = g_variant_new ("(@as)", + g_variant_new_strv ((const gchar **)array->pdata, array->len)); + g_ptr_array_free (array, TRUE); + return record; +} + +static gint +g_resolver_record_type_to_rrtype (GResolverRecordType type) +{ + switch (type) + { + case G_RESOLVER_RECORD_SRV: + return T_SRV; + case G_RESOLVER_RECORD_TXT: + return T_TXT; + case G_RESOLVER_RECORD_SOA: + return T_SOA; + case G_RESOLVER_RECORD_NS: + return T_NS; + case G_RESOLVER_RECORD_MX: + return T_MX; + } + g_return_val_if_reached (-1); +} + +static GList * +g_resolver_records_from_res_query (const gchar *rrname, + gint rrtype, + guchar *answer, + gint len, + gint herr, + GError **error) +{ + gint count; + gchar namebuf[1024]; + guchar *end, *p; + guint16 type, qclass, rdlength; + guint32 ttl; + HEADER *header; + GList *records; + GVariant *record; + + if (len <= 0) + { + if (len == 0 || herr == HOST_NOT_FOUND || herr == NO_DATA) + { + g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_NOT_FOUND, + _("No DNS record of the requested type for '%s'"), rrname); + } + else if (herr == TRY_AGAIN) + { + g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_TEMPORARY_FAILURE, + _("Temporarily unable to resolve '%s'"), rrname); + } + else + { + g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_INTERNAL, + _("Error resolving '%s'"), rrname); + } + + return NULL; + } + + records = NULL; + + header = (HEADER *)answer; + p = answer + sizeof (HEADER); + end = answer + len; + + /* Skip query */ + count = ntohs (header->qdcount); + while (count-- && p < end) + { + p += dn_expand (answer, end, p, namebuf, sizeof (namebuf)); + p += 4; + + /* To silence gcc warnings */ + namebuf[0] = namebuf[1]; + } + + /* Read answers */ + count = ntohs (header->ancount); + while (count-- && p < end) + { + p += dn_expand (answer, end, p, namebuf, sizeof (namebuf)); + GETSHORT (type, p); + GETSHORT (qclass, p); + GETLONG (ttl, p); + ttl = ttl; /* To avoid -Wunused-but-set-variable */ + GETSHORT (rdlength, p); + + if (type != rrtype || qclass != C_IN) + { + p += rdlength; + continue; + } + + switch (rrtype) + { + case T_SRV: + record = parse_res_srv (answer, end, &p); + break; + case T_MX: + record = parse_res_mx (answer, end, &p); + break; + case T_SOA: + record = parse_res_soa (answer, end, &p); + break; + case T_NS: + record = parse_res_ns (answer, end, &p); + break; + case T_TXT: + record = parse_res_txt (answer, p + rdlength, &p); + break; + default: + g_warn_if_reached (); + record = NULL; + break; + } + + if (record != NULL) + records = g_list_prepend (records, record); + } + + if (records == NULL) + { + g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_NOT_FOUND, + _("No DNS record of the requested type for '%s'"), rrname); + + return NULL; + } + else + return records; +} + +#elif defined(G_OS_WIN32) + +static GVariant * +parse_dns_srv (DNS_RECORD *rec) +{ + return g_variant_new ("(qqqs)", + (guint16)rec->Data.SRV.wPriority, + (guint16)rec->Data.SRV.wWeight, + (guint16)rec->Data.SRV.wPort, + rec->Data.SRV.pNameTarget); +} + +static GVariant * +parse_dns_soa (DNS_RECORD *rec) +{ + return g_variant_new ("(ssuuuuu)", + rec->Data.SOA.pNamePrimaryServer, + rec->Data.SOA.pNameAdministrator, + (guint32)rec->Data.SOA.dwSerialNo, + (guint32)rec->Data.SOA.dwRefresh, + (guint32)rec->Data.SOA.dwRetry, + (guint32)rec->Data.SOA.dwExpire, + (guint32)rec->Data.SOA.dwDefaultTtl); +} + +static GVariant * +parse_dns_ns (DNS_RECORD *rec) +{ + return g_variant_new ("(s)", rec->Data.NS.pNameHost); +} + +static GVariant * +parse_dns_mx (DNS_RECORD *rec) +{ + return g_variant_new ("(qs)", + (guint16)rec->Data.MX.wPreference, + rec->Data.MX.pNameExchange); +} + +static GVariant * +parse_dns_txt (DNS_RECORD *rec) +{ + GVariant *record; + GPtrArray *array; + DWORD i; + + array = g_ptr_array_new (); + for (i = 0; i < rec->Data.TXT.dwStringCount; i++) + g_ptr_array_add (array, rec->Data.TXT.pStringArray[i]); + record = g_variant_new ("(@as)", + g_variant_new_strv ((const gchar **)array->pdata, array->len)); + g_ptr_array_free (array, TRUE); + return record; +} + +static WORD +g_resolver_record_type_to_dnstype (GResolverRecordType type) +{ + switch (type) + { + case G_RESOLVER_RECORD_SRV: + return DNS_TYPE_SRV; + case G_RESOLVER_RECORD_TXT: + return DNS_TYPE_TEXT; + case G_RESOLVER_RECORD_SOA: + return DNS_TYPE_SOA; + case G_RESOLVER_RECORD_NS: + return DNS_TYPE_NS; + case G_RESOLVER_RECORD_MX: + return DNS_TYPE_MX; + } + g_return_val_if_reached (-1); +} + +static GList * +g_resolver_records_from_DnsQuery (const gchar *rrname, + WORD dnstype, + DNS_STATUS status, + DNS_RECORD *results, + GError **error) +{ + DNS_RECORD *rec; + gpointer record; + GList *records; + + if (status != ERROR_SUCCESS) + { + if (status == DNS_ERROR_RCODE_NAME_ERROR) + { + g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_NOT_FOUND, + _("No DNS record of the requested type for '%s'"), rrname); + } + else if (status == DNS_ERROR_RCODE_SERVER_FAILURE) + { + g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_TEMPORARY_FAILURE, + _("Temporarily unable to resolve '%s'"), rrname); + } + else + { + g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_INTERNAL, + _("Error resolving '%s'"), rrname); + } + + return NULL; + } + + records = NULL; + for (rec = results; rec; rec = rec->pNext) + { + if (rec->wType != dnstype) + continue; + switch (dnstype) + { + case DNS_TYPE_SRV: + record = parse_dns_srv (rec); + break; + case DNS_TYPE_SOA: + record = parse_dns_soa (rec); + break; + case DNS_TYPE_NS: + record = parse_dns_ns (rec); + break; + case DNS_TYPE_MX: + record = parse_dns_mx (rec); + break; + case DNS_TYPE_TEXT: + record = parse_dns_txt (rec); + break; + default: + g_warn_if_reached (); + record = NULL; + break; + } + if (record != NULL) + records = g_list_prepend (records, g_variant_ref_sink (record)); + } + + if (records == NULL) + { + g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_NOT_FOUND, + _("No DNS record of the requested type for '%s'"), rrname); + + return NULL; + } + else + return records; +} + +#endif + +typedef struct { + char *rrname; + GResolverRecordType record_type; +} LookupRecordsData; + +static void +free_lookup_records_data (LookupRecordsData *lrd) +{ + g_free (lrd->rrname); + g_slice_free (LookupRecordsData, lrd); +} static void -do_lookup_service (GThreadedResolverRequest *req, - GError **error) +free_records (GList *records) { + g_list_free_full (records, (GDestroyNotify) g_variant_unref); +} + #if defined(G_OS_UNIX) - gint len, herr; - guchar answer[1024]; -#elif defined(G_OS_WIN32) - DNS_STATUS status; - DNS_RECORD *results; +#ifdef __BIONIC__ +#define C_IN 1 +int res_query(const char *, int, int, u_char *, int); +#endif #endif +static void +do_lookup_records (GTask *task, + gpointer source_object, + gpointer task_data, + GCancellable *cancellable) +{ + LookupRecordsData *lrd = task_data; + GList *records; + GError *error = NULL; + #if defined(G_OS_UNIX) - len = res_query (req->u.service.rrname, C_IN, T_SRV, answer, sizeof (answer)); + gint len = 512; + gint herr; + GByteArray *answer; + gint rrtype; + + rrtype = g_resolver_record_type_to_rrtype (lrd->record_type); + answer = g_byte_array_new (); + for (;;) + { + g_byte_array_set_size (answer, len * 2); + len = res_query (lrd->rrname, C_IN, rrtype, answer->data, answer->len); + + /* If answer fit in the buffer then we're done */ + if (len < 0 || len < (gint)answer->len) + break; + + /* + * On overflow some res_query's return the length needed, others + * return the full length entered. This code works in either case. + */ + } + herr = h_errno; - req->u.service.targets = _g_resolver_targets_from_res_query (req->u.service.rrname, answer, len, herr, error); -#elif defined(G_OS_WIN32) - status = DnsQuery_A (req->u.service.rrname, DNS_TYPE_SRV, - DNS_QUERY_STANDARD, NULL, &results, NULL); - req->u.service.targets = _g_resolver_targets_from_DnsQuery (req->u.service.rrname, status, results, error); - DnsRecordListFree (results, DnsFreeRecordList); + records = g_resolver_records_from_res_query (lrd->rrname, rrtype, answer->data, len, herr, &error); + g_byte_array_free (answer, TRUE); + +#else + + DNS_STATUS status; + DNS_RECORD *results = NULL; + WORD dnstype; + + dnstype = g_resolver_record_type_to_dnstype (lrd->record_type); + status = DnsQuery_A (lrd->rrname, dnstype, DNS_QUERY_STANDARD, NULL, &results, NULL); + records = g_resolver_records_from_DnsQuery (lrd->rrname, dnstype, status, results, &error); + if (results != NULL) + DnsRecordListFree (results, DnsFreeRecordList); + #endif + + if (records) + g_task_return_pointer (task, records, (GDestroyNotify) free_records); + else + g_task_return_error (task, error); } static GList * -lookup_service (GResolver *resolver, - const gchar *rrname, - GCancellable *cancellable, - GError **error) +lookup_records (GResolver *resolver, + const gchar *rrname, + GResolverRecordType record_type, + GCancellable *cancellable, + GError **error) { - GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver); - GThreadedResolverRequest *req; - GList *targets; + GTask *task; + GList *records; + LookupRecordsData *lrd; - req = g_threaded_resolver_request_new (do_lookup_service, NULL, cancellable); - req->u.service.rrname = (char *)rrname; - resolve_sync (gtr, req, error); + task = g_task_new (resolver, cancellable, NULL, NULL); - targets = req->u.service.targets; - g_threaded_resolver_request_unref (req); - return targets; -} + lrd = g_slice_new (LookupRecordsData); + lrd->rrname = g_strdup (rrname); + lrd->record_type = record_type; + g_task_set_task_data (task, lrd, (GDestroyNotify) free_lookup_records_data); -static void -free_lookup_service (GThreadedResolverRequest *req) -{ - g_free (req->u.service.rrname); - if (req->u.service.targets) - g_resolver_free_targets (req->u.service.targets); + g_task_set_return_on_cancel (task, TRUE); + g_task_run_in_thread_sync (task, do_lookup_records); + records = g_task_propagate_pointer (task, error); + g_object_unref (task); + + return records; } static void -lookup_service_async (GResolver *resolver, +lookup_records_async (GResolver *resolver, const char *rrname, - GCancellable *cancellable, + GResolverRecordType record_type, + GCancellable *cancellable, GAsyncReadyCallback callback, - gpointer user_data) + gpointer user_data) { - GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver); - GThreadedResolverRequest *req; - - req = g_threaded_resolver_request_new (do_lookup_service, - free_lookup_service, - cancellable); - req->u.service.rrname = g_strdup (rrname); - resolve_async (gtr, req, callback, user_data, lookup_service_async); + GTask *task; + LookupRecordsData *lrd; + + task = g_task_new (resolver, cancellable, callback, user_data); + + lrd = g_slice_new (LookupRecordsData); + lrd->rrname = g_strdup (rrname); + lrd->record_type = record_type; + g_task_set_task_data (task, lrd, (GDestroyNotify) free_lookup_records_data); + + g_task_set_return_on_cancel (task, TRUE); + g_task_run_in_thread (task, do_lookup_records); + g_object_unref (task); } static GList * -lookup_service_finish (GResolver *resolver, +lookup_records_finish (GResolver *resolver, GAsyncResult *result, - GError **error) + GError **error) { - GThreadedResolverRequest *req; - GList *targets; + g_return_val_if_fail (g_task_is_valid (result, resolver), NULL); - req = resolve_finish (resolver, result, lookup_service_async, error); - targets = req->u.service.targets; - req->u.service.targets = NULL; - return targets; + return g_task_propagate_pointer (G_TASK (result), error); } @@ -599,7 +922,6 @@ static void g_threaded_resolver_class_init (GThreadedResolverClass *threaded_class) { GResolverClass *resolver_class = G_RESOLVER_CLASS (threaded_class); - GObjectClass *object_class = G_OBJECT_CLASS (threaded_class); resolver_class->lookup_by_name = lookup_by_name; resolver_class->lookup_by_name_async = lookup_by_name_async; @@ -607,9 +929,18 @@ g_threaded_resolver_class_init (GThreadedResolverClass *threaded_class) resolver_class->lookup_by_address = lookup_by_address; resolver_class->lookup_by_address_async = lookup_by_address_async; resolver_class->lookup_by_address_finish = lookup_by_address_finish; - resolver_class->lookup_service = lookup_service; - resolver_class->lookup_service_async = lookup_service_async; - resolver_class->lookup_service_finish = lookup_service_finish; + resolver_class->lookup_records = lookup_records; + resolver_class->lookup_records_async = lookup_records_async; + resolver_class->lookup_records_finish = lookup_records_finish; - object_class->finalize = finalize; + /* Initialize addrinfo_hints */ +#ifdef AI_ADDRCONFIG + addrinfo_hints.ai_flags |= AI_ADDRCONFIG; +#endif + /* These two don't actually matter, they just get copied into the + * returned addrinfo structures (and then we ignore them). But if + * we leave them unset, we'll get back duplicate answers. + */ + addrinfo_hints.ai_socktype = SOCK_STREAM; + addrinfo_hints.ai_protocol = IPPROTO_TCP; }