HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/libsystemd/sd-resolve/sd-resolve.c
Git blob: 0f189a50444f544dd955b6a12b13a1d06146dd0f
Lines 1001–1293 of 1,293
static int getaddrinfo_done(sd_resolve_query* q) {
assert(q);
assert(q->done);
assert(q->getaddrinfo_handler);
errno = q->_errno;
h_errno = q->_h_errno;
return q->getaddrinfo_handler(q, q->ret, q->addrinfo, q->userdata);
}
int resolve_getnameinfo_with_destroy_callback(
sd_resolve *resolve,
sd_resolve_query **ret,
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 iovec iov[2];
struct msghdr mh;
int r;
assert_return(resolve, -EINVAL);
assert_return(sa, -EINVAL);
assert_return(salen >= sizeof(struct sockaddr), -EINVAL);
assert_return(salen <= sizeof(union sockaddr_union), -EINVAL);
assert_return((get & ~SD_RESOLVE_GET_BOTH) == 0, -EINVAL);
assert_return(callback, -EINVAL);
assert_return(!resolve_pid_changed(resolve), -ECHILD);
r = alloc_query(resolve, !ret, &q);
if (r < 0)
return r;
q->type = REQUEST_NAMEINFO;
q->getnameinfo_handler = callback;
q->userdata = userdata;
req = (NameInfoRequest) {
.header.id = q->id,
.header.type = REQUEST_NAMEINFO,
.header.length = sizeof(NameInfoRequest) + salen,
.flags = flags,
.sockaddr_len = salen,
.gethost = !!(get & SD_RESOLVE_GET_HOST),
.getserv = !!(get & SD_RESOLVE_GET_SERVICE),
};
msan_unpoison(&req, sizeof(req));
iov[0] = IOVEC_MAKE(&req, sizeof(NameInfoRequest));
iov[1] = IOVEC_MAKE((void*) sa, salen);
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 (ret)
*ret = q;
TAKE_PTR(q);
return 0;
}
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->done);
assert(q->getnameinfo_handler);
errno = q->_errno;
h_errno = q->_h_errno;
return q->getnameinfo_handler(q, q->ret, q->host, q->serv, q->userdata);
}
static void resolve_freeaddrinfo(struct addrinfo *ai) {
while (ai) {
struct addrinfo *next = ai->ai_next;
free(ai->ai_addr);
free(ai->ai_canonname);
free_and_replace(ai, next);
}
}
static void resolve_query_disconnect(sd_resolve_query *q) {
sd_resolve *resolve;
unsigned i;
assert(q);
if (!q->resolve)
return;
resolve = q->resolve;
assert(resolve->n_queries > 0);
if (q->done) {
assert(resolve->n_done > 0);
resolve->n_done--;
}
i = q->id % QUERIES_MAX;
assert(resolve->query_array[i] == q);
resolve->query_array[i] = NULL;
LIST_REMOVE(queries, resolve->queries, q);
resolve->n_queries--;
q->resolve = NULL;
if (!q->floating)
sd_resolve_unref(resolve);
}
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);
return mfree(q);
}
DEFINE_TRIVIAL_REF_UNREF_FUNC(sd_resolve_query, sd_resolve_query, resolve_query_free);
int sd_resolve_query_is_done(sd_resolve_query *q) {
assert_return(q, -EINVAL);
assert_return(!resolve_pid_changed(q->resolve), -ECHILD);
return q->done;
}
void* sd_resolve_query_set_userdata(sd_resolve_query *q, void *userdata) {
void *ret;
assert_return(q, NULL);
assert_return(!resolve_pid_changed(q->resolve), NULL);
ret = q->userdata;
q->userdata = userdata;
return ret;
}
void* sd_resolve_query_get_userdata(sd_resolve_query *q) {
assert_return(q, NULL);
assert_return(!resolve_pid_changed(q->resolve), NULL);
return q->userdata;
}
sd_resolve *sd_resolve_query_get_resolve(sd_resolve_query *q) {
assert_return(q, NULL);
assert_return(!resolve_pid_changed(q->resolve), NULL);
return q->resolve;
}
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;
}
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;
}
int sd_resolve_query_get_floating(sd_resolve_query *q) {
assert_return(q, -EINVAL);
return q->floating;
}
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 = ASSERT_PTR(userdata);
int r;
r = sd_resolve_process(resolve);
if (r < 0)
return r;
return 1;
}
int sd_resolve_attach_event(sd_resolve *resolve, sd_event *event, int64_t priority) {
int r;
assert_return(resolve, -EINVAL);
assert_return(!resolve->event, -EBUSY);
assert(!resolve->event_source);
if (event)
resolve->event = sd_event_ref(event);
else {
r = sd_event_default(&resolve->event);
if (r < 0)
return r;
}
r = sd_event_add_io(resolve->event, &resolve->event_source, resolve->fds[RESPONSE_RECV_FD], POLLIN, io_callback, resolve);
if (r < 0)
goto fail;
r = sd_event_source_set_priority(resolve->event_source, priority);
if (r < 0)
goto fail;
return 0;
fail:
sd_resolve_detach_event(resolve);
return r;
}
int sd_resolve_detach_event(sd_resolve *resolve) {
assert_return(resolve, -EINVAL);
if (!resolve->event)
return 0;
resolve->event_source = sd_event_source_disable_unref(resolve->event_source);
resolve->event = sd_event_unref(resolve->event);
return 1;
}
sd_event *sd_resolve_get_event(sd_resolve *resolve) {
assert_return(resolve, NULL);
return resolve->event;
}