<div dir="ltr">Okay, guess thats right? Second opinion, lennart? Kay?</div><div class="gmail_extra"> <div class="gmail_quote">2014/1/13 Tom Gundersen <<a href="mailto:teg@jklm.no" target="_blank">teg@jklm.no</a>> <blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div class="HOEnZb"><div class="h5">On Sun, Jan 12, 2014 at 7:42 PM, Daniel Buch <<a href="mailto:boogiewasthere@gmail.com">boogiewasthere@gmail.com</a>> wrote: > --- > src/libsystemd-bus/dns-util.h | 12 ++--- > src/libsystemd-bus/sd-dns.c | 100 +++++++++++++++++++++--------------------- > src/libsystemd-bus/test-dns.c | 26 +++++------ > src/systemd/sd-dns.h | 46 +++++++++---------- > 4 files changed, 92 insertions(+), 92 deletions(-) > > diff --git a/src/libsystemd-bus/dns-util.h b/src/libsystemd-bus/dns-util.h > index e0284c8..15ab28b 100644 > --- a/src/libsystemd-bus/dns-util.h > +++ b/src/libsystemd-bus/dns-util.h > @@ -23,9 +23,9 @@ > > #include "util.h" > > -DEFINE_TRIVIAL_CLEANUP_FUNC(asyncns_t*, asyncns_free); > -DEFINE_TRIVIAL_CLEANUP_FUNC(unsigned char *, asyncns_freeanswer); > -DEFINE_TRIVIAL_CLEANUP_FUNC(struct addrinfo*, asyncns_freeaddrinfo); > -#define _cleanup_asyncns_free_ _cleanup_(asyncns_freep) > -#define _cleanup_asyncns_answer_free_ _cleanup_(asyncns_freeanswerp) > -#define _cleanup_asyncns_addrinfo_free_ _cleanup_(asyncns_freeaddrinfop) > +DEFINE_TRIVIAL_CLEANUP_FUNC(sd_asyncns_t*, sd_asyncns_free); > +DEFINE_TRIVIAL_CLEANUP_FUNC(unsigned char *, sd_asyncns_freeanswer); > +DEFINE_TRIVIAL_CLEANUP_FUNC(struct addrinfo*, sd_asyncns_freeaddrinfo); > +#define _cleanup_asyncns_free_ _cleanup_(sd_asyncns_freep) > +#define _cleanup_asyncns_answer_free_ _cleanup_(sd_asyncns_freeanswerp) > +#define _cleanup_asyncns_addrinfo_free_ _cleanup_(sd_asyncns_freeaddrinfop) > diff --git a/src/libsystemd-bus/sd-dns.c b/src/libsystemd-bus/sd-dns.c > index 0f90d02..7062ee2 100644 > --- a/src/libsystemd-bus/sd-dns.c > +++ b/src/libsystemd-bus/sd-dns.c > @@ -68,27 +68,27 @@ enum { > MESSAGE_FD_MAX = 4 > }; > > -struct asyncns { > +struct sd_asyncns { > int fds[MESSAGE_FD_MAX]; > > pthread_t workers[MAX_WORKERS]; > unsigned valid_workers; > > unsigned current_id, current_index; > - asyncns_query_t* queries[MAX_QUERIES]; > + sd_asyncns_query_t* queries[MAX_QUERIES]; > > - asyncns_query_t *done_head, *done_tail; > + sd_asyncns_query_t *done_head, *done_tail; > > int n_queries; > int dead; > }; > > -struct asyncns_query { > - asyncns_t *asyncns; > +struct sd_asyncns_query { > + sd_asyncns_t *asyncns; > int done; > unsigned id; > query_type_t type; > - asyncns_query_t *done_next, *done_prev; > + sd_asyncns_query_t *done_next, *done_prev; > int ret; > int _errno; > int _h_errno; > @@ -383,7 +383,7 @@ static int handle_request(int out_fd, const packet_t *packet, size_t length) { > } > > static void* thread_worker(void *p) { > - asyncns_t *asyncns = p; > + sd_asyncns_t *asyncns = p; > sigset_t fullset; > > /* No signals in this thread please */ > @@ -414,16 +414,16 @@ static void* thread_worker(void *p) { > return NULL; > } > > -asyncns_t* asyncns_new(unsigned n_proc) { > +sd_asyncns_t* sd_asyncns_new(unsigned n_proc) { > int i; > - asyncns_t *asyncns = NULL; > + sd_asyncns_t *asyncns = NULL; > > assert(n_proc >= 1); > > if (n_proc > MAX_WORKERS) > n_proc = MAX_WORKERS; > > - asyncns = malloc(sizeof(asyncns_t)); > + asyncns = malloc(sizeof(sd_asyncns_t)); > if (!asyncns) { > errno = ENOMEM; > goto fail; > @@ -475,12 +475,12 @@ asyncns_t* asyncns_new(unsigned n_proc) { > > fail: > if (asyncns) > - asyncns_free(asyncns); > + sd_asyncns_free(asyncns); > > return NULL; > } > > -void asyncns_free(asyncns_t *asyncns) { > +void sd_asyncns_free(sd_asyncns_t *asyncns) { > int i; > int saved_errno = errno; > unsigned p; > @@ -516,21 +516,21 @@ void asyncns_free(asyncns_t *asyncns) { > > for (p = 0; p < MAX_QUERIES; p++) > if (asyncns->queries[p]) > - asyncns_cancel(asyncns, asyncns->queries[p]); > + sd_asyncns_cancel(asyncns, asyncns->queries[p]); > > free(asyncns); > > errno = saved_errno; > } > > -int asyncns_fd(asyncns_t *asyncns) { > +int asyncns_fd(sd_asyncns_t *asyncns) { > assert(asyncns); > > return asyncns->fds[RESPONSE_RECV_FD]; > } > > -static asyncns_query_t *lookup_query(asyncns_t *asyncns, unsigned id) { > - asyncns_query_t *q; > +static sd_asyncns_query_t *lookup_query(sd_asyncns_t *asyncns, unsigned id) { > + sd_asyncns_query_t *q; > assert(asyncns); > > q = asyncns->queries[id % MAX_QUERIES]; > @@ -541,7 +541,7 @@ static asyncns_query_t *lookup_query(asyncns_t *asyncns, unsigned id) { > return NULL; > } > > -static void complete_query(asyncns_t *asyncns, asyncns_query_t *q) { > +static void complete_query(sd_asyncns_t *asyncns, sd_asyncns_query_t *q) { > assert(asyncns); > assert(q); > assert(!q->done); > @@ -608,14 +608,14 @@ static const void *unserialize_addrinfo(const void *p, struct addrinfo **ret_ai, > > fail: > if (ai) > - asyncns_freeaddrinfo(ai); > + sd_asyncns_freeaddrinfo(ai); > > return NULL; > } > > -static int handle_response(asyncns_t *asyncns, const packet_t *packet, size_t length) { > +static int handle_response(sd_asyncns_t *asyncns, const packet_t *packet, size_t length) { > const rheader_t *resp; > - asyncns_query_t *q; > + sd_asyncns_query_t *q; > > assert(asyncns); > > @@ -721,7 +721,7 @@ static int handle_response(asyncns_t *asyncns, const packet_t *packet, size_t le > return 0; > } > > -int asyncns_wait(asyncns_t *asyncns, int block) { > +int sd_asyncns_wait(sd_asyncns_t *asyncns, int block) { > int handled = 0; > assert(asyncns); > > @@ -760,8 +760,8 @@ int asyncns_wait(asyncns_t *asyncns, int block) { > } > } > > -static asyncns_query_t *alloc_query(asyncns_t *asyncns) { > - asyncns_query_t *q; > +static sd_asyncns_query_t *alloc_query(sd_asyncns_t *asyncns) { > + sd_asyncns_query_t *q; > assert(asyncns); > > if (asyncns->n_queries >= MAX_QUERIES) { > @@ -777,7 +777,7 @@ static asyncns_query_t *alloc_query(asyncns_t *asyncns) { > asyncns->current_index -= MAX_QUERIES; > } > > - q = asyncns->queries[asyncns->current_index] = malloc(sizeof(asyncns_query_t)); > + q = asyncns->queries[asyncns->current_index] = malloc(sizeof(sd_asyncns_query_t)); > if (!q) { > errno = ENOMEM; > return NULL; > @@ -799,10 +799,10 @@ static asyncns_query_t *alloc_query(asyncns_t *asyncns) { > return q; > } > > -asyncns_query_t* asyncns_getaddrinfo(asyncns_t *asyncns, const char *node, const char *service, const struct addrinfo *hints) { > +sd_asyncns_query_t* sd_asyncns_getaddrinfo(sd_asyncns_t *asyncns, const char *node, const char *service, const struct addrinfo *hints) { > addrinfo_request_t data[BUFSIZE/sizeof(addrinfo_request_t) + 1] = {}; > addrinfo_request_t *req = data; > - asyncns_query_t *q; > + sd_asyncns_query_t *q; > assert(asyncns); > assert(node || service); > > @@ -847,12 +847,12 @@ asyncns_query_t* asyncns_getaddrinfo(asyncns_t *asyncns, const char *node, const > > fail: > if (q) > - asyncns_cancel(asyncns, q); > + sd_asyncns_cancel(asyncns, q); > > return NULL; > } > > -int asyncns_getaddrinfo_done(asyncns_t *asyncns, asyncns_query_t* q, struct addrinfo **ret_res) { > +int sd_asyncns_getaddrinfo_done(sd_asyncns_t *asyncns, sd_asyncns_query_t* q, struct addrinfo **ret_res) { > int ret; > assert(asyncns); > assert(q); > @@ -878,15 +878,15 @@ int asyncns_getaddrinfo_done(asyncns_t *asyncns, asyncns_query_t* q, struct addr > if (ret != 0) > h_errno = q->_h_errno; > > - asyncns_cancel(asyncns, q); > + sd_asyncns_cancel(asyncns, q); > > return ret; > } > > -asyncns_query_t* asyncns_getnameinfo(asyncns_t *asyncns, const struct sockaddr *sa, socklen_t salen, int flags, int gethost, int getserv) { > +sd_asyncns_query_t* sd_asyncns_getnameinfo(sd_asyncns_t *asyncns, const struct sockaddr *sa, socklen_t salen, int flags, int gethost, int getserv) { > nameinfo_request_t data[BUFSIZE/sizeof(nameinfo_request_t) + 1] = {}; > nameinfo_request_t *req = data; > - asyncns_query_t *q; > + sd_asyncns_query_t *q; > > assert(asyncns); > assert(sa); > @@ -924,12 +924,12 @@ asyncns_query_t* asyncns_getnameinfo(asyncns_t *asyncns, const struct sockaddr * > > fail: > if (q) > - asyncns_cancel(asyncns, q); > + sd_asyncns_cancel(asyncns, q); > > return NULL; > } > > -int asyncns_getnameinfo_done(asyncns_t *asyncns, asyncns_query_t* q, char *ret_host, size_t hostlen, char *ret_serv, size_t servlen) { > +int sd_asyncns_getnameinfo_done(sd_asyncns_t *asyncns, sd_asyncns_query_t* q, char *ret_host, size_t hostlen, char *ret_serv, size_t servlen) { > int ret; > assert(asyncns); > assert(q); > @@ -964,15 +964,15 @@ int asyncns_getnameinfo_done(asyncns_t *asyncns, asyncns_query_t* q, char *ret_h > if (ret != 0) > h_errno = q->_h_errno; > > - asyncns_cancel(asyncns, q); > + sd_asyncns_cancel(asyncns, q); > > return ret; > } > > -static asyncns_query_t * asyncns_res(asyncns_t *asyncns, query_type_t qtype, const char *dname, int class, int type) { > +static sd_asyncns_query_t * asyncns_res(sd_asyncns_t *asyncns, query_type_t qtype, const char *dname, int class, int type) { > res_request_t data[BUFSIZE/sizeof(res_request_t) + 1]; > res_request_t *req = data; > - asyncns_query_t *q; > + sd_asyncns_query_t *q; > > assert(asyncns); > assert(dname); > @@ -1009,20 +1009,20 @@ static asyncns_query_t * asyncns_res(asyncns_t *asyncns, query_type_t qtype, con > > fail: > if (q) > - asyncns_cancel(asyncns, q); > + sd_asyncns_cancel(asyncns, q); > > return NULL; > } > > -asyncns_query_t* asyncns_res_query(asyncns_t *asyncns, const char *dname, int class, int type) { > +sd_asyncns_query_t* sd_asyncns_res_query(sd_asyncns_t *asyncns, const char *dname, int class, int type) { > return asyncns_res(asyncns, REQUEST_RES_QUERY, dname, class, type); > } > > -asyncns_query_t* asyncns_res_search(asyncns_t *asyncns, const char *dname, int class, int type) { > +sd_asyncns_query_t* asyncns_res_search(sd_asyncns_t *asyncns, const char *dname, int class, int type) { > return asyncns_res(asyncns, REQUEST_RES_SEARCH, dname, class, type); > } > > -int asyncns_res_done(asyncns_t *asyncns, asyncns_query_t* q, unsigned char **answer) { > +int sd_asyncns_res_done(sd_asyncns_t *asyncns, sd_asyncns_query_t* q, unsigned char **answer) { > int ret; > assert(asyncns); > assert(q); > @@ -1050,22 +1050,22 @@ int asyncns_res_done(asyncns_t *asyncns, asyncns_query_t* q, unsigned char **ans > h_errno = q->_h_errno; > } > > - asyncns_cancel(asyncns, q); > + sd_asyncns_cancel(asyncns, q); > > return ret < 0 ? -errno : ret; > } > > -asyncns_query_t* asyncns_getnext(asyncns_t *asyncns) { > +sd_asyncns_query_t* asyncns_getnext(sd_asyncns_t *asyncns) { > assert(asyncns); > return asyncns->done_head; > } > > -int asyncns_getnqueries(asyncns_t *asyncns) { > +int asyncns_getnqueries(sd_asyncns_t *asyncns) { > assert(asyncns); > return asyncns->n_queries; > } > > -void asyncns_cancel(asyncns_t *asyncns, asyncns_query_t* q) { > +void sd_asyncns_cancel(sd_asyncns_t *asyncns, sd_asyncns_query_t* q) { > int i; > int saved_errno = errno; > > @@ -1091,7 +1091,7 @@ void asyncns_cancel(asyncns_t *asyncns, asyncns_query_t* q) { > assert(asyncns->queries[i] == q); > asyncns->queries[i] = NULL; > > - asyncns_freeaddrinfo(q->addrinfo); > + sd_asyncns_freeaddrinfo(q->addrinfo); > free(q->host); > free(q->serv); > > @@ -1101,7 +1101,7 @@ void asyncns_cancel(asyncns_t *asyncns, asyncns_query_t* q) { > errno = saved_errno; > } > > -void asyncns_freeaddrinfo(struct addrinfo *ai) { > +void sd_asyncns_freeaddrinfo(struct addrinfo *ai) { > int saved_errno = errno; > > while (ai) { > @@ -1117,7 +1117,7 @@ void asyncns_freeaddrinfo(struct addrinfo *ai) { > errno = saved_errno; > } > > -void asyncns_freeanswer(unsigned char *answer) { > +void sd_asyncns_freeanswer(unsigned char *answer) { > int saved_errno = errno; > > if (!answer) > @@ -1133,7 +1133,7 @@ void asyncns_freeanswer(unsigned char *answer) { > errno = saved_errno; > } > > -int asyncns_isdone(asyncns_t *asyncns, asyncns_query_t*q) { > +int sd_asyncns_isdone(sd_asyncns_t *asyncns, sd_asyncns_query_t*q) { > assert(asyncns); > assert(q); > assert(q->asyncns == asyncns); > @@ -1141,7 +1141,7 @@ int asyncns_isdone(asyncns_t *asyncns, asyncns_query_t*q) { > return q->done; > } > > -void asyncns_setuserdata(asyncns_t *asyncns, asyncns_query_t *q, void *userdata) { > +void asyncns_setuserdata(sd_asyncns_t *asyncns, sd_asyncns_query_t *q, void *userdata) { > assert(q); > assert(asyncns); > assert(q->asyncns = asyncns); > @@ -1149,7 +1149,7 @@ void asyncns_setuserdata(asyncns_t *asyncns, asyncns_query_t *q, void *userdata) > q->userdata = userdata; > } > > -void* asyncns_getuserdata(asyncns_t *asyncns, asyncns_query_t *q) { > +void *asyncns_getuserdata(sd_asyncns_t *asyncns, sd_asyncns_query_t *q) { > assert(q); > assert(asyncns); > assert(q->asyncns = asyncns); > diff --git a/src/libsystemd-bus/test-dns.c b/src/libsystemd-bus/test-dns.c > index b4f064f..78aa557 100644 > --- a/src/libsystemd-bus/test-dns.c > +++ b/src/libsystemd-bus/test-dns.c > @@ -37,17 +37,17 @@ > > int main(int argc, char *argv[]) { > int r = 1, ret; > - _cleanup_asyncns_free_ asyncns_t *asyncns = NULL; > + _cleanup_asyncns_free_ sd_asyncns_t *asyncns = NULL; > _cleanup_asyncns_addrinfo_free_ struct addrinfo *ai = NULL; > _cleanup_asyncns_answer_free_ unsigned char *srv = NULL; > - asyncns_query_t *q1, *q2, *q3; > + sd_asyncns_query_t *q1, *q2, *q3; > struct addrinfo hints = {}; > struct sockaddr_in sa = {}; > char host[NI_MAXHOST] = "", serv[NI_MAXSERV] = ""; > > signal(SIGCHLD, SIG_IGN); > > - asyncns = asyncns_new(2); > + asyncns = sd_asyncns_new(2); > if (!asyncns) > log_oom(); > > @@ -55,7 +55,7 @@ int main(int argc, char *argv[]) { > hints.ai_family = PF_UNSPEC; > hints.ai_socktype = SOCK_STREAM; > > - q1 = asyncns_getaddrinfo(asyncns, argc >= 2 ? argv[1] : "<a href="http://www.heise.de" target="_blank">www.heise.de</a>", NULL, &hints); > + q1 = sd_asyncns_getaddrinfo(asyncns, argc >= 2 ? argv[1] : "<a href="http://www.heise.de" target="_blank">www.heise.de</a>", NULL, &hints); > if (!q1) > fprintf(stderr, "asyncns_getaddrinfo(): %s\n", strerror(errno)); > > @@ -64,25 +64,25 @@ int main(int argc, char *argv[]) { > sa.sin_addr.s_addr = inet_addr(argc >= 3 ? argv[2] : "193.99.144.71"); > sa.sin_port = htons(80); > > - q2 = asyncns_getnameinfo(asyncns, (struct sockaddr*) &sa, sizeof(sa), 0, 1, 1); > + q2 = sd_asyncns_getnameinfo(asyncns, (struct sockaddr*) &sa, sizeof(sa), 0, 1, 1); > if (!q2) > fprintf(stderr, "asyncns_getnameinfo(): %s\n", strerror(errno)); > > /* Make a res_query() call */ > - q3 = asyncns_res_query(asyncns, "_xmpp-client._<a href="http://tcp.gmail.com" target="_blank">tcp.gmail.com</a>", C_IN, T_SRV); > + q3 = sd_asyncns_res_query(asyncns, "_xmpp-client._<a href="http://tcp.gmail.com" target="_blank">tcp.gmail.com</a>", C_IN, T_SRV); > if (!q3) > fprintf(stderr, "asyncns_res_query(): %s\n", strerror(errno)); > > /* Wait until the three queries are completed */ > - while (!asyncns_isdone(asyncns, q1) || > - !asyncns_isdone(asyncns, q2) || > - !asyncns_isdone(asyncns, q3)) { > - if (asyncns_wait(asyncns, 1) < 0) > + while (!sd_asyncns_isdone(asyncns, q1) || > + !sd_asyncns_isdone(asyncns, q2) || > + !sd_asyncns_isdone(asyncns, q3)) { > + if (sd_asyncns_wait(asyncns, 1) < 0) > fprintf(stderr, "asyncns_wait(): %s\n", strerror(errno)); > } > > /* Interpret the result of the name -> addr query */ > - ret = asyncns_getaddrinfo_done(asyncns, q1, &ai); > + ret = sd_asyncns_getaddrinfo_done(asyncns, q1, &ai); > if (ret) > fprintf(stderr, "error: %s %i\n", gai_strerror(ret), ret); > else { > @@ -102,14 +102,14 @@ int main(int argc, char *argv[]) { > } > > /* Interpret the result of the addr -> name query */ > - ret = asyncns_getnameinfo_done(asyncns, q2, host, sizeof(host), serv, sizeof(serv)); > + ret = sd_asyncns_getnameinfo_done(asyncns, q2, host, sizeof(host), serv, sizeof(serv)); > if (ret) > fprintf(stderr, "error: %s %i\n", gai_strerror(ret), ret); > else > printf("%s -- %s\n", host, serv); > > /* Interpret the result of the SRV lookup */ > - ret = asyncns_res_done(asyncns, q3, &srv); > + ret = sd_asyncns_res_done(asyncns, q3, &srv); > if (ret < 0) { > fprintf(stderr, "error: %s %i\n", strerror(errno), ret); > } else if (ret == 0) { > diff --git a/src/systemd/sd-dns.h b/src/systemd/sd-dns.h > index 38972db..4b382ec 100644 > --- a/src/systemd/sd-dns.h > +++ b/src/systemd/sd-dns.h > @@ -33,7 +33,7 @@ _SD_BEGIN_DECLARATIONS; > * > * \section moo Method of operation > * > - * To use libasyncns allocate an asyncns_t object with > + * To use libasyncns allocate an sd_asyncns_t object with > * asyncns_new(). This will spawn a number of worker threads (or processes, depending on what is available) which > * are subsequently used to process the queries the controlling > * program issues via asyncns_getaddrinfo() and > @@ -45,36 +45,36 @@ _SD_BEGIN_DECLARATIONS; > */ > > /** An opaque libasyncns session structure */ > -typedef struct asyncns asyncns_t; > +typedef struct sd_asyncns sd_asyncns_t; > > /** An opaque libasyncns query structure */ > -typedef struct asyncns_query asyncns_query_t; > +typedef struct sd_asyncns_query sd_asyncns_query_t; > > /** Allocate a new libasyncns session with n_proc worker processes/threads */ > -asyncns_t* asyncns_new(unsigned n_proc); > +sd_asyncns_t* sd_asyncns_new(unsigned n_proc); > > /** Free a libasyncns session. This destroys all attached > - * asyncns_query_t objects automatically */ > -void asyncns_free(asyncns_t *asyncns); > + * sd_asyncns_query_t objects automatically */ > +void sd_asyncns_free(sd_asyncns_t *asyncns); > > /** Return the UNIX file descriptor to select() for readability > * on. Use this function to integrate libasyncns with your custom main > * loop. */ > -int asyncns_fd(asyncns_t *asyncns); > +int sd_asyncns_fd(sd_asyncns_t *asyncns); > > /** Process pending responses. After this function is called you can > * get the next completed query object(s) using asyncns_getnext(). If > * block is non-zero wait until at least one response has been > * processed. If block is zero, process all pending responses and > * return. */ > -int asyncns_wait(asyncns_t *asyncns, int block); > +int sd_asyncns_wait(sd_asyncns_t *asyncns, int block); > > /** Issue a name to address query on the specified session. The > * arguments are compatible with the ones of libc's > * getaddrinfo(3). The function returns a new query object. When the > * query is completed you may retrieve the results using > * asyncns_getaddrinfo_done().*/ > -asyncns_query_t* asyncns_getaddrinfo(asyncns_t *asyncns, const char *node, const char *service, const struct addrinfo *hints); > +sd_asyncns_query_t* sd_asyncns_getaddrinfo(sd_asyncns_t *asyncns, const char *node, const char *service, const struct addrinfo *hints); > > /** Retrieve the results of a preceding asyncns_getaddrinfo() > * call. Returns a addrinfo structure and a return value compatible > @@ -83,7 +83,7 @@ asyncns_query_t* asyncns_getaddrinfo(asyncns_t *asyncns, const char *node, const > * returned addrinfo structure with asyncns_freeaddrinfo() and not > * libc's freeaddrinfo(3)! If the query is not completed yet EAI_AGAIN > * is returned.*/ > -int asyncns_getaddrinfo_done(asyncns_t *asyncns, asyncns_query_t* q, struct addrinfo **ret_res); > +int sd_asyncns_getaddrinfo_done(sd_asyncns_t *asyncns, sd_asyncns_query_t* q, struct addrinfo **ret_res); > > /** Issue an address to name query on the specified session. The > * arguments are compatible with the ones of libc's > @@ -91,26 +91,26 @@ int asyncns_getaddrinfo_done(asyncns_t *asyncns, asyncns_query_t* q, struct addr > * query is completed you may retrieve the results using > * asyncns_getnameinfo_done(). Set gethost (resp. getserv) to non-zero > * if you want to query the hostname (resp. the service name). */ > -asyncns_query_t* asyncns_getnameinfo(asyncns_t *asyncns, const struct sockaddr *sa, socklen_t salen, int flags, int gethost, int getserv); > +sd_asyncns_query_t* sd_asyncns_getnameinfo(sd_asyncns_t *asyncns, const struct sockaddr *sa, socklen_t salen, int flags, int gethost, int getserv); > > /** Retrieve the results of a preceding asyncns_getnameinfo() > * call. Returns the hostname and the service name in ret_host and > * ret_serv. The query object q is destroyed by this call and may not > * be used any further. If the query is not completed yet EAI_AGAIN is > * returned. */ > -int asyncns_getnameinfo_done(asyncns_t *asyncns, asyncns_query_t* q, char *ret_host, size_t hostlen, char *ret_serv, size_t servlen); > +int sd_asyncns_getnameinfo_done(sd_asyncns_t *asyncns, sd_asyncns_query_t* q, char *ret_host, size_t hostlen, char *ret_serv, size_t servlen); > > /** Issue a resolver query on the specified session. The arguments are > * compatible with the ones of libc's res_query(3). The function returns a new > * query object. When the query is completed you may retrieve the results using > * asyncns_res_done(). */ > -asyncns_query_t* asyncns_res_query(asyncns_t *asyncns, const char *dname, int class, int type); > +sd_asyncns_query_t* sd_asyncns_res_query(sd_asyncns_t *asyncns, const char *dname, int class, int type); > > /** Issue an resolver query on the specified session. The arguments are > * compatible with the ones of libc's res_search(3). The function returns a new > * query object. When the query is completed you may retrieve the results using > * asyncns_res_done(). */ > -asyncns_query_t* asyncns_res_search(asyncns_t *asyncns, const char *dname, int class, int type); > +sd_asyncns_query_t* sd_asyncns_res_search(sd_asyncns_t *asyncns, const char *dname, int class, int type); > > /** Retrieve the results of a preceding asyncns_res_query() or > * asyncns_res_search call. The query object q is destroyed by this > @@ -119,39 +119,39 @@ asyncns_query_t* asyncns_res_search(asyncns_t *asyncns, const char *dname, int c > * -EAGAIN is returned, on failure -errno is returned, otherwise the > * length of answer is returned. Make sure to free the answer is a > * call to asyncns_freeanswer(). */ > -int asyncns_res_done(asyncns_t *asyncns, asyncns_query_t* q, unsigned char **answer); > +int sd_asyncns_res_done(sd_asyncns_t *asyncns, sd_asyncns_query_t* q, unsigned char **answer); > > /** Return the next completed query object. If no query has been > * completed yet, return NULL. Please note that you need to run > * asyncns_wait() before this function will return sensible data. */ > -asyncns_query_t* asyncns_getnext(asyncns_t *asyncns); > +sd_asyncns_query_t* sd_asyncns_getnext(sd_asyncns_t *asyncns); > > /** Return the number of query objects (completed or not) attached to > * this session */ > -int asyncns_getnqueries(asyncns_t *asyncns); > +int sd_asyncns_getnqueries(sd_asyncns_t *asyncns); > > /** Cancel a currently running query. q is is destroyed by this call > * and may not be used any futher. */ > -void asyncns_cancel(asyncns_t *asyncns, asyncns_query_t* q); > +void sd_asyncns_cancel(sd_asyncns_t *asyncns, sd_asyncns_query_t* q); > > /** Free the addrinfo structure as returned by > * asyncns_getaddrinfo_done(). Make sure to use this functions instead > * of the libc's freeaddrinfo()! */ > -void asyncns_freeaddrinfo(struct addrinfo *ai); > +void sd_asyncns_freeaddrinfo(struct addrinfo *ai); > > /** Free the answer data as returned by asyncns_res_done().*/ > -void asyncns_freeanswer(unsigned char *answer); > +void sd_asyncns_freeanswer(unsigned char *answer); > > /** Returns non-zero when the query operation specified by q has been completed */ > -int asyncns_isdone(asyncns_t *asyncns, asyncns_query_t*q); > +int sd_asyncns_isdone(sd_asyncns_t *asyncns, sd_asyncns_query_t*q); > > /** Assign some opaque userdata with a query object */ > -void asyncns_setuserdata(asyncns_t *asyncns, asyncns_query_t *q, void *userdata); > +void sd_asyncns_setuserdata(sd_asyncns_t *asyncns, sd_asyncns_query_t *q, void *userdata); > > /** Return userdata assigned to a query object. Use > * asyncns_setuserdata() to set this data. If no data has been set > * prior to this call it returns NULL. */ > -void* asyncns_getuserdata(asyncns_t *asyncns, asyncns_query_t *q); > +void* sd_asyncns_getuserdata(sd_asyncns_t *asyncns, sd_asyncns_query_t *q); > > _SD_END_DECLARATIONS; > > -- > 1.8.5.2 > </div></div>> _______________________________________________ > systemd-devel mailing list > <a href="mailto:systemd-devel@lists.freedesktop.org">systemd-devel@lists.freedesktop.org</a> > <a href="http://lists.freedesktop.org/mailman/listinfo/systemd-devel" target="_blank">http://lists.freedesktop.org/mailman/listinfo/systemd-devel</a> Hm, I guess we should be renaming all of this to "sd_dns*" and not "sd_asyncns*", no? -t </blockquote></div> </div>