/* SPDX-License-Identifier: LGPL-2.1+ */
-/***
- This file is part of systemd.
-
- Copyright 2005-2008 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/>.
-***/
#include <errno.h>
#include <poll.h>
#include "alloc-util.h"
#include "dns-domain.h"
+#include "errno-util.h"
#include "fd-util.h"
#include "io-util.h"
#include "list.h"
+#include "memory-util.h"
#include "missing.h"
-#include "socket-util.h"
-#include "util.h"
#include "process-util.h"
+#include "resolve-private.h"
+#include "socket-util.h"
#define WORKERS_MIN 1U
#define WORKERS_MAX 16U
};
void *userdata;
+ sd_resolve_destroy_t destroy_callback;
LIST_FIELDS(sd_resolve_query, queries);
};
#define RESOLVE_DONT_DESTROY(resolve) \
_cleanup_(sd_resolve_unrefp) _unused_ sd_resolve *_dont_destroy_##resolve = sd_resolve_ref(resolve)
-static int send_died(int out_fd) {
+static void query_assign_errno(sd_resolve_query *q, int ret, int error, int h_error) {
+ assert(q);
+ q->ret = ret;
+ q->_errno = abs(error);
+ q->_h_errno = h_error;
+}
+
+static int send_died(int out_fd) {
RHeader rh = {
.type = RESPONSE_DIED,
.length = sizeof(RHeader),
if (*length + l > maxlength)
return NULL;
- s.ai_flags = ai->ai_flags;
- s.ai_family = ai->ai_family;
- s.ai_socktype = ai->ai_socktype;
- s.ai_protocol = ai->ai_protocol;
- s.ai_addrlen = ai->ai_addrlen;
- s.canonname_len = cnl;
+ s = (AddrInfoSerialization) {
+ .ai_flags = ai->ai_flags,
+ .ai_family = ai->ai_family,
+ .ai_socktype = ai->ai_socktype,
+ .ai_protocol = ai->ai_protocol,
+ .ai_addrlen = ai->ai_addrlen,
+ .canonname_len = cnl,
+ };
memcpy((uint8_t*) p, &s, sizeof(AddrInfoSerialization));
memcpy((uint8_t*) p + sizeof(AddrInfoSerialization), ai->ai_addr, ai->ai_addrlen);
int _errno,
int _h_errno) {
- AddrInfoResponse resp = {
+ AddrInfoResponse resp = {};
+ union {
+ AddrInfoSerialization ais;
+ uint8_t space[BUFSIZE];
+ } buffer;
+ struct iovec iov[2];
+ struct msghdr mh;
+
+ assert(out_fd >= 0);
+
+ resp = (AddrInfoResponse) {
.header.type = RESPONSE_ADDRINFO,
.header.id = id,
.header.length = sizeof(AddrInfoResponse),
._h_errno = _h_errno,
};
- struct msghdr mh = {};
- struct iovec iov[2];
- union {
- AddrInfoSerialization ais;
- uint8_t space[BUFSIZE];
- } buffer;
-
- assert(out_fd >= 0);
+ msan_unpoison(&resp, sizeof(resp));
if (ret == 0 && ai) {
void *p = &buffer;
if (ai)
freeaddrinfo(ai);
- iov[0] = (struct iovec) { .iov_base = &resp, .iov_len = sizeof(AddrInfoResponse) };
- iov[1] = (struct iovec) { .iov_base = &buffer, .iov_len = resp.header.length - sizeof(AddrInfoResponse) };
+ iov[0] = IOVEC_MAKE(&resp, sizeof(AddrInfoResponse));
+ iov[1] = IOVEC_MAKE(&buffer, resp.header.length - sizeof(AddrInfoResponse));
- mh.msg_iov = iov;
- mh.msg_iovlen = ELEMENTSOF(iov);
+ mh = (struct msghdr) {
+ .msg_iov = iov,
+ .msg_iovlen = ELEMENTSOF(iov)
+ };
if (sendmsg(out_fd, &mh, MSG_NOSIGNAL) < 0)
return -errno;
int _errno,
int _h_errno) {
- NameInfoResponse resp = {
- .header.type = RESPONSE_NAMEINFO,
- .header.id = id,
- .ret = ret,
- ._errno = _errno,
- ._h_errno = _h_errno,
- };
-
- struct msghdr mh = {};
+ NameInfoResponse resp = {};
struct iovec iov[3];
+ struct msghdr mh;
size_t hl, sl;
assert(out_fd >= 0);
sl = serv ? strlen(serv)+1 : 0;
hl = host ? strlen(host)+1 : 0;
- resp.header.length = sizeof(NameInfoResponse) + hl + sl;
- resp.hostlen = hl;
- resp.servlen = sl;
+ resp = (NameInfoResponse) {
+ .header.type = RESPONSE_NAMEINFO,
+ .header.id = id,
+ .header.length = sizeof(NameInfoResponse) + hl + sl,
+ .hostlen = hl,
+ .servlen = sl,
+ .ret = ret,
+ ._errno = _errno,
+ ._h_errno = _h_errno,
+ };
+
+ msan_unpoison(&resp, sizeof(resp));
- iov[0] = (struct iovec) { .iov_base = &resp, .iov_len = sizeof(NameInfoResponse) };
- iov[1] = (struct iovec) { .iov_base = (void*) host, .iov_len = hl };
- iov[2] = (struct iovec) { .iov_base = (void*) serv, .iov_len = sl };
+ iov[0] = IOVEC_MAKE(&resp, sizeof(NameInfoResponse));
+ iov[1] = IOVEC_MAKE((void*) host, hl);
+ iov[2] = IOVEC_MAKE((void*) serv, sl);
- mh.msg_iov = iov;
- mh.msg_iovlen = ELEMENTSOF(iov);
+ mh = (struct msghdr) {
+ .msg_iov = iov,
+ .msg_iovlen = ELEMENTSOF(iov)
+ };
if (sendmsg(out_fd, &mh, MSG_NOSIGNAL) < 0)
return -errno;
req = &packet->rheader;
- assert(length >= sizeof(RHeader));
- assert(length == req->length);
+ assert_return(length >= sizeof(RHeader), -EIO);
+ assert_return(length == req->length, -EIO);
switch (req->type) {
case REQUEST_ADDRINFO: {
const AddrInfoRequest *ai_req = &packet->addrinfo_request;
- struct addrinfo hints = {}, *result = NULL;
+ struct addrinfo hints, *result = NULL;
const char *node, *service;
int ret;
- assert(length >= sizeof(AddrInfoRequest));
- assert(length == sizeof(AddrInfoRequest) + ai_req->node_len + ai_req->service_len);
+ assert_return(length >= sizeof(AddrInfoRequest), -EBADMSG);
+ assert_return(length == sizeof(AddrInfoRequest) + ai_req->node_len + ai_req->service_len, -EBADMSG);
- hints.ai_flags = ai_req->ai_flags;
- hints.ai_family = ai_req->ai_family;
- hints.ai_socktype = ai_req->ai_socktype;
- hints.ai_protocol = ai_req->ai_protocol;
+ hints = (struct addrinfo) {
+ .ai_flags = ai_req->ai_flags,
+ .ai_family = ai_req->ai_family,
+ .ai_socktype = ai_req->ai_socktype,
+ .ai_protocol = ai_req->ai_protocol,
+ };
+
+ msan_unpoison(&hints, sizeof(hints));
node = ai_req->node_len ? (const char*) ai_req + sizeof(AddrInfoRequest) : NULL;
service = ai_req->service_len ? (const char*) ai_req + sizeof(AddrInfoRequest) + ai_req->node_len : NULL;
- ret = getaddrinfo(
- node, service,
- ai_req->hints_valid ? &hints : NULL,
- &result);
+ ret = getaddrinfo(node, service,
+ ai_req->hints_valid ? &hints : NULL,
+ &result);
/* send_addrinfo_reply() frees result */
return send_addrinfo_reply(out_fd, req->id, ret, result, errno, h_errno);
union sockaddr_union sa;
int ret;
- assert(length >= sizeof(NameInfoRequest));
- assert(length == sizeof(NameInfoRequest) + ni_req->sockaddr_len);
- assert(sizeof(sa) >= ni_req->sockaddr_len);
+ assert_return(length >= sizeof(NameInfoRequest), -EBADMSG);
+ assert_return(length == sizeof(NameInfoRequest) + ni_req->sockaddr_len, -EBADMSG);
+ assert_return(ni_req->sockaddr_len <= sizeof(sa), -EBADMSG);
memcpy(&sa, (const uint8_t *) ni_req + sizeof(NameInfoRequest), ni_req->sockaddr_len);
ret = getnameinfo(&sa.sa, ni_req->sockaddr_len,
- ni_req->gethost ? hostbuf : NULL, ni_req->gethost ? sizeof(hostbuf) : 0,
- ni_req->getserv ? servbuf : NULL, ni_req->getserv ? sizeof(servbuf) : 0,
- ni_req->flags);
+ ni_req->gethost ? hostbuf : NULL, ni_req->gethost ? sizeof(hostbuf) : 0,
+ ni_req->getserv ? servbuf : NULL, ni_req->getserv ? sizeof(servbuf) : 0,
+ ni_req->flags);
return send_nameinfo_reply(out_fd, req->id, ret,
- ret == 0 && ni_req->gethost ? hostbuf : NULL,
- ret == 0 && ni_req->getserv ? servbuf : NULL,
- errno, h_errno);
+ ret == 0 && ni_req->gethost ? hostbuf : NULL,
+ ret == 0 && ni_req->getserv ? servbuf : NULL,
+ errno, h_errno);
}
case REQUEST_TERMINATE:
} buf;
ssize_t length;
- length = recv(resolve->fds[REQUEST_RECV_FD], &buf, sizeof(buf), 0);
+ length = recv(resolve->fds[REQUEST_RECV_FD], &buf, sizeof buf, 0);
if (length < 0) {
if (errno == EINTR)
continue;
if (length == 0)
break;
- if (resolve->dead)
- break;
-
if (handle_request(resolve->fds[RESPONSE_SEND_FD], &buf.packet, (size_t) length) < 0)
break;
}
unsigned n;
int r, k;
- if (sigfillset(&ss) < 0)
- return -errno;
+ assert_se(sigfillset(&ss) >= 0);
/* No signals in forked off threads please. We set the mask before forking, so that the threads never exist
* with a different mask than a fully blocked one */
n = CLAMP(n, WORKERS_MIN, WORKERS_MAX);
while (resolve->n_valid_workers < n) {
-
r = pthread_create(&resolve->workers[resolve->n_valid_workers], NULL, thread_worker, resolve);
if (r > 0) {
r = -r;
}
_public_ int sd_resolve_new(sd_resolve **ret) {
- sd_resolve *resolve = NULL;
- int i, r;
+ _cleanup_(sd_resolve_unrefp) sd_resolve *resolve = NULL;
+ int i;
assert_return(ret, -EINVAL);
for (i = 0; i < _FD_MAX; i++)
resolve->fds[i] = -1;
- r = socketpair(PF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0, resolve->fds + REQUEST_RECV_FD);
- if (r < 0) {
- r = -errno;
- goto fail;
- }
+ if (socketpair(PF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0, resolve->fds + REQUEST_RECV_FD) < 0)
+ return -errno;
- r = socketpair(PF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0, resolve->fds + RESPONSE_RECV_FD);
- if (r < 0) {
- r = -errno;
- goto fail;
- }
+ if (socketpair(PF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0, resolve->fds + RESPONSE_RECV_FD) < 0)
+ return -errno;
- fd_inc_sndbuf(resolve->fds[REQUEST_SEND_FD], QUERIES_MAX * BUFSIZE);
- fd_inc_rcvbuf(resolve->fds[REQUEST_RECV_FD], QUERIES_MAX * BUFSIZE);
- fd_inc_sndbuf(resolve->fds[RESPONSE_SEND_FD], QUERIES_MAX * BUFSIZE);
- fd_inc_rcvbuf(resolve->fds[RESPONSE_RECV_FD], QUERIES_MAX * BUFSIZE);
+ for (i = 0; i < _FD_MAX; i++)
+ resolve->fds[i] = fd_move_above_stdio(resolve->fds[i]);
- fd_nonblock(resolve->fds[RESPONSE_RECV_FD], true);
+ (void) fd_inc_sndbuf(resolve->fds[REQUEST_SEND_FD], QUERIES_MAX * BUFSIZE);
+ (void) fd_inc_rcvbuf(resolve->fds[REQUEST_RECV_FD], QUERIES_MAX * BUFSIZE);
+ (void) fd_inc_sndbuf(resolve->fds[RESPONSE_SEND_FD], QUERIES_MAX * BUFSIZE);
+ (void) fd_inc_rcvbuf(resolve->fds[RESPONSE_RECV_FD], QUERIES_MAX * BUFSIZE);
- *ret = resolve;
- return 0;
+ (void) fd_nonblock(resolve->fds[RESPONSE_RECV_FD], true);
-fail:
- sd_resolve_unref(resolve);
- return r;
+ *ret = TAKE_PTR(resolve);
+ return 0;
}
_public_ int sd_resolve_default(sd_resolve **ret) {
-
static thread_local sd_resolve *default_resolve = NULL;
sd_resolve *e = NULL;
int r;
return -ENXIO;
}
-static void resolve_free(sd_resolve *resolve) {
+static sd_resolve *resolve_free(sd_resolve *resolve) {
PROTECT_ERRNO;
sd_resolve_query *q;
unsigned i;
RHeader req = {
.type = REQUEST_TERMINATE,
- .length = sizeof(req)
+ .length = sizeof req,
};
/* Send one termination packet for each worker */
/* Close all communication channels */
close_many(resolve->fds, _FD_MAX);
- free(resolve);
-}
-
-_public_ sd_resolve* sd_resolve_ref(sd_resolve *resolve) {
- assert_return(resolve, NULL);
- assert(resolve->n_ref >= 1);
- resolve->n_ref++;
-
- return resolve;
+ return mfree(resolve);
}
-_public_ sd_resolve* sd_resolve_unref(sd_resolve *resolve) {
-
- if (!resolve)
- return NULL;
-
- assert(resolve->n_ref >= 1);
- resolve->n_ref--;
-
- if (resolve->n_ref <= 0)
- resolve_free(resolve);
-
- return NULL;
-}
+DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_resolve, sd_resolve, resolve_free);
_public_ int sd_resolve_get_fd(sd_resolve *resolve) {
assert_return(resolve, -EINVAL);
static int unserialize_addrinfo(const void **p, size_t *length, struct addrinfo **ret_ai) {
AddrInfoSerialization s;
- size_t l;
struct addrinfo *ai;
+ size_t l;
assert(p);
assert(*p);
if (*length < l)
return -EBADMSG;
- ai = new0(struct addrinfo, 1);
+ ai = new(struct addrinfo, 1);
if (!ai)
return -ENOMEM;
- ai->ai_flags = s.ai_flags;
- ai->ai_family = s.ai_family;
- ai->ai_socktype = s.ai_socktype;
- ai->ai_protocol = s.ai_protocol;
- ai->ai_addrlen = s.ai_addrlen;
+ *ai = (struct addrinfo) {
+ .ai_flags = s.ai_flags,
+ .ai_family = s.ai_family,
+ .ai_socktype = s.ai_socktype,
+ .ai_protocol = s.ai_protocol,
+ .ai_addrlen = s.ai_addrlen,
+ };
if (s.ai_addrlen > 0) {
ai->ai_addr = memdup((const uint8_t*) *p + sizeof(AddrInfoSerialization), s.ai_addrlen);
int r;
assert(resolve);
+ assert(packet);
resp = &packet->rheader;
- assert(resp);
- assert(length >= sizeof(RHeader));
- assert(length == resp->length);
+ assert_return(length >= sizeof(RHeader), -EIO);
+ assert_return(length == resp->length, -EIO);
if (resp->type == RESPONSE_DIED) {
resolve->dead = true;
size_t l;
struct addrinfo *prev = NULL;
- assert(length >= sizeof(AddrInfoResponse));
- assert(q->type == REQUEST_ADDRINFO);
+ assert_return(length >= sizeof(AddrInfoResponse), -EBADMSG);
+ assert_return(q->type == REQUEST_ADDRINFO, -EBADMSG);
- q->ret = ai_resp->ret;
- q->_errno = ai_resp->_errno;
- q->_h_errno = ai_resp->_h_errno;
+ query_assign_errno(q, ai_resp->ret, ai_resp->_errno, ai_resp->_h_errno);
l = length - sizeof(AddrInfoResponse);
p = (const uint8_t*) resp + sizeof(AddrInfoResponse);
r = unserialize_addrinfo(&p, &l, &ai);
if (r < 0) {
- q->ret = EAI_SYSTEM;
- q->_errno = -r;
- q->_h_errno = 0;
+ query_assign_errno(q, EAI_SYSTEM, r, 0);
freeaddrinfo(q->addrinfo);
q->addrinfo = NULL;
break;
case RESPONSE_NAMEINFO: {
const NameInfoResponse *ni_resp = &packet->nameinfo_response;
- assert(length >= sizeof(NameInfoResponse));
- assert(q->type == REQUEST_NAMEINFO);
+ assert_return(length >= sizeof(NameInfoResponse), -EBADMSG);
+ assert_return(q->type == REQUEST_NAMEINFO, -EBADMSG);
if (ni_resp->hostlen > DNS_HOSTNAME_MAX ||
ni_resp->servlen > DNS_HOSTNAME_MAX ||
- sizeof(NameInfoResponse) + ni_resp->hostlen + ni_resp->servlen > length + 2) {
- q->ret = EAI_SYSTEM;
- q->_errno = -EIO;
- q->_h_errno = 0;
-
- } else {
- q->ret = ni_resp->ret;
- q->_errno = ni_resp->_errno;
- q->_h_errno = ni_resp->_h_errno;
+ sizeof(NameInfoResponse) + ni_resp->hostlen + ni_resp->servlen > length)
+ query_assign_errno(q, EAI_SYSTEM, EIO, 0);
+ else {
+ query_assign_errno(q, ni_resp->ret, ni_resp->_errno, ni_resp->_h_errno);
if (ni_resp->hostlen > 0) {
q->host = strndup((const char*) ni_resp + sizeof(NameInfoResponse),
ni_resp->hostlen-1);
- if (!q->host) {
- q->ret = EAI_MEMORY;
- q->_errno = ENOMEM;
- q->_h_errno = 0;
- }
+ if (!q->host)
+ query_assign_errno(q, EAI_MEMORY, ENOMEM, 0);
}
if (ni_resp->servlen > 0) {
q->serv = strndup((const char*) ni_resp + sizeof(NameInfoResponse) + ni_resp->hostlen,
ni_resp->servlen-1);
- if (!q->serv) {
- q->ret = EAI_MEMORY;
- q->_errno = ENOMEM;
- q->_h_errno = 0;
- }
+ if (!q->serv)
+ query_assign_errno(q, EAI_MEMORY, ENOMEM, 0);
}
}
/* We don't allow recursively invoking sd_resolve_process(). */
assert_return(!resolve->current, -EBUSY);
- l = recv(resolve->fds[RESPONSE_RECV_FD], &buf, sizeof(buf), 0);
+ l = recv(resolve->fds[RESPONSE_RECV_FD], &buf, sizeof buf, 0);
if (l < 0) {
if (errno == EAGAIN)
return 0;
return 0;
}
-_public_ int sd_resolve_getaddrinfo(
+int resolve_getaddrinfo_with_destroy_callback(
sd_resolve *resolve,
- sd_resolve_query **_q,
+ sd_resolve_query **ret_query,
const char *node, const char *service,
const struct addrinfo *hints,
- sd_resolve_getaddrinfo_handler_t callback, void *userdata) {
+ sd_resolve_getaddrinfo_handler_t callback,
+ sd_resolve_destroy_t destroy_callback,
+ void *userdata) {
+ _cleanup_(sd_resolve_query_unrefp) sd_resolve_query *q = NULL;
+ size_t node_len, service_len;
AddrInfoRequest req = {};
- struct msghdr mh = {};
struct iovec iov[3];
- sd_resolve_query *q;
+ struct msghdr mh = {};
int r;
assert_return(resolve, -EINVAL);
assert_return(callback, -EINVAL);
assert_return(!resolve_pid_changed(resolve), -ECHILD);
- r = alloc_query(resolve, !_q, &q);
+ r = alloc_query(resolve, !ret_query, &q);
if (r < 0)
return r;
q->getaddrinfo_handler = callback;
q->userdata = userdata;
- req.node_len = node ? strlen(node)+1 : 0;
- req.service_len = service ? strlen(service)+1 : 0;
+ node_len = node ? strlen(node) + 1 : 0;
+ service_len = service ? strlen(service) + 1 : 0;
- req.header.id = q->id;
- req.header.type = REQUEST_ADDRINFO;
- req.header.length = sizeof(AddrInfoRequest) + req.node_len + req.service_len;
+ req = (AddrInfoRequest) {
+ .node_len = node_len,
+ .service_len = service_len,
- if (hints) {
- req.hints_valid = true;
- req.ai_flags = hints->ai_flags;
- req.ai_family = hints->ai_family;
- req.ai_socktype = hints->ai_socktype;
- req.ai_protocol = hints->ai_protocol;
- }
+ .header.id = q->id,
+ .header.type = REQUEST_ADDRINFO,
+ .header.length = sizeof(AddrInfoRequest) + node_len + service_len,
- iov[mh.msg_iovlen++] = (struct iovec) { .iov_base = &req, .iov_len = sizeof(AddrInfoRequest) };
+ .hints_valid = hints,
+ .ai_flags = hints ? hints->ai_flags : 0,
+ .ai_family = hints ? hints->ai_family : 0,
+ .ai_socktype = hints ? hints->ai_socktype : 0,
+ .ai_protocol = hints ? hints->ai_protocol : 0,
+ };
+
+ msan_unpoison(&req, sizeof(req));
+
+ iov[mh.msg_iovlen++] = IOVEC_MAKE(&req, sizeof(AddrInfoRequest));
if (node)
- iov[mh.msg_iovlen++] = (struct iovec) { .iov_base = (void*) node, .iov_len = req.node_len };
+ iov[mh.msg_iovlen++] = IOVEC_MAKE((void*) node, req.node_len);
if (service)
- iov[mh.msg_iovlen++] = (struct iovec) { .iov_base = (void*) service, .iov_len = req.service_len };
+ iov[mh.msg_iovlen++] = IOVEC_MAKE((void*) service, req.service_len);
mh.msg_iov = iov;
- if (sendmsg(resolve->fds[REQUEST_SEND_FD], &mh, MSG_NOSIGNAL) < 0) {
- sd_resolve_query_unref(q);
+ if (sendmsg(resolve->fds[REQUEST_SEND_FD], &mh, MSG_NOSIGNAL) < 0)
return -errno;
- }
resolve->n_outstanding++;
+ q->destroy_callback = destroy_callback;
- if (_q)
- *_q = q;
+ if (ret_query)
+ *ret_query = q;
+
+ TAKE_PTR(q);
return 0;
}
+_public_ int sd_resolve_getaddrinfo(
+ sd_resolve *resolve,
+ sd_resolve_query **ret_query,
+ const char *node, const char *service,
+ const struct addrinfo *hints,
+ sd_resolve_getaddrinfo_handler_t callback,
+ void *userdata) {
+
+ return resolve_getaddrinfo_with_destroy_callback(resolve, ret_query, node, service, hints, callback, NULL, userdata);
+}
+
static int getaddrinfo_done(sd_resolve_query* q) {
assert(q);
assert(q->done);
return q->getaddrinfo_handler(q, q->ret, q->addrinfo, q->userdata);
}
-_public_ int sd_resolve_getnameinfo(
+int resolve_getnameinfo_with_destroy_callback(
sd_resolve *resolve,
- sd_resolve_query**_q,
+ sd_resolve_query **ret_query,
const struct sockaddr *sa, socklen_t salen,
int flags,
uint64_t get,
sd_resolve_getnameinfo_handler_t callback,
+ sd_resolve_destroy_t destroy_callback,
void *userdata) {
+ _cleanup_(sd_resolve_query_unrefp) sd_resolve_query *q = NULL;
NameInfoRequest req = {};
- struct msghdr mh = {};
struct iovec iov[2];
- sd_resolve_query *q;
+ struct msghdr mh;
int r;
assert_return(resolve, -EINVAL);
assert_return(callback, -EINVAL);
assert_return(!resolve_pid_changed(resolve), -ECHILD);
- r = alloc_query(resolve, !_q, &q);
+ r = alloc_query(resolve, !ret_query, &q);
if (r < 0)
return r;
q->getnameinfo_handler = callback;
q->userdata = userdata;
- req.header.id = q->id;
- req.header.type = REQUEST_NAMEINFO;
- req.header.length = sizeof(NameInfoRequest) + salen;
+ req = (NameInfoRequest) {
+ .header.id = q->id,
+ .header.type = REQUEST_NAMEINFO,
+ .header.length = sizeof(NameInfoRequest) + salen,
- req.flags = flags;
- req.sockaddr_len = salen;
- req.gethost = !!(get & SD_RESOLVE_GET_HOST);
- req.getserv = !!(get & SD_RESOLVE_GET_SERVICE);
+ .flags = flags,
+ .sockaddr_len = salen,
+ .gethost = !!(get & SD_RESOLVE_GET_HOST),
+ .getserv = !!(get & SD_RESOLVE_GET_SERVICE),
+ };
- iov[0] = (struct iovec) { .iov_base = &req, .iov_len = sizeof(NameInfoRequest) };
- iov[1] = (struct iovec) { .iov_base = (void*) sa, .iov_len = salen };
+ msan_unpoison(&req, sizeof(req));
- mh.msg_iov = iov;
- mh.msg_iovlen = 2;
+ iov[0] = IOVEC_MAKE(&req, sizeof(NameInfoRequest));
+ iov[1] = IOVEC_MAKE((void*) sa, salen);
- if (sendmsg(resolve->fds[REQUEST_SEND_FD], &mh, MSG_NOSIGNAL) < 0) {
- sd_resolve_query_unref(q);
+ mh = (struct msghdr) {
+ .msg_iov = iov,
+ .msg_iovlen = ELEMENTSOF(iov)
+ };
+
+ if (sendmsg(resolve->fds[REQUEST_SEND_FD], &mh, MSG_NOSIGNAL) < 0)
return -errno;
- }
resolve->n_outstanding++;
+ q->destroy_callback = destroy_callback;
- if (_q)
- *_q = q;
+ if (ret_query)
+ *ret_query = q;
+
+ TAKE_PTR(q);
return 0;
}
+_public_ int sd_resolve_getnameinfo(
+ sd_resolve *resolve,
+ sd_resolve_query **ret_query,
+ const struct sockaddr *sa, socklen_t salen,
+ int flags,
+ uint64_t get,
+ sd_resolve_getnameinfo_handler_t callback,
+ void *userdata) {
+
+ return resolve_getnameinfo_with_destroy_callback(resolve, ret_query, sa, salen, flags, get, callback, NULL, userdata);
+}
+
static int getnameinfo_done(sd_resolve_query *q) {
assert(q);
assert(q->getnameinfo_handler);
errno = q->_errno;
- h_errno= q->_h_errno;
+ h_errno = q->_h_errno;
return q->getnameinfo_handler(q, q->ret, q->host, q->serv, q->userdata);
}
-_public_ sd_resolve_query* sd_resolve_query_ref(sd_resolve_query *q) {
- assert_return(q, NULL);
-
- assert(q->n_ref >= 1);
- q->n_ref++;
-
- return q;
-}
-
static void resolve_freeaddrinfo(struct addrinfo *ai) {
while (ai) {
struct addrinfo *next = ai->ai_next;
sd_resolve_unref(resolve);
}
-static void resolve_query_free(sd_resolve_query *q) {
+static sd_resolve_query *resolve_query_free(sd_resolve_query *q) {
assert(q);
resolve_query_disconnect(q);
+ if (q->destroy_callback)
+ q->destroy_callback(q->userdata);
+
resolve_freeaddrinfo(q->addrinfo);
free(q->host);
free(q->serv);
- free(q);
-}
-
-_public_ sd_resolve_query* sd_resolve_query_unref(sd_resolve_query* q) {
- if (!q)
- return NULL;
- assert(q->n_ref >= 1);
- q->n_ref--;
-
- if (q->n_ref <= 0)
- resolve_query_free(q);
-
- return NULL;
+ return mfree(q);
}
+DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_resolve_query, sd_resolve_query, resolve_query_free);
+
_public_ int sd_resolve_query_is_done(sd_resolve_query *q) {
assert_return(q, -EINVAL);
assert_return(!resolve_pid_changed(q->resolve), -ECHILD);
return q->resolve;
}
+_public_ int sd_resolve_query_get_destroy_callback(sd_resolve_query *q, sd_resolve_destroy_t *destroy_callback) {
+ assert_return(q, -EINVAL);
+
+ if (destroy_callback)
+ *destroy_callback = q->destroy_callback;
+
+ return !!q->destroy_callback;
+}
+
+_public_ int sd_resolve_query_set_destroy_callback(sd_resolve_query *q, sd_resolve_destroy_t destroy_callback) {
+ assert_return(q, -EINVAL);
+
+ q->destroy_callback = destroy_callback;
+ return 0;
+}
+
+_public_ int sd_resolve_query_get_floating(sd_resolve_query *q) {
+ assert_return(q, -EINVAL);
+
+ return q->floating;
+}
+
+_public_ int sd_resolve_query_set_floating(sd_resolve_query *q, int b) {
+ assert_return(q, -EINVAL);
+
+ if (q->floating == !!b)
+ return 0;
+
+ if (!q->resolve) /* Already disconnected */
+ return -ESTALE;
+
+ q->floating = b;
+
+ if (b) {
+ sd_resolve_query_ref(q);
+ sd_resolve_unref(q->resolve);
+ } else {
+ sd_resolve_ref(q->resolve);
+ sd_resolve_query_unref(q);
+ }
+
+ return 1;
+}
+
static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
sd_resolve *resolve = userdata;
int r;
projects / thirdparty / systemd.git / blobdiff