HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/libsystemd/sd-resolve/sd-resolve.c

37,107 bytesGit mode 100644Download original fileLGPL-2.1-or-later

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;
}