sd-resolve: drop res_query() API

Querying low-level DNS RRs should be done via resolved now, not via
glibc's awful res_query() API anymore. Let's not introduce an async
wrapper for it hence.

1 files changed, 0 insertions, 178 deletions

diff --git a/src/libsystemd/sd-resolve/sd-resolve.c b/src/libsystemd/sd-resolve/sd-resolve.c
index b0dc822591..888b372c99 100644
--- a/src/libsystemd/sd-resolve/sd-resolve.c
+++ b/src/libsystemd/sd-resolve/sd-resolve.c
@@ -48,9 +48,6 @@ typedef enum {
         RESPONSE_ADDRINFO,
         REQUEST_NAMEINFO,
         RESPONSE_NAMEINFO,
-        REQUEST_RES_QUERY,
-        REQUEST_RES_SEARCH,
-        RESPONSE_RES,
         REQUEST_TERMINATE,
         RESPONSE_DIED
 } QueryType;
@@ -104,12 +101,10 @@ struct sd_resolve_query {
         int _h_errno;
         struct addrinfo *addrinfo;
         char *serv, *host;
-        unsigned char *answer;
 
         union {
                 sd_resolve_getaddrinfo_handler_t getaddrinfo_handler;
                 sd_resolve_getnameinfo_handler_t getnameinfo_handler;
-                sd_resolve_res_handler_t res_handler;
         };
 
         void *userdata;
@@ -166,33 +161,16 @@ typedef struct NameInfoResponse {
         int _h_errno;
 } NameInfoResponse;
 
-typedef struct ResRequest {
-        struct RHeader header;
-        int class;
-        int type;
-        size_t dname_len;
-} ResRequest;
-
-typedef struct ResResponse {
-        struct RHeader header;
-        int ret;
-        int _errno;
-        int _h_errno;
-} ResResponse;
-
 typedef union Packet {
         RHeader rheader;
         AddrInfoRequest addrinfo_request;
         AddrInfoResponse addrinfo_response;
         NameInfoRequest nameinfo_request;
         NameInfoResponse nameinfo_response;
-        ResRequest res_request;
-        ResResponse res_response;
 } Packet;
 
 static int getaddrinfo_done(sd_resolve_query* q);
 static int getnameinfo_done(sd_resolve_query *q);
-static int res_query_done(sd_resolve_query* q);
 
 static void resolve_query_disconnect(sd_resolve_query *q);
 
@@ -343,38 +321,6 @@ static int send_nameinfo_reply(
         return 0;
 }
 
-static int send_res_reply(int out_fd, unsigned id, const unsigned char *answer, int ret, int _errno, int _h_errno) {
-
-        ResResponse resp = {
-                .header.type = RESPONSE_RES,
-                .header.id = id,
-                .ret = ret,
-                ._errno = _errno,
-                ._h_errno = _h_errno,
-        };
-
-        struct msghdr mh = {};
-        struct iovec iov[2];
-        size_t l;
-
-        assert(out_fd >= 0);
-
-        l = ret > 0 ? (size_t) ret : 0;
-
-        resp.header.length = sizeof(ResResponse) + l;
-
-        iov[0] = (struct iovec) { .iov_base = &resp, .iov_len = sizeof(ResResponse) };
-        iov[1] = (struct iovec) { .iov_base = (void*) answer, .iov_len = l };
-
-        mh.msg_iov = iov;
-        mh.msg_iovlen = ELEMENTSOF(iov);
-
-        if (sendmsg(out_fd, &mh, MSG_NOSIGNAL) < 0)
-                return -errno;
-
-        return 0;
-}
-
 static int handle_request(int out_fd, const Packet *packet, size_t length) {
         const RHeader *req;
 
@@ -437,29 +383,6 @@ static int handle_request(int out_fd, const Packet *packet, size_t length) {
                                errno, h_errno);
         }
 
-        case REQUEST_RES_QUERY:
-        case REQUEST_RES_SEARCH: {
-                 const ResRequest *res_req = &packet->res_request;
-                 union {
-                         HEADER header;
-                         uint8_t space[BUFSIZE];
-                 } answer;
-                 const char *dname;
-                 int ret;
-
-                 assert(length >= sizeof(ResRequest));
-                 assert(length == sizeof(ResRequest) + res_req->dname_len);
-
-                 dname = (const char *) res_req + sizeof(ResRequest);
-
-                 if (req->type == REQUEST_RES_QUERY)
-                         ret = res_query(dname, res_req->class, res_req->type, (unsigned char *) &answer, BUFSIZE);
-                 else
-                         ret = res_search(dname, res_req->class, res_req->type, (unsigned char *) &answer, BUFSIZE);
-
-                 return send_res_reply(out_fd, req->id, (unsigned char *) &answer, ret, errno, h_errno);
-        }
-
         case REQUEST_TERMINATE:
                  /* Quit */
                  return -ECONNRESET;
@@ -752,11 +675,6 @@ static int complete_query(sd_resolve *resolve, sd_resolve_query *q) {
                 r = getnameinfo_done(q);
                 break;
 
-        case REQUEST_RES_QUERY:
-        case REQUEST_RES_SEARCH:
-                r = res_query_done(q);
-                break;
-
         default:
                 assert_not_reached("Cannot complete unknown query type");
         }
@@ -923,28 +841,6 @@ static int handle_response(sd_resolve *resolve, const Packet *packet, size_t len
                 return complete_query(resolve, q);
         }
 
-        case RESPONSE_RES: {
-                const ResResponse *res_resp = &packet->res_response;
-
-                assert(length >= sizeof(ResResponse));
-                assert(q->type == REQUEST_RES_QUERY || q->type == REQUEST_RES_SEARCH);
-
-                q->ret = res_resp->ret;
-                q->_errno = res_resp->_errno;
-                q->_h_errno = res_resp->_h_errno;
-
-                if (res_resp->ret >= 0)  {
-                        q->answer = memdup((const char *)resp + sizeof(ResResponse), res_resp->ret);
-                        if (!q->answer) {
-                                q->ret = -1;
-                                q->_errno = ENOMEM;
-                                q->_h_errno = 0;
-                        }
-                }
-
-                return complete_query(resolve, q);
-        }
-
         default:
                 return 0;
         }
@@ -1181,79 +1077,6 @@ static int getnameinfo_done(sd_resolve_query *q) {
         return q->getnameinfo_handler(q, q->ret, q->host, q->serv, q->userdata);
 }
 
-static int resolve_res(
-                sd_resolve *resolve,
-                sd_resolve_query **_q,
-                QueryType qtype,
-                const char *dname,
-                int class, int type,
-                sd_resolve_res_handler_t callback, void *userdata) {
-
-        struct msghdr mh = {};
-        struct iovec iov[2];
-        ResRequest req = {};
-        sd_resolve_query *q;
-        int r;
-
-        assert_return(resolve, -EINVAL);
-        assert_return(dname, -EINVAL);
-        assert_return(callback, -EINVAL);
-        assert_return(!resolve_pid_changed(resolve), -ECHILD);
-
-        r = alloc_query(resolve, !_q, &q);
-        if (r < 0)
-                return r;
-
-        q->type = qtype;
-        q->res_handler = callback;
-        q->userdata = userdata;
-
-        req.dname_len = strlen(dname) + 1;
-        req.class = class;
-        req.type = type;
-
-        req.header.id = q->id;
-        req.header.type = qtype;
-        req.header.length = sizeof(ResRequest) + req.dname_len;
-
-        iov[0] = (struct iovec) { .iov_base = &req, .iov_len = sizeof(ResRequest) };
-        iov[1] = (struct iovec) { .iov_base = (void*) dname, .iov_len = req.dname_len };
-
-        mh.msg_iov = iov;
-        mh.msg_iovlen = 2;
-
-        if (sendmsg(resolve->fds[REQUEST_SEND_FD], &mh, MSG_NOSIGNAL) < 0) {
-                sd_resolve_query_unref(q);
-                return -errno;
-        }
-
-        resolve->n_outstanding++;
-
-        if (_q)
-                *_q = q;
-
-        return 0;
-}
-
-_public_ int sd_resolve_res_query(sd_resolve *resolve, sd_resolve_query** q, const char *dname, int class, int type, sd_resolve_res_handler_t callback, void *userdata) {
-        return resolve_res(resolve, q, REQUEST_RES_QUERY, dname, class, type, callback, userdata);
-}
-
-_public_ int sd_resolve_res_search(sd_resolve *resolve, sd_resolve_query** q, const char *dname, int class, int type, sd_resolve_res_handler_t callback, void *userdata) {
-        return resolve_res(resolve, q, REQUEST_RES_SEARCH, dname, class, type, callback, userdata);
-}
-
-static int res_query_done(sd_resolve_query* q) {
-        assert(q);
-        assert(q->done);
-        assert(q->res_handler);
-
-        errno = q->_errno;
-        h_errno = q->_h_errno;
-
-        return q->res_handler(q, q->ret, q->answer, q->userdata);
-}
-
 _public_ sd_resolve_query* sd_resolve_query_ref(sd_resolve_query *q) {
         assert_return(q, NULL);
 
@@ -1310,7 +1133,6 @@ static void resolve_query_free(sd_resolve_query *q) {
         resolve_freeaddrinfo(q->addrinfo);
         free(q->host);
         free(q->serv);
-        free(q->answer);
         free(q);
 }