diff options
| -rw-r--r-- | meta/recipes-extended/libtirpc/libtirpc/0001-Add-missing-rwlock_unlocks-in-xprt_register.patch | 62 | ||||
| -rw-r--r-- | meta/recipes-extended/libtirpc/libtirpc/Use-netbsd-queue.h.patch | 1579 | ||||
| -rw-r--r-- | meta/recipes-extended/libtirpc/libtirpc/remove-des-functionality.patch | 144 | ||||
| -rw-r--r-- | meta/recipes-extended/libtirpc/libtirpc/remove-des-uclibc.patch | 38 | ||||
| -rw-r--r-- | meta/recipes-extended/libtirpc/libtirpc_1.0.1.bb (renamed from meta/recipes-extended/libtirpc/libtirpc_0.2.5.bb) | 11 |
5 files changed, 1793 insertions, 41 deletions
diff --git a/meta/recipes-extended/libtirpc/libtirpc/0001-Add-missing-rwlock_unlocks-in-xprt_register.patch b/meta/recipes-extended/libtirpc/libtirpc/0001-Add-missing-rwlock_unlocks-in-xprt_register.patch new file mode 100644 index 0000000000..50613ba312 --- /dev/null +++ b/meta/recipes-extended/libtirpc/libtirpc/0001-Add-missing-rwlock_unlocks-in-xprt_register.patch @@ -0,0 +1,62 @@ +Subject: [PATCH] Add missing rwlock_unlocks in xprt_register + +It looks like in b2c9430f46c4ac848957fb8adaac176a3f6ac03f when svc_run +switched to poll, an early return was added, but the rwlock was not +unlocked. + +I observed that rpcbind built against libtirpc-1.0.1 would handle only +one request before hanging, and tracked it down to a missing +rwlock_unlock here. + +Fixes: b2c9430f46c4 ('Use poll() instead of select() in svc_run()') + +Upstream-Status: Backport + +Signed-off-by: Michael Forney <mforney@mforney.org> +Signed-off-by: Steve Dickson <steved@redhat.com> +Signed-off-by: Maxin B. John <maxin.john@intel.com> +--- + src/svc.c | 7 ++++--- + 1 file changed, 4 insertions(+), 3 deletions(-) + +diff --git a/src/svc.c b/src/svc.c +index 9c41445..b59467b 100644 +--- a/src/svc.c ++++ b/src/svc.c +@@ -99,7 +99,7 @@ xprt_register (xprt) + { + __svc_xports = (SVCXPRT **) calloc (_rpc_dtablesize(), sizeof (SVCXPRT *)); + if (__svc_xports == NULL) +- return; ++ goto unlock; + } + if (sock < _rpc_dtablesize()) + { +@@ -120,14 +120,14 @@ xprt_register (xprt) + svc_pollfd[i].fd = sock; + svc_pollfd[i].events = (POLLIN | POLLPRI | + POLLRDNORM | POLLRDBAND); +- return; ++ goto unlock; + } + + new_svc_pollfd = (struct pollfd *) realloc (svc_pollfd, + sizeof (struct pollfd) + * (svc_max_pollfd + 1)); + if (new_svc_pollfd == NULL) /* Out of memory */ +- return; ++ goto unlock; + svc_pollfd = new_svc_pollfd; + ++svc_max_pollfd; + +@@ -135,6 +135,7 @@ xprt_register (xprt) + svc_pollfd[svc_max_pollfd - 1].events = (POLLIN | POLLPRI | + POLLRDNORM | POLLRDBAND); + } ++unlock: + rwlock_unlock (&svc_fd_lock); + } + +-- +2.5.3 + diff --git a/meta/recipes-extended/libtirpc/libtirpc/Use-netbsd-queue.h.patch b/meta/recipes-extended/libtirpc/libtirpc/Use-netbsd-queue.h.patch new file mode 100644 index 0000000000..21c6c53a85 --- /dev/null +++ b/meta/recipes-extended/libtirpc/libtirpc/Use-netbsd-queue.h.patch @@ -0,0 +1,1579 @@ +musl does not provide sys/queue.h implementation. Borrow queue.h from +the NetBSD project +http://cvsweb.netbsd.org/bsdweb.cgi/src/sys/sys/queue.h?rev=1.68 + +Upstream-Status: Inappropriate [musl specific] + +Signed-off-by: Jörg Krause <joerg.krause@embedded.rocks> +Signed-off-by: Maxin B. John <maxin.john@intel.com> +--- +diff -Naur libtirpc-1.0.1-orig/src/clnt_bcast.c libtirpc-1.0.1/src/clnt_bcast.c +--- libtirpc-1.0.1-orig/src/clnt_bcast.c 2015-10-30 17:15:14.000000000 +0200 ++++ libtirpc-1.0.1/src/clnt_bcast.c 2015-12-21 17:03:52.066008311 +0200 +@@ -40,7 +40,6 @@ + */ + #include <sys/socket.h> + #include <sys/types.h> +-#include <sys/queue.h> + + #include <net/if.h> + #include <netinet/in.h> +@@ -62,6 +61,7 @@ + #include <err.h> + #include <string.h> + ++#include "queue.h" + #include "rpc_com.h" + #include "debug.h" + +diff -Naur libtirpc-1.0.1-orig/src/clnt_bcast.c.orig libtirpc-1.0.1/src/clnt_bcast.c.orig +--- libtirpc-1.0.1-orig/src/clnt_bcast.c.orig 1970-01-01 02:00:00.000000000 +0200 ++++ libtirpc-1.0.1/src/clnt_bcast.c.orig 2015-10-30 17:15:14.000000000 +0200 +@@ -0,0 +1,697 @@ ++/* ++ * Copyright (c) 2009, Sun Microsystems, Inc. ++ * All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions are met: ++ * - Redistributions of source code must retain the above copyright notice, ++ * this list of conditions and the following disclaimer. ++ * - Redistributions in binary form must reproduce the above copyright notice, ++ * this list of conditions and the following disclaimer in the documentation ++ * and/or other materials provided with the distribution. ++ * - Neither the name of Sun Microsystems, Inc. nor the names of its ++ * contributors may be used to endorse or promote products derived ++ * from this software without specific prior written permission. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" ++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE ++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR ++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF ++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS ++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN ++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ++ * POSSIBILITY OF SUCH DAMAGE. ++ */ ++/* ++ * Copyright (c) 1986-1991 by Sun Microsystems Inc. ++ */ ++ ++/* ++ * clnt_bcast.c ++ * Client interface to broadcast service. ++ * ++ * Copyright (C) 1988, Sun Microsystems, Inc. ++ * ++ * The following is kludged-up support for simple rpc broadcasts. ++ * Someday a large, complicated system will replace these routines. ++ */ ++#include <sys/socket.h> ++#include <sys/types.h> ++#include <sys/queue.h> ++ ++#include <net/if.h> ++#include <netinet/in.h> ++#include <ifaddrs.h> ++#include <poll.h> ++#include <rpc/rpc.h> ++#ifdef PORTMAP ++#include <rpc/pmap_prot.h> ++#include <rpc/pmap_clnt.h> ++#include <rpc/pmap_rmt.h> ++#endif /* PORTMAP */ ++#include <rpc/nettype.h> ++#include <arpa/inet.h> ++#include <stdio.h> ++#include <errno.h> ++#include <stdlib.h> ++#include <unistd.h> ++#include <netdb.h> ++#include <err.h> ++#include <string.h> ++ ++#include "rpc_com.h" ++#include "debug.h" ++ ++#define MAXBCAST 20 /* Max no of broadcasting transports */ ++#define INITTIME 4000 /* Time to wait initially */ ++#define WAITTIME 8000 /* Maximum time to wait */ ++ ++# define POLLRDNORM 0x040 /* Normal data may be read. */ ++# define POLLRDBAND 0x080 /* Priority data may be read. */ ++ ++ ++ ++/* ++ * If nettype is NULL, it broadcasts on all the available ++ * datagram_n transports. May potentially lead to broadacst storms ++ * and hence should be used with caution, care and courage. ++ * ++ * The current parameter xdr packet size is limited by the max tsdu ++ * size of the transport. If the max tsdu size of any transport is ++ * smaller than the parameter xdr packet, then broadcast is not ++ * sent on that transport. ++ * ++ * Also, the packet size should be less the packet size of ++ * the data link layer (for ethernet it is 1400 bytes). There is ++ * no easy way to find out the max size of the data link layer and ++ * we are assuming that the args would be smaller than that. ++ * ++ * The result size has to be smaller than the transport tsdu size. ++ * ++ * If PORTMAP has been defined, we send two packets for UDP, one for ++ * rpcbind and one for portmap. For those machines which support ++ * both rpcbind and portmap, it will cause them to reply twice, and ++ * also here it will get two responses ... inefficient and clumsy. ++ */ ++ ++#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) ++ ++#define TAILQ_FIRST(head) ((head)->tqh_first) ++ ++ ++struct broadif { ++ int index; ++ struct sockaddr_storage broadaddr; ++ TAILQ_ENTRY(broadif) link; ++}; ++ ++typedef TAILQ_HEAD(, broadif) broadlist_t; ++ ++int __rpc_getbroadifs(int, int, int, broadlist_t *); ++void __rpc_freebroadifs(broadlist_t *); ++int __rpc_broadenable(int, int, struct broadif *); ++ ++int __rpc_lowvers = 0; ++ ++int ++__rpc_getbroadifs(int af, int proto, int socktype, broadlist_t *list) ++{ ++ int count = 0; ++ struct broadif *bip; ++ struct ifaddrs *ifap, *ifp; ++#ifdef INET6 ++ struct sockaddr_in6 *sin6; ++#endif ++ struct sockaddr_in *sin; ++ struct addrinfo hints, *res; ++ ++ if (getifaddrs(&ifp) < 0) ++ return 0; ++ ++ memset(&hints, 0, sizeof hints); ++ ++ hints.ai_family = af; ++ hints.ai_protocol = proto; ++ hints.ai_socktype = socktype; ++ ++ if (getaddrinfo(NULL, "sunrpc", &hints, &res) != 0) ++ return 0; ++ ++ for (ifap = ifp; ifap != NULL; ifap = ifap->ifa_next) { ++ if (ifap->ifa_addr == NULL || /* happens for eg tuntap devices */ ++ ifap->ifa_addr->sa_family != af || ++ !(ifap->ifa_flags & IFF_UP)) ++ continue; ++ bip = (struct broadif *)malloc(sizeof *bip); ++ if (bip == NULL) ++ break; ++ bip->index = if_nametoindex(ifap->ifa_name); ++ if ( ++#ifdef INET6 ++ af != AF_INET6 && ++#endif ++ (ifap->ifa_flags & IFF_BROADCAST) && ++ ifap->ifa_broadaddr) { ++ /* memcpy(&bip->broadaddr, ifap->ifa_broadaddr, ++ (size_t)ifap->ifa_broadaddr->sa_len);*/ ++ memcpy(&bip->broadaddr, ifap->ifa_broadaddr, ++ sizeof(bip->broadaddr)); ++ sin = (struct sockaddr_in *)(void *)&bip->broadaddr; ++ sin->sin_port = ++ ((struct sockaddr_in *) ++ (void *)res->ai_addr)->sin_port; ++ } else ++#ifdef INET6 ++ if (af == AF_INET6 && (ifap->ifa_flags & IFF_MULTICAST)) { ++ sin6 = (struct sockaddr_in6 *)(void *)&bip->broadaddr; ++ inet_pton(af, RPCB_MULTICAST_ADDR, &sin6->sin6_addr); ++ sin6->sin6_family = af; ++ sin6->sin6_port = ++ ((struct sockaddr_in6 *) ++ (void *)res->ai_addr)->sin6_port; ++ sin6->sin6_scope_id = bip->index; ++ } else ++#endif ++ { ++ free(bip); ++ continue; ++ } ++ TAILQ_INSERT_TAIL(list, bip, link); ++ count++; ++ } ++ freeifaddrs(ifp); ++ freeaddrinfo(res); ++ ++ return count; ++} ++ ++void ++__rpc_freebroadifs(broadlist_t *list) ++{ ++ struct broadif *bip, *next; ++ ++ bip = TAILQ_FIRST(list); ++ ++ while (bip != NULL) { ++ next = TAILQ_NEXT(bip, link); ++ free(bip); ++ bip = next; ++ } ++} ++ ++int ++/*ARGSUSED*/ ++__rpc_broadenable(int af, int s, struct broadif *bip) ++{ ++ int o = 1; ++ ++#if 0 ++ if (af == AF_INET6) { ++ fprintf(stderr, "set v6 multicast if to %d\n", bip->index); ++ if (setsockopt(s, IPPROTO_IPV6, IPV6_MULTICAST_IF, &bip->index, ++ sizeof bip->index) < 0) ++ return -1; ++ } else ++#endif ++ if (setsockopt(s, SOL_SOCKET, SO_BROADCAST, &o, sizeof o) < 0) ++ return -1; ++ ++ return 0; ++} ++ ++/* ++ * Some rpcbind implementations use an IPv6 socket to serve both ++ * IPv4 and IPv6 messages, but neglect to check for the caller's ++ * address family when sending broadcast replies. These rpcbind ++ * implementations return an IPv6 address in reply to an IPv4 ++ * broadcast. We can either ignore them, or try to patch them up. ++ */ ++static struct netbuf * ++__ipv6v4_fixup(struct sockaddr_storage *ss, const char *uaddr) ++{ ++ struct sockaddr_in sin; ++ struct netbuf *np; ++ ++ /* ss is the remote rpcbind server's address */ ++ if (ss->ss_family != AF_INET) ++ return NULL; ++ memcpy(&sin, ss, sizeof(sin)); ++ ++ np = __rpc_uaddr2taddr_af(AF_INET6, uaddr); ++ if (np == NULL) ++ return NULL; ++ ++ /* Overwrite the port with that of the service we ++ * wanted to talk to. */ ++ sin.sin_port = ((struct sockaddr_in6 *) np)->sin6_port; ++ ++ /* We know netbuf holds a sockaddr_in6, so it can easily ++ * hold a sockaddr_in as well. */ ++ memcpy(np->buf, &sin, sizeof(sin)); ++ np->len = sizeof(sin); ++ ++ return np; ++} ++ ++enum clnt_stat ++rpc_broadcast_exp(prog, vers, proc, xargs, argsp, xresults, resultsp, ++ eachresult, inittime, waittime, nettype) ++ rpcprog_t prog; /* program number */ ++ rpcvers_t vers; /* version number */ ++ rpcproc_t proc; /* procedure number */ ++ xdrproc_t xargs; /* xdr routine for args */ ++ caddr_t argsp; /* pointer to args */ ++ xdrproc_t xresults; /* xdr routine for results */ ++ caddr_t resultsp; /* pointer to results */ ++ resultproc_t eachresult; /* call with each result obtained */ ++ int inittime; /* how long to wait initially */ ++ int waittime; /* maximum time to wait */ ++ const char *nettype; /* transport type */ ++{ ++ enum clnt_stat stat = RPC_SUCCESS; /* Return status */ ++ XDR xdr_stream; /* XDR stream */ ++ XDR *xdrs = &xdr_stream; ++ struct rpc_msg msg; /* RPC message */ ++ struct timeval t; ++ char *outbuf = NULL; /* Broadcast msg buffer */ ++ char *inbuf = NULL; /* Reply buf */ ++ int inlen; ++ u_int maxbufsize = 0; ++ AUTH *sys_auth = authunix_create_default(); ++ int i; ++ void *handle; ++ char uaddress[1024]; /* A self imposed limit */ ++ char *uaddrp = uaddress; ++ int pmap_reply_flag; /* reply recvd from PORTMAP */ ++ /* An array of all the suitable broadcast transports */ ++ struct { ++ int fd; /* File descriptor */ ++ int af; ++ int proto; ++ struct netconfig *nconf; /* Netconfig structure */ ++ u_int asize; /* Size of the addr buf */ ++ u_int dsize; /* Size of the data buf */ ++ struct sockaddr_storage raddr; /* Remote address */ ++ broadlist_t nal; ++ } fdlist[MAXBCAST]; ++ struct pollfd pfd[MAXBCAST]; ++ size_t fdlistno = 0; ++ struct r_rpcb_rmtcallargs barg; /* Remote arguments */ ++ struct r_rpcb_rmtcallres bres; /* Remote results */ ++ size_t outlen; ++ struct netconfig *nconf; ++ int msec; ++ int pollretval; ++ int fds_found; ++ ++#ifdef PORTMAP ++ size_t outlen_pmap = 0; ++ u_long port; /* Remote port number */ ++ int pmap_flag = 0; /* UDP exists ? */ ++ char *outbuf_pmap = NULL; ++ struct rmtcallargs barg_pmap; /* Remote arguments */ ++ struct rmtcallres bres_pmap; /* Remote results */ ++ u_int udpbufsz = 0; ++#endif /* PORTMAP */ ++ ++ if (sys_auth == NULL) { ++ return (RPC_SYSTEMERROR); ++ } ++ /* ++ * initialization: create a fd, a broadcast address, and send the ++ * request on the broadcast transport. ++ * Listen on all of them and on replies, call the user supplied ++ * function. ++ */ ++ ++ if (nettype == NULL) ++ nettype = "datagram_n"; ++ if ((handle = __rpc_setconf(nettype)) == NULL) { ++ return (RPC_UNKNOWNPROTO); ++ } ++ while ((nconf = __rpc_getconf(handle)) != NULL) { ++ int fd; ++ struct __rpc_sockinfo si; ++ ++ if (nconf->nc_semantics != NC_TPI_CLTS) ++ continue; ++ if (fdlistno >= MAXBCAST) ++ break; /* No more slots available */ ++ if (!__rpc_nconf2sockinfo(nconf, &si)) ++ continue; ++ ++ TAILQ_INIT(&fdlist[fdlistno].nal); ++ if (__rpc_getbroadifs(si.si_af, si.si_proto, si.si_socktype, ++ &fdlist[fdlistno].nal) == 0) ++ continue; ++ ++ fd = socket(si.si_af, si.si_socktype, si.si_proto); ++ if (fd < 0) { ++ stat = RPC_CANTSEND; ++ continue; ++ } ++ fdlist[fdlistno].af = si.si_af; ++ fdlist[fdlistno].proto = si.si_proto; ++ fdlist[fdlistno].fd = fd; ++ fdlist[fdlistno].nconf = nconf; ++ fdlist[fdlistno].asize = __rpc_get_a_size(si.si_af); ++ pfd[fdlistno].events = POLLIN | POLLPRI | ++ POLLRDNORM | POLLRDBAND; ++ pfd[fdlistno].fd = fdlist[fdlistno].fd = fd; ++ fdlist[fdlistno].dsize = __rpc_get_t_size(si.si_af, si.si_proto, ++ 0); ++ ++ if (maxbufsize <= fdlist[fdlistno].dsize) ++ maxbufsize = fdlist[fdlistno].dsize; ++ ++#ifdef PORTMAP ++ if (si.si_af == AF_INET && si.si_proto == IPPROTO_UDP) { ++ udpbufsz = fdlist[fdlistno].dsize; ++ if ((outbuf_pmap = malloc(udpbufsz)) == NULL) { ++ close(fd); ++ stat = RPC_SYSTEMERROR; ++ goto done_broad; ++ } ++ pmap_flag = 1; ++ } ++#endif /* PORTMAP */ ++ fdlistno++; ++ } ++ ++ if (fdlistno == 0) { ++ if (stat == RPC_SUCCESS) ++ stat = RPC_UNKNOWNPROTO; ++ goto done_broad; ++ } ++ if (maxbufsize == 0) { ++ if (stat == RPC_SUCCESS) ++ stat = RPC_CANTSEND; ++ goto done_broad; ++ } ++ inbuf = malloc(maxbufsize); ++ outbuf = malloc(maxbufsize); ++ if ((inbuf == NULL) || (outbuf == NULL)) { ++ stat = RPC_SYSTEMERROR; ++ goto done_broad; ++ } ++ ++ /* Serialize all the arguments which have to be sent */ ++ (void) gettimeofday(&t, NULL); ++ msg.rm_xid = __RPC_GETXID(&t); ++ msg.rm_direction = CALL; ++ msg.rm_call.cb_rpcvers = RPC_MSG_VERSION; ++ msg.rm_call.cb_prog = RPCBPROG; ++ msg.rm_call.cb_vers = RPCBVERS; ++ msg.rm_call.cb_proc = RPCBPROC_CALLIT; ++ barg.prog = prog; ++ barg.vers = vers; ++ barg.proc = proc; ++ barg.args.args_val = argsp; ++ barg.xdr_args = xargs; ++ bres.addr = uaddrp; ++ bres.results.results_val = resultsp; ++ bres.xdr_res = xresults; ++ msg.rm_call.cb_cred = sys_auth->ah_cred; ++ msg.rm_call.cb_verf = sys_auth->ah_verf; ++ xdrmem_create(xdrs, outbuf, maxbufsize, XDR_ENCODE); ++ if ((!xdr_callmsg(xdrs, &msg)) || ++ (!xdr_rpcb_rmtcallargs(xdrs, ++ (struct rpcb_rmtcallargs *)(void *)&barg))) { ++ stat = RPC_CANTENCODEARGS; ++ goto done_broad; ++ } ++ outlen = xdr_getpos(xdrs); ++ xdr_destroy(xdrs); ++ ++#ifdef PORTMAP ++ /* Prepare the packet for version 2 PORTMAP */ ++ if (pmap_flag) { ++ msg.rm_xid++; /* One way to distinguish */ ++ msg.rm_call.cb_prog = PMAPPROG; ++ msg.rm_call.cb_vers = PMAPVERS; ++ msg.rm_call.cb_proc = PMAPPROC_CALLIT; ++ barg_pmap.prog = prog; ++ barg_pmap.vers = vers; ++ barg_pmap.proc = proc; ++ barg_pmap.args_ptr = argsp; ++ barg_pmap.xdr_args = xargs; ++ bres_pmap.port_ptr = &port; ++ bres_pmap.xdr_results = xresults; ++ bres_pmap.results_ptr = resultsp; ++ xdrmem_create(xdrs, outbuf_pmap, udpbufsz, XDR_ENCODE); ++ if ((! xdr_callmsg(xdrs, &msg)) || ++ (! xdr_rmtcall_args(xdrs, &barg_pmap))) { ++ stat = RPC_CANTENCODEARGS; ++ goto done_broad; ++ } ++ outlen_pmap = xdr_getpos(xdrs); ++ xdr_destroy(xdrs); ++ } ++#endif /* PORTMAP */ ++ ++ /* ++ * Basic loop: broadcast the packets to transports which ++ * support data packets of size such that one can encode ++ * all the arguments. ++ * Wait a while for response(s). ++ * The response timeout grows larger per iteration. ++ */ ++ for (msec = inittime; msec <= waittime; msec += msec) { ++ struct broadif *bip; ++ ++ /* Broadcast all the packets now */ ++ for (i = 0; i < fdlistno; i++) { ++ if (fdlist[i].dsize < outlen) { ++ stat = RPC_CANTSEND; ++ continue; ++ } ++ for (bip = TAILQ_FIRST(&fdlist[i].nal); bip != NULL; ++ bip = TAILQ_NEXT(bip, link)) { ++ void *addr; ++ ++ addr = &bip->broadaddr; ++ ++ __rpc_broadenable(fdlist[i].af, fdlist[i].fd, ++ bip); ++ ++ /* ++ * Only use version 3 if lowvers is not set ++ */ ++ ++ if (!__rpc_lowvers) ++ if (sendto(fdlist[i].fd, outbuf, ++ outlen, 0, (struct sockaddr*)addr, ++ (size_t)fdlist[i].asize) != ++ outlen) { ++ LIBTIRPC_DEBUG(1, ++ ("rpc_broadcast_exp: sendto failed: errno %d", errno)); ++ warnx("rpc_broadcast_exp: cannot send broadcast packet"); ++ stat = RPC_CANTSEND; ++ continue; ++ }; ++ if (!__rpc_lowvers) ++ LIBTIRPC_DEBUG(3, ("rpc_broadcast_exp: Broadcast packet sent for %s\n", ++ fdlist[i].nconf->nc_netid)); ++#ifdef PORTMAP ++ /* ++ * Send the version 2 packet also ++ * for UDP/IP ++ */ ++ if (pmap_flag && ++ fdlist[i].proto == IPPROTO_UDP) { ++ if (sendto(fdlist[i].fd, outbuf_pmap, ++ outlen_pmap, 0, addr, ++ (size_t)fdlist[i].asize) != ++ outlen_pmap) { ++ warnx("clnt_bcast: " ++ "Cannot send broadcast packet"); ++ stat = RPC_CANTSEND; ++ continue; ++ } ++ } ++ LIBTIRPC_DEBUG(3, ("rpc_broadcast_exp: PMAP Broadcast packet sent for %s\n", ++ fdlist[i].nconf->nc_netid)); ++#endif /* PORTMAP */ ++ } ++ /* End for sending all packets on this transport */ ++ } /* End for sending on all transports */ ++ ++ if (eachresult == NULL) { ++ stat = RPC_SUCCESS; ++ goto done_broad; ++ } ++ ++ /* ++ * Get all the replies from these broadcast requests ++ */ ++ recv_again: ++ ++ switch (pollretval = poll(pfd, fdlistno, msec)) { ++ case 0: /* timed out */ ++ stat = RPC_TIMEDOUT; ++ continue; ++ case -1: /* some kind of error - we ignore it */ ++ goto recv_again; ++ } /* end of poll results switch */ ++ ++ for (i = fds_found = 0; ++ i < fdlistno && fds_found < pollretval; i++) { ++ bool_t done = FALSE; ++ ++ if (pfd[i].revents == 0) ++ continue; ++ else if (pfd[i].revents & POLLNVAL) { ++ /* ++ * Something bad has happened to this descri- ++ * ptor. We can cause _poll() to ignore ++ * it simply by using a negative fd. We do that ++ * rather than compacting the pfd[] and fdlist[] ++ * arrays. ++ */ ++ pfd[i].fd = -1; ++ fds_found++; ++ continue; ++ } else ++ fds_found++; ++ LIBTIRPC_DEBUG(3, ("rpc_broadcast_exp: response for %s\n", ++ fdlist[i].nconf->nc_netid)); ++ try_again: ++ inlen = recvfrom(fdlist[i].fd, inbuf, fdlist[i].dsize, ++ 0, (struct sockaddr *)(void *)&fdlist[i].raddr, ++ &fdlist[i].asize); ++ if (inlen < 0) { ++ if (errno == EINTR) ++ goto try_again; ++ warnx("clnt_bcast: Cannot receive reply to " ++ "broadcast"); ++ stat = RPC_CANTRECV; ++ continue; ++ } ++ if (inlen < sizeof (u_int32_t)) ++ continue; /* Drop that and go ahead */ ++ /* ++ * see if reply transaction id matches sent id. ++ * If so, decode the results. If return id is xid + 1 ++ * it was a PORTMAP reply ++ */ ++ if (*((u_int32_t *)(void *)(inbuf)) == ++ *((u_int32_t *)(void *)(outbuf))) { ++ pmap_reply_flag = 0; ++ msg.acpted_rply.ar_verf = _null_auth; ++ msg.acpted_rply.ar_results.where = ++ (caddr_t)(void *)&bres; ++ msg.acpted_rply.ar_results.proc = ++ (xdrproc_t)xdr_rpcb_rmtcallres; ++#ifdef PORTMAP ++ } else if (pmap_flag && ++ *((u_int32_t *)(void *)(inbuf)) == ++ *((u_int32_t *)(void *)(outbuf_pmap))) { ++ pmap_reply_flag = 1; ++ msg.acpted_rply.ar_verf = _null_auth; ++ msg.acpted_rply.ar_results.where = ++ (caddr_t)(void *)&bres_pmap; ++ msg.acpted_rply.ar_results.proc = ++ (xdrproc_t)xdr_rmtcallres; ++#endif /* PORTMAP */ ++ } else ++ continue; ++ xdrmem_create(xdrs, inbuf, (u_int)inlen, XDR_DECODE); ++ if (xdr_replymsg(xdrs, &msg)) { ++ if ((msg.rm_reply.rp_stat == MSG_ACCEPTED) && ++ (msg.acpted_rply.ar_stat == SUCCESS)) { ++ struct netbuf *np; ++#ifdef PORTMAP ++ struct netbuf taddr; ++ struct sockaddr_in sin; ++ ++ if (pmap_flag && pmap_reply_flag) { ++ memcpy(&sin, &fdlist[i].raddr, sizeof(sin)); ++ sin.sin_port = htons((u_short)port); ++ memcpy(&fdlist[i].raddr, &sin, sizeof(sin)); ++ taddr.len = taddr.maxlen = ++ sizeof(fdlist[i].raddr); ++ taddr.buf = &fdlist[i].raddr; ++ done = (*eachresult)(resultsp, ++ &taddr, fdlist[i].nconf); ++ } else { ++#endif /* PORTMAP */ ++ LIBTIRPC_DEBUG(3, ("rpc_broadcast_exp: uaddr %s\n", uaddrp)); ++ np = uaddr2taddr( ++ fdlist[i].nconf, uaddrp); ++ /* Some misguided rpcbind implemenations ++ * seem to return an IPv6 uaddr in IPv4 ++ * responses. */ ++ if (np == NULL) ++ np = __ipv6v4_fixup( ++ &fdlist[i].raddr, ++ uaddrp); ++ if (np != NULL) { ++ done = (*eachresult)(resultsp, ++ np, fdlist[i].nconf); ++ free(np); ++ } ++#ifdef PORTMAP ++ } ++#endif /* PORTMAP */ ++ } ++ /* otherwise, we just ignore the errors ... */ ++ } ++ /* else some kind of deserialization problem ... */ ++ ++ xdrs->x_op = XDR_FREE; ++ msg.acpted_rply.ar_results.proc = (xdrproc_t) xdr_void; ++ (void) xdr_replymsg(xdrs, &msg); ++ (void) (*xresults)(xdrs, resultsp); ++ XDR_DESTROY(xdrs); ++ if (done) { ++ stat = RPC_SUCCESS; ++ goto done_broad; ++ } else { ++ goto recv_again; ++ } ++ } /* The recv for loop */ ++ } /* The giant for loop */ ++ ++done_broad: ++ if (inbuf) ++ (void) free(inbuf); ++ if (outbuf) ++ (void) free(outbuf); ++#ifdef PORTMAP ++ if (outbuf_pmap) ++ (void) free(outbuf_pmap); ++#endif /* PORTMAP */ ++ for (i = 0; i < fdlistno; i++) { ++ (void)close(fdlist[i].fd); ++ __rpc_freebroadifs(&fdlist[i].nal); ++ } ++ AUTH_DESTROY(sys_auth); ++ (void) __rpc_endconf(handle); ++ ++ return (stat); ++} ++ ++ ++enum clnt_stat ++rpc_broadcast(prog, vers, proc, xargs, argsp, xresults, resultsp, ++ eachresult, nettype) ++ rpcprog_t prog; /* program number */ ++ rpcvers_t vers; /* version number */ ++ rpcproc_t proc; /* procedure number */ ++ xdrproc_t xargs; /* xdr routine for args */ ++ caddr_t argsp; /* pointer to args */ ++ xdrproc_t xresults; /* xdr routine for results */ ++ caddr_t resultsp; /* pointer to results */ ++ resultproc_t eachresult; /* call with each result obtained */ ++ const char *nettype; /* transport type */ ++{ ++ enum clnt_stat dummy; ++ ++ dummy = rpc_broadcast_exp(prog, vers, proc, xargs, argsp, ++ xresults, resultsp, eachresult, ++ INITTIME, WAITTIME, nettype); ++ return (dummy); ++} +diff -Naur libtirpc-1.0.1-orig/tirpc/queue.h libtirpc-1.0.1/tirpc/queue.h +--- libtirpc-1.0.1-orig/tirpc/queue.h 1970-01-01 02:00:00.000000000 +0200 ++++ libtirpc-1.0.1/tirpc/queue.h 2015-12-21 17:02:44.427853905 +0200 +@@ -0,0 +1,846 @@ ++/* $NetBSD: queue.h,v 1.68 2014/11/19 08:10:01 uebayasi Exp $ */ ++ ++/* ++ * Copyright (c) 1991, 1993 ++ * The Regents of the University of California. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. Neither the name of the University nor the names of its contributors ++ * may be used to endorse or promote products derived from this software ++ * without specific prior written permission. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * @(#)queue.h 8.5 (Berkeley) 8/20/94 ++ */ ++ ++#ifndef _SYS_QUEUE_H_ ++#define _SYS_QUEUE_H_ ++ ++/* ++ * This file defines five types of data structures: singly-linked lists, ++ * lists, simple queues, tail queues, and circular queues. ++ * ++ * A singly-linked list is headed by a single forward pointer. The ++ * elements are singly linked for minimum space and pointer manipulation ++ * overhead at the expense of O(n) removal for arbitrary elements. New ++ * elements can be added to the list after an existing element or at the ++ * head of the list. Elements being removed from the head of the list ++ * should use the explicit macro for this purpose for optimum ++ * efficiency. A singly-linked list may only be traversed in the forward ++ * direction. Singly-linked lists are ideal for applications with large ++ * datasets and few or no removals or for implementing a LIFO queue. ++ * ++ * A list is headed by a single forward pointer (or an array of forward ++ * pointers for a hash table header). The elements are doubly linked ++ * so that an arbitrary element can be removed without a need to ++ * traverse the list. New elements can be added to the list before ++ * or after an existing element or at the head of the list. A list ++ * may only be traversed in the forward direction. ++ * ++ * A simple queue is headed by a pair of pointers, one the head of the ++ * list and the other to the tail of the list. The elements are singly ++ * linked to save space, so elements can only be removed from the ++ * head of the list. New elements can be added to the list after ++ * an existing element, at the head of the list, or at the end of the ++ * list. A simple queue may only be traversed in the forward direction. ++ * ++ * A tail queue is headed by a pair of pointers, one to the head of the ++ * list and the other to the tail of the list. The elements are doubly ++ * linked so that an arbitrary element can be removed without a need to ++ * traverse the list. New elements can be added to the list before or ++ * after an existing element, at the head of the list, or at the end of ++ * the list. A tail queue may be traversed in either direction. ++ * ++ * A circle queue is headed by a pair of pointers, one to the head of the ++ * list and the other to the tail of the list. The elements are doubly ++ * linked so that an arbitrary element can be removed without a need to ++ * traverse the list. New elements can be added to the list before or after ++ * an existing element, at the head of the list, or at the end of the list. ++ * A circle queue may be traversed in either direction, but has a more ++ * complex end of list detection. ++ * ++ * For details on the use of these macros, see the queue(3) manual page. ++ */ ++ ++/* ++ * Include the definition of NULL only on NetBSD because sys/null.h ++ * is not available elsewhere. This conditional makes the header ++ * portable and it can simply be dropped verbatim into any system. ++ * The caveat is that on other systems some other header ++ * must provide NULL before the macros can be used. ++ */ ++#ifdef __NetBSD__ ++#include <sys/null.h> ++#endif ++ ++#if defined(QUEUEDEBUG) ++# if defined(_KERNEL) ++# define QUEUEDEBUG_ABORT(...) panic(__VA_ARGS__) ++# else ++# include <err.h> ++# define QUEUEDEBUG_ABORT(...) err(1, __VA_ARGS__) ++# endif ++#endif ++ ++/* ++ * Singly-linked List definitions. ++ */ ++#define SLIST_HEAD(name, type) \ ++struct name { \ ++ struct type *slh_first; /* first element */ \ ++} ++ ++#define SLIST_HEAD_INITIALIZER(head) \ ++ { NULL } ++ ++#define SLIST_ENTRY(type) \ ++struct { \ ++ struct type *sle_next; /* next element */ \ ++} ++ ++/* ++ * Singly-linked List access methods. ++ */ ++#define SLIST_FIRST(head) ((head)->slh_first) ++#define SLIST_END(head) NULL ++#define SLIST_EMPTY(head) ((head)->slh_first == NULL) ++#define SLIST_NEXT(elm, field) ((elm)->field.sle_next) ++ ++#define SLIST_FOREACH(var, head, field) \ ++ for((var) = (head)->slh_first; \ ++ (var) != SLIST_END(head); \ ++ (var) = (var)->field.sle_next) ++ ++#define SLIST_FOREACH_SAFE(var, head, field, tvar) \ ++ for ((var) = SLIST_FIRST((head)); \ ++ (var) != SLIST_END(head) && \ ++ ((tvar) = SLIST_NEXT((var), field), 1); \ ++ (var) = (tvar)) ++ ++/* ++ * Singly-linked List functions. ++ */ ++#define SLIST_INIT(head) do { \ ++ (head)->slh_first = SLIST_END(head); \ ++} while (/*CONSTCOND*/0) ++ ++#define SLIST_INSERT_AFTER(slistelm, elm, field) do { \ ++ (elm)->field.sle_next = (slistelm)->field.sle_next; \ ++ (slistelm)->field.sle_next = (elm); \ ++} while (/*CONSTCOND*/0) ++ ++#define SLIST_INSERT_HEAD(head, elm, field) do { \ ++ (elm)->field.sle_next = (head)->slh_first; \ ++ (head)->slh_first = (elm); \ ++} while (/*CONSTCOND*/0) ++ ++#define SLIST_REMOVE_AFTER(slistelm, field) do { \ ++ (slistelm)->field.sle_next = \ ++ SLIST_NEXT(SLIST_NEXT((slistelm), field), field); \ ++} while (/*CONSTCOND*/0) ++ ++#define SLIST_REMOVE_HEAD(head, field) do { \ ++ (head)->slh_first = (head)->slh_first->field.sle_next; \ ++} while (/*CONSTCOND*/0) ++ ++#define SLIST_REMOVE(head, elm, type, field) do { \ ++ if ((head)->slh_first == (elm)) { \ ++ SLIST_REMOVE_HEAD((head), field); \ ++ } \ ++ else { \ ++ struct type *curelm = (head)->slh_first; \ ++ while(curelm->field.sle_next != (elm)) \ ++ curelm = curelm->field.sle_next; \ ++ curelm->field.sle_next = \ ++ curelm->field.sle_next->field.sle_next; \ ++ } \ ++} while (/*CONSTCOND*/0) ++ ++ ++/* ++ * List definitions. ++ */ ++#define LIST_HEAD(name, type) \ ++struct name { \ ++ struct type *lh_first; /* first element */ \ ++} ++ ++#define LIST_HEAD_INITIALIZER(head) \ ++ { NULL } ++ ++#define LIST_ENTRY(type) \ ++struct { \ ++ struct type *le_next; /* next element */ \ ++ struct type **le_prev; /* address of previous next element */ \ ++} ++ ++/* ++ * List access methods. ++ */ ++#define LIST_FIRST(head) ((head)->lh_first) ++#define LIST_END(head) NULL ++#define LIST_EMPTY(head) ((head)->lh_first == LIST_END(head)) ++#define LIST_NEXT(elm, field) ((elm)->field.le_next) ++ ++#define LIST_FOREACH(var, head, field) \ ++ for ((var) = ((head)->lh_first); \ ++ (var) != LIST_END(head); \ ++ (var) = ((var)->field.le_next)) ++ ++#define LIST_FOREACH_SAFE(var, head, field, tvar) \ ++ for ((var) = LIST_FIRST((head)); \ ++ (var) != LIST_END(head) && \ ++ ((tvar) = LIST_NEXT((var), field), 1); \ ++ (var) = (tvar)) ++ ++#define LIST_MOVE(head1, head2) do { \ ++ LIST_INIT((head2)); \ ++ if (!LIST_EMPTY((head1))) { \ ++ (head2)->lh_first = (head1)->lh_first; \ ++ LIST_INIT((head1)); \ ++ } \ ++} while (/*CONSTCOND*/0) ++ ++/* ++ * List functions. ++ */ ++#if defined(QUEUEDEBUG) ++#define QUEUEDEBUG_LIST_INSERT_HEAD(head, elm, field) \ ++ if ((head)->lh_first && \ ++ (head)->lh_first->field.le_prev != &(head)->lh_first) \ ++ QUEUEDEBUG_ABORT("LIST_INSERT_HEAD %p %s:%d", (head), \ ++ __FILE__, __LINE__); ++#define QUEUEDEBUG_LIST_OP(elm, field) \ ++ if ((elm)->field.le_next && \ ++ (elm)->field.le_next->field.le_prev != \ ++ &(elm)->field.le_next) \ ++ QUEUEDEBUG_ABORT("LIST_* forw %p %s:%d", (elm), \ ++ __FILE__, __LINE__); \ ++ if (*(elm)->field.le_prev != (elm)) \ ++ QUEUEDEBUG_ABORT("LIST_* back %p %s:%d", (elm), \ ++ __FILE__, __LINE__); ++#define QUEUEDEBUG_LIST_POSTREMOVE(elm, field) \ ++ (elm)->field.le_next = (void *)1L; \ ++ (elm)->field.le_prev = (void *)1L; ++#else ++#define QUEUEDEBUG_LIST_INSERT_HEAD(head, elm, field) ++#define QUEUEDEBUG_LIST_OP(elm, field) ++#define QUEUEDEBUG_LIST_POSTREMOVE(elm, field) ++#endif ++ ++#define LIST_INIT(head) do { \ ++ (head)->lh_first = LIST_END(head); \ ++} while (/*CONSTCOND*/0) ++ ++#define LIST_INSERT_AFTER(listelm, elm, field) do { \ ++ QUEUEDEBUG_LIST_OP((listelm), field) \ ++ if (((elm)->field.le_next = (listelm)->field.le_next) != \ ++ LIST_END(head)) \ ++ (listelm)->field.le_next->field.le_prev = \ ++ &(elm)->field.le_next; \ ++ (listelm)->field.le_next = (elm); \ ++ (elm)->field.le_prev = &(listelm)->field.le_next; \ ++} while (/*CONSTCOND*/0) ++ ++#define LIST_INSERT_BEFORE(listelm, elm, field) do { \ ++ QUEUEDEBUG_LIST_OP((listelm), field) \ ++ (elm)->field.le_prev = (listelm)->field.le_prev; \ ++ (elm)->field.le_next = (listelm); \ ++ *(listelm)->field.le_prev = (elm); \ ++ (listelm)->field.le_prev = &(elm)->field.le_next; \ ++} while (/*CONSTCOND*/0) ++ ++#define LIST_INSERT_HEAD(head, elm, field) do { \ ++ QUEUEDEBUG_LIST_INSERT_HEAD((head), (elm), field) \ ++ if (((elm)->field.le_next = (head)->lh_first) != LIST_END(head))\ ++ (head)->lh_first->field.le_prev = &(elm)->field.le_next;\ ++ (head)->lh_first = (elm); \ ++ (elm)->field.le_prev = &(head)->lh_first; \ ++} while (/*CONSTCOND*/0) ++ ++#define LIST_REMOVE(elm, field) do { \ ++ QUEUEDEBUG_LIST_OP((elm), field) \ ++ if ((elm)->field.le_next != NULL) \ ++ (elm)->field.le_next->field.le_prev = \ ++ (elm)->field.le_prev; \ ++ *(elm)->field.le_prev = (elm)->field.le_next; \ ++ QUEUEDEBUG_LIST_POSTREMOVE((elm), field) \ ++} while (/*CONSTCOND*/0) ++ ++#define LIST_REPLACE(elm, elm2, field) do { \ ++ if (((elm2)->field.le_next = (elm)->field.le_next) != NULL) \ ++ (elm2)->field.le_next->field.le_prev = \ ++ &(elm2)->field.le_next; \ ++ (elm2)->field.le_prev = (elm)->field.le_prev; \ ++ *(elm2)->field.le_prev = (elm2); \ ++ QUEUEDEBUG_LIST_POSTREMOVE((elm), field) \ ++} while (/*CONSTCOND*/0) ++ ++/* ++ * Simple queue definitions. ++ */ ++#define SIMPLEQ_HEAD(name, type) \ ++struct name { \ ++ struct type *sqh_first; /* first element */ \ ++ struct type **sqh_last; /* addr of last next element */ \ ++} ++ ++#define SIMPLEQ_HEAD_INITIALIZER(head) \ ++ { NULL, &(head).sqh_first } ++ ++#define SIMPLEQ_ENTRY(type) \ ++struct { \ ++ struct type *sqe_next; /* next element */ \ ++} ++ ++/* ++ * Simple queue access methods. ++ */ ++#define SIMPLEQ_FIRST(head) ((head)->sqh_first) ++#define SIMPLEQ_END(head) NULL ++#define SIMPLEQ_EMPTY(head) ((head)->sqh_first == SIMPLEQ_END(head)) ++#define SIMPLEQ_NEXT(elm, field) ((elm)->field.sqe_next) ++ ++#define SIMPLEQ_FOREACH(var, head, field) \ ++ for ((var) = ((head)->sqh_first); \ ++ (var) != SIMPLEQ_END(head); \ ++ (var) = ((var)->field.sqe_next)) ++ ++#define SIMPLEQ_FOREACH_SAFE(var, head, field, next) \ ++ for ((var) = ((head)->sqh_first); \ ++ (var) != SIMPLEQ_END(head) && \ ++ ((next = ((var)->field.sqe_next)), 1); \ ++ (var) = (next)) ++ ++/* ++ * Simple queue functions. ++ */ ++#define SIMPLEQ_INIT(head) do { \ ++ (head)->sqh_first = NULL; \ ++ (head)->sqh_last = &(head)->sqh_first; \ ++} while (/*CONSTCOND*/0) ++ ++#define SIMPLEQ_INSERT_HEAD(head, elm, field) do { \ ++ if (((elm)->field.sqe_next = (head)->sqh_first) == NULL) \ ++ (head)->sqh_last = &(elm)->field.sqe_next; \ ++ (head)->sqh_first = (elm); \ ++} while (/*CONSTCOND*/0) ++ ++#define SIMPLEQ_INSERT_TAIL(head, elm, field) do { \ ++ (elm)->field.sqe_next = NULL; \ ++ *(head)->sqh_last = (elm); \ ++ (head)->sqh_last = &(elm)->field.sqe_next; \ ++} while (/*CONSTCOND*/0) ++ ++#define SIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do { \ ++ if (((elm)->field.sqe_next = (listelm)->field.sqe_next) == NULL)\ ++ (head)->sqh_last = &(elm)->field.sqe_next; \ ++ (listelm)->field.sqe_next = (elm); \ ++} while (/*CONSTCOND*/0) ++ ++#define SIMPLEQ_REMOVE_HEAD(head, field) do { \ ++ if (((head)->sqh_first = (head)->sqh_first->field.sqe_next) == NULL) \ ++ (head)->sqh_last = &(head)->sqh_first; \ ++} while (/*CONSTCOND*/0) ++ ++#define SIMPLEQ_REMOVE_AFTER(head, elm, field) do { \ ++ if (((elm)->field.sqe_next = (elm)->field.sqe_next->field.sqe_next) \ ++ == NULL) \ ++ (head)->sqh_last = &(elm)->field.sqe_next; \ ++} while (/*CONSTCOND*/0) ++ ++#define SIMPLEQ_REMOVE(head, elm, type, field) do { \ ++ if ((head)->sqh_first == (elm)) { \ ++ SIMPLEQ_REMOVE_HEAD((head), field); \ ++ } else { \ ++ struct type *curelm = (head)->sqh_first; \ ++ while (curelm->field.sqe_next != (elm)) \ ++ curelm = curelm->field.sqe_next; \ ++ if ((curelm->field.sqe_next = \ ++ curelm->field.sqe_next->field.sqe_next) == NULL) \ ++ (head)->sqh_last = &(curelm)->field.sqe_next; \ ++ } \ ++} while (/*CONSTCOND*/0) ++ ++#define SIMPLEQ_CONCAT(head1, head2) do { \ ++ if (!SIMPLEQ_EMPTY((head2))) { \ ++ *(head1)->sqh_last = (head2)->sqh_first; \ ++ (head1)->sqh_last = (head2)->sqh_last; \ ++ SIMPLEQ_INIT((head2)); \ ++ } \ ++} while (/*CONSTCOND*/0) ++ ++#define SIMPLEQ_LAST(head, type, field) \ ++ (SIMPLEQ_EMPTY((head)) ? \ ++ NULL : \ ++ ((struct type *)(void *) \ ++ ((char *)((head)->sqh_last) - offsetof(struct type, field)))) ++ ++/* ++ * Tail queue definitions. ++ */ ++#define _TAILQ_HEAD(name, type, qual) \ ++struct name { \ ++ qual type *tqh_first; /* first element */ \ ++ qual type *qual *tqh_last; /* addr of last next element */ \ ++} ++#define TAILQ_HEAD(name, type) _TAILQ_HEAD(name, struct type,) ++ ++#define TAILQ_HEAD_INITIALIZER(head) \ ++ { TAILQ_END(head), &(head).tqh_first } ++ ++#define _TAILQ_ENTRY(type, qual) \ ++struct { \ ++ qual type *tqe_next; /* next element */ \ ++ qual type *qual *tqe_prev; /* address of previous next element */\ ++} ++#define TAILQ_ENTRY(type) _TAILQ_ENTRY(struct type,) ++ ++/* ++ * Tail queue access methods. ++ */ ++#define TAILQ_FIRST(head) ((head)->tqh_first) ++#define TAILQ_END(head) (NULL) ++#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) ++#define TAILQ_LAST(head, headname) \ ++ (*(((struct headname *)((head)->tqh_last))->tqh_last)) ++#define TAILQ_PREV(elm, headname, field) \ ++ (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last)) ++#define TAILQ_EMPTY(head) (TAILQ_FIRST(head) == TAILQ_END(head)) ++ ++ ++#define TAILQ_FOREACH(var, head, field) \ ++ for ((var) = ((head)->tqh_first); \ ++ (var) != TAILQ_END(head); \ ++ (var) = ((var)->field.tqe_next)) ++ ++#define TAILQ_FOREACH_SAFE(var, head, field, next) \ ++ for ((var) = ((head)->tqh_first); \ ++ (var) != TAILQ_END(head) && \ ++ ((next) = TAILQ_NEXT(var, field), 1); (var) = (next)) ++ ++#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \ ++ for ((var) = (*(((struct headname *)((head)->tqh_last))->tqh_last));\ ++ (var) != TAILQ_END(head); \ ++ (var) = (*(((struct headname *)((var)->field.tqe_prev))->tqh_last))) ++ ++#define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, prev) \ ++ for ((var) = TAILQ_LAST((head), headname); \ ++ (var) != TAILQ_END(head) && \ ++ ((prev) = TAILQ_PREV((var), headname, field), 1); (var) = (prev)) ++ ++/* ++ * Tail queue functions. ++ */ ++#if defined(QUEUEDEBUG) ++#define QUEUEDEBUG_TAILQ_INSERT_HEAD(head, elm, field) \ ++ if ((head)->tqh_first && \ ++ (head)->tqh_first->field.tqe_prev != &(head)->tqh_first) \ ++ QUEUEDEBUG_ABORT("TAILQ_INSERT_HEAD %p %s:%d", (head), \ ++ __FILE__, __LINE__); ++#define QUEUEDEBUG_TAILQ_INSERT_TAIL(head, elm, field) \ ++ if (*(head)->tqh_last != NULL) \ ++ QUEUEDEBUG_ABORT("TAILQ_INSERT_TAIL %p %s:%d", (head), \ ++ __FILE__, __LINE__); ++#define QUEUEDEBUG_TAILQ_OP(elm, field) \ ++ if ((elm)->field.tqe_next && \ ++ (elm)->field.tqe_next->field.tqe_prev != \ ++ &(elm)->field.tqe_next) \ ++ QUEUEDEBUG_ABORT("TAILQ_* forw %p %s:%d", (elm), \ ++ __FILE__, __LINE__); \ ++ if (*(elm)->field.tqe_prev != (elm)) \ ++ QUEUEDEBUG_ABORT("TAILQ_* back %p %s:%d", (elm), \ ++ __FILE__, __LINE__); ++#define QUEUEDEBUG_TAILQ_PREREMOVE(head, elm, field) \ ++ if ((elm)->field.tqe_next == NULL && \ ++ (head)->tqh_last != &(elm)->field.tqe_next) \ ++ QUEUEDEBUG_ABORT("TAILQ_PREREMOVE head %p elm %p %s:%d",\ ++ (head), (elm), __FILE__, __LINE__); ++#define QUEUEDEBUG_TAILQ_POSTREMOVE(elm, field) \ ++ (elm)->field.tqe_next = (void *)1L; \ ++ (elm)->field.tqe_prev = (void *)1L; ++#else ++#define QUEUEDEBUG_TAILQ_INSERT_HEAD(head, elm, field) ++#define QUEUEDEBUG_TAILQ_INSERT_TAIL(head, elm, field) ++#define QUEUEDEBUG_TAILQ_OP(elm, field) ++#define QUEUEDEBUG_TAILQ_PREREMOVE(head, elm, field) ++#define QUEUEDEBUG_TAILQ_POSTREMOVE(elm, field) ++#endif ++ ++#define TAILQ_INIT(head) do { \ ++ (head)->tqh_first = TAILQ_END(head); \ ++ (head)->tqh_last = &(head)->tqh_first; \ ++} while (/*CONSTCOND*/0) ++ ++#define TAILQ_INSERT_HEAD(head, elm, field) do { \ ++ QUEUEDEBUG_TAILQ_INSERT_HEAD((head), (elm), field) \ ++ if (((elm)->field.tqe_next = (head)->tqh_first) != TAILQ_END(head))\ ++ (head)->tqh_first->field.tqe_prev = \ ++ &(elm)->field.tqe_next; \ ++ else \ ++ (head)->tqh_last = &(elm)->field.tqe_next; \ ++ (head)->tqh_first = (elm); \ ++ (elm)->field.tqe_prev = &(head)->tqh_first; \ ++} while (/*CONSTCOND*/0) ++ ++#define TAILQ_INSERT_TAIL(head, elm, field) do { \ ++ QUEUEDEBUG_TAILQ_INSERT_TAIL((head), (elm), field) \ ++ (elm)->field.tqe_next = TAILQ_END(head); \ ++ (elm)->field.tqe_prev = (head)->tqh_last; \ ++ *(head)->tqh_last = (elm); \ ++ (head)->tqh_last = &(elm)->field.tqe_next; \ ++} while (/*CONSTCOND*/0) ++ ++#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \ ++ QUEUEDEBUG_TAILQ_OP((listelm), field) \ ++ if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != \ ++ TAILQ_END(head)) \ ++ (elm)->field.tqe_next->field.tqe_prev = \ ++ &(elm)->field.tqe_next; \ ++ else \ ++ (head)->tqh_last = &(elm)->field.tqe_next; \ ++ (listelm)->field.tqe_next = (elm); \ ++ (elm)->field.tqe_prev = &(listelm)->field.tqe_next; \ ++} while (/*CONSTCOND*/0) ++ ++#define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \ ++ QUEUEDEBUG_TAILQ_OP((listelm), field) \ ++ (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \ ++ (elm)->field.tqe_next = (listelm); \ ++ *(listelm)->field.tqe_prev = (elm); \ ++ (listelm)->field.tqe_prev = &(elm)->field.tqe_next; \ ++} while (/*CONSTCOND*/0) ++ ++#define TAILQ_REMOVE(head, elm, field) do { \ ++ QUEUEDEBUG_TAILQ_PREREMOVE((head), (elm), field) \ ++ QUEUEDEBUG_TAILQ_OP((elm), field) \ ++ if (((elm)->field.tqe_next) != TAILQ_END(head)) \ ++ (elm)->field.tqe_next->field.tqe_prev = \ ++ (elm)->field.tqe_prev; \ ++ else \ ++ (head)->tqh_last = (elm)->field.tqe_prev; \ ++ *(elm)->field.tqe_prev = (elm)->field.tqe_next; \ ++ QUEUEDEBUG_TAILQ_POSTREMOVE((elm), field); \ ++} while (/*CONSTCOND*/0) ++ ++#define TAILQ_REPLACE(head, elm, elm2, field) do { \ ++ if (((elm2)->field.tqe_next = (elm)->field.tqe_next) != \ ++ TAILQ_END(head)) \ ++ (elm2)->field.tqe_next->field.tqe_prev = \ ++ &(elm2)->field.tqe_next; \ ++ else \ ++ (head)->tqh_last = &(elm2)->field.tqe_next; \ ++ (elm2)->field.tqe_prev = (elm)->field.tqe_prev; \ ++ *(elm2)->field.tqe_prev = (elm2); \ ++ QUEUEDEBUG_TAILQ_POSTREMOVE((elm), field); \ ++} while (/*CONSTCOND*/0) ++ ++#define TAILQ_CONCAT(head1, head2, field) do { \ ++ if (!TAILQ_EMPTY(head2)) { \ ++ *(head1)->tqh_last = (head2)->tqh_first; \ ++ (head2)->tqh_first->field.tqe_prev = (head1)->tqh_last; \ ++ (head1)->tqh_last = (head2)->tqh_last; \ ++ TAILQ_INIT((head2)); \ ++ } \ ++} while (/*CONSTCOND*/0) ++ ++/* ++ * Singly-linked Tail queue declarations. ++ */ ++#define STAILQ_HEAD(name, type) \ ++struct name { \ ++ struct type *stqh_first; /* first element */ \ ++ struct type **stqh_last; /* addr of last next element */ \ ++} ++ ++#define STAILQ_HEAD_INITIALIZER(head) \ ++ { NULL, &(head).stqh_first } ++ ++#define STAILQ_ENTRY(type) \ ++struct { \ ++ struct type *stqe_next; /* next element */ \ ++} ++ ++/* ++ * Singly-linked Tail queue access methods. ++ */ ++#define STAILQ_FIRST(head) ((head)->stqh_first) ++#define STAILQ_END(head) NULL ++#define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next) ++#define STAILQ_EMPTY(head) (STAILQ_FIRST(head) == STAILQ_END(head)) ++ ++/* ++ * Singly-linked Tail queue functions. ++ */ ++#define STAILQ_INIT(head) do { \ ++ (head)->stqh_first = NULL; \ ++ (head)->stqh_last = &(head)->stqh_first; \ ++} while (/*CONSTCOND*/0) ++ ++#define STAILQ_INSERT_HEAD(head, elm, field) do { \ ++ if (((elm)->field.stqe_next = (head)->stqh_first) == NULL) \ ++ (head)->stqh_last = &(elm)->field.stqe_next; \ ++ (head)->stqh_first = (elm); \ ++} while (/*CONSTCOND*/0) ++ ++#define STAILQ_INSERT_TAIL(head, elm, field) do { \ ++ (elm)->field.stqe_next = NULL; \ ++ *(head)->stqh_last = (elm); \ ++ (head)->stqh_last = &(elm)->field.stqe_next; \ ++} while (/*CONSTCOND*/0) ++ ++#define STAILQ_INSERT_AFTER(head, listelm, elm, field) do { \ ++ if (((elm)->field.stqe_next = (listelm)->field.stqe_next) == NULL)\ ++ (head)->stqh_last = &(elm)->field.stqe_next; \ ++ (listelm)->field.stqe_next = (elm); \ ++} while (/*CONSTCOND*/0) ++ ++#define STAILQ_REMOVE_HEAD(head, field) do { \ ++ if (((head)->stqh_first = (head)->stqh_first->field.stqe_next) == NULL) \ ++ (head)->stqh_last = &(head)->stqh_first; \ ++} while (/*CONSTCOND*/0) ++ ++#define STAILQ_REMOVE(head, elm, type, field) do { \ ++ if ((head)->stqh_first == (elm)) { \ ++ STAILQ_REMOVE_HEAD((head), field); \ ++ } else { \ ++ struct type *curelm = (head)->stqh_first; \ ++ while (curelm->field.stqe_next != (elm)) \ ++ curelm = curelm->field.stqe_next; \ ++ if ((curelm->field.stqe_next = \ ++ curelm->field.stqe_next->field.stqe_next) == NULL) \ ++ (head)->stqh_last = &(curelm)->field.stqe_next; \ ++ } \ ++} while (/*CONSTCOND*/0) ++ ++#define STAILQ_FOREACH(var, head, field) \ ++ for ((var) = ((head)->stqh_first); \ ++ (var); \ ++ (var) = ((var)->field.stqe_next)) ++ ++#define STAILQ_FOREACH_SAFE(var, head, field, tvar) \ ++ for ((var) = STAILQ_FIRST((head)); \ ++ (var) && ((tvar) = STAILQ_NEXT((var), field), 1); \ ++ (var) = (tvar)) ++ ++#define STAILQ_CONCAT(head1, head2) do { \ ++ if (!STAILQ_EMPTY((head2))) { \ ++ *(head1)->stqh_last = (head2)->stqh_first; \ ++ (head1)->stqh_last = (head2)->stqh_last; \ ++ STAILQ_INIT((head2)); \ ++ } \ ++} while (/*CONSTCOND*/0) ++ ++#define STAILQ_LAST(head, type, field) \ ++ (STAILQ_EMPTY((head)) ? \ ++ NULL : \ ++ ((struct type *)(void *) \ ++ ((char *)((head)->stqh_last) - offsetof(struct type, field)))) ++ ++ ++#ifndef _KERNEL ++/* ++ * Circular queue definitions. Do not use. We still keep the macros ++ * for compatibility but because of pointer aliasing issues their use ++ * is discouraged! ++ */ ++ ++/* ++ * __launder_type(): We use this ugly hack to work around the the compiler ++ * noticing that two types may not alias each other and elide tests in code. ++ * We hit this in the CIRCLEQ macros when comparing 'struct name *' and ++ * 'struct type *' (see CIRCLEQ_HEAD()). Modern compilers (such as GCC ++ * 4.8) declare these comparisons as always false, causing the code to ++ * not run as designed. ++ * ++ * This hack is only to be used for comparisons and thus can be fully const. ++ * Do not use for assignment. ++ * ++ * If we ever choose to change the ABI of the CIRCLEQ macros, we could fix ++ * this by changing the head/tail sentinal values, but see the note above ++ * this one. ++ */ ++static __inline const void * __launder_type(const void *); ++static __inline const void * ++__launder_type(const void *__x) ++{ ++ __asm __volatile("" : "+r" (__x)); ++ return __x; ++} ++ ++#if defined(QUEUEDEBUG) ++#define QUEUEDEBUG_CIRCLEQ_HEAD(head, field) \ ++ if ((head)->cqh_first != CIRCLEQ_ENDC(head) && \ ++ (head)->cqh_first->field.cqe_prev != CIRCLEQ_ENDC(head)) \ ++ QUEUEDEBUG_ABORT("CIRCLEQ head forw %p %s:%d", (head), \ ++ __FILE__, __LINE__); \ ++ if ((head)->cqh_last != CIRCLEQ_ENDC(head) && \ ++ (head)->cqh_last->field.cqe_next != CIRCLEQ_ENDC(head)) \ ++ QUEUEDEBUG_ABORT("CIRCLEQ head back %p %s:%d", (head), \ ++ __FILE__, __LINE__); ++#define QUEUEDEBUG_CIRCLEQ_ELM(head, elm, field) \ ++ if ((elm)->field.cqe_next == CIRCLEQ_ENDC(head)) { \ ++ if ((head)->cqh_last != (elm)) \ ++ QUEUEDEBUG_ABORT("CIRCLEQ elm last %p %s:%d", \ ++ (elm), __FILE__, __LINE__); \ ++ } else { \ ++ if ((elm)->field.cqe_next->field.cqe_prev != (elm)) \ ++ QUEUEDEBUG_ABORT("CIRCLEQ elm forw %p %s:%d", \ ++ (elm), __FILE__, __LINE__); \ ++ } \ ++ if ((elm)->field.cqe_prev == CIRCLEQ_ENDC(head)) { \ ++ if ((head)->cqh_first != (elm)) \ ++ QUEUEDEBUG_ABORT("CIRCLEQ elm first %p %s:%d", \ ++ (elm), __FILE__, __LINE__); \ ++ } else { \ ++ if ((elm)->field.cqe_prev->field.cqe_next != (elm)) \ ++ QUEUEDEBUG_ABORT("CIRCLEQ elm prev %p %s:%d", \ ++ (elm), __FILE__, __LINE__); \ ++ } ++#define QUEUEDEBUG_CIRCLEQ_POSTREMOVE(elm, field) \ ++ (elm)->field.cqe_next = (void *)1L; \ ++ (elm)->field.cqe_prev = (void *)1L; ++#else ++#define QUEUEDEBUG_CIRCLEQ_HEAD(head, field) ++#define QUEUEDEBUG_CIRCLEQ_ELM(head, elm, field) ++#define QUEUEDEBUG_CIRCLEQ_POSTREMOVE(elm, field) ++#endif ++ ++#define CIRCLEQ_HEAD(name, type) \ ++struct name { \ ++ struct type *cqh_first; /* first element */ \ ++ struct type *cqh_last; /* last element */ \ ++} ++ ++#define CIRCLEQ_HEAD_INITIALIZER(head) \ ++ { CIRCLEQ_END(&head), CIRCLEQ_END(&head) } ++ ++#define CIRCLEQ_ENTRY(type) \ ++struct { \ ++ struct type *cqe_next; /* next element */ \ ++ struct type *cqe_prev; /* previous element */ \ ++} ++ ++/* ++ * Circular queue functions. ++ */ ++#define CIRCLEQ_INIT(head) do { \ ++ (head)->cqh_first = CIRCLEQ_END(head); \ ++ (head)->cqh_last = CIRCLEQ_END(head); \ ++} while (/*CONSTCOND*/0) ++ ++#define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do { \ ++ QUEUEDEBUG_CIRCLEQ_HEAD((head), field) \ ++ QUEUEDEBUG_CIRCLEQ_ELM((head), (listelm), field) \ ++ (elm)->field.cqe_next = (listelm)->field.cqe_next; \ ++ (elm)->field.cqe_prev = (listelm); \ ++ if ((listelm)->field.cqe_next == CIRCLEQ_ENDC(head)) \ ++ (head)->cqh_last = (elm); \ ++ else \ ++ (listelm)->field.cqe_next->field.cqe_prev = (elm); \ ++ (listelm)->field.cqe_next = (elm); \ ++} while (/*CONSTCOND*/0) ++ ++#define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do { \ ++ QUEUEDEBUG_CIRCLEQ_HEAD((head), field) \ ++ QUEUEDEBUG_CIRCLEQ_ELM((head), (listelm), field) \ ++ (elm)->field.cqe_next = (listelm); \ ++ (elm)->field.cqe_prev = (listelm)->field.cqe_prev; \ ++ if ((listelm)->field.cqe_prev == CIRCLEQ_ENDC(head)) \ ++ (head)->cqh_first = (elm); \ ++ else \ ++ (listelm)->field.cqe_prev->field.cqe_next = (elm); \ ++ (listelm)->field.cqe_prev = (elm); \ ++} while (/*CONSTCOND*/0) ++ ++#define CIRCLEQ_INSERT_HEAD(head, elm, field) do { \ ++ QUEUEDEBUG_CIRCLEQ_HEAD((head), field) \ ++ (elm)->field.cqe_next = (head)->cqh_first; \ ++ (elm)->field.cqe_prev = CIRCLEQ_END(head); \ ++ if ((head)->cqh_last == CIRCLEQ_ENDC(head)) \ ++ (head)->cqh_last = (elm); \ ++ else \ ++ (head)->cqh_first->field.cqe_prev = (elm); \ ++ (head)->cqh_first = (elm); \ ++} while (/*CONSTCOND*/0) ++ ++#define CIRCLEQ_INSERT_TAIL(head, elm, field) do { \ ++ QUEUEDEBUG_CIRCLEQ_HEAD((head), field) \ ++ (elm)->field.cqe_next = CIRCLEQ_END(head); \ ++ (elm)->field.cqe_prev = (head)->cqh_last; \ ++ if ((head)->cqh_first == CIRCLEQ_ENDC(head)) \ ++ (head)->cqh_first = (elm); \ ++ else \ ++ (head)->cqh_last->field.cqe_next = (elm); \ ++ (head)->cqh_last = (elm); \ ++} while (/*CONSTCOND*/0) ++ ++#define CIRCLEQ_REMOVE(head, elm, field) do { \ ++ QUEUEDEBUG_CIRCLEQ_HEAD((head), field) \ ++ QUEUEDEBUG_CIRCLEQ_ELM((head), (elm), field) \ ++ if ((elm)->field.cqe_next == CIRCLEQ_ENDC(head)) \ ++ (head)->cqh_last = (elm)->field.cqe_prev; \ ++ else \ ++ (elm)->field.cqe_next->field.cqe_prev = \ ++ (elm)->field.cqe_prev; \ ++ if ((elm)->field.cqe_prev == CIRCLEQ_ENDC(head)) \ ++ (head)->cqh_first = (elm)->field.cqe_next; \ ++ else \ ++ (elm)->field.cqe_prev->field.cqe_next = \ ++ (elm)->field.cqe_next; \ ++ QUEUEDEBUG_CIRCLEQ_POSTREMOVE((elm), field) \ ++} while (/*CONSTCOND*/0) ++ ++#define CIRCLEQ_FOREACH(var, head, field) \ ++ for ((var) = ((head)->cqh_first); \ ++ (var) != CIRCLEQ_ENDC(head); \ ++ (var) = ((var)->field.cqe_next)) ++ ++#define CIRCLEQ_FOREACH_REVERSE(var, head, field) \ ++ for ((var) = ((head)->cqh_last); \ ++ (var) != CIRCLEQ_ENDC(head); \ ++ (var) = ((var)->field.cqe_prev)) ++ ++/* ++ * Circular queue access methods. ++ */ ++#define CIRCLEQ_FIRST(head) ((head)->cqh_first) ++#define CIRCLEQ_LAST(head) ((head)->cqh_last) ++/* For comparisons */ ++#define CIRCLEQ_ENDC(head) (__launder_type(head)) ++/* For assignments */ ++#define CIRCLEQ_END(head) ((void *)(head)) ++#define CIRCLEQ_NEXT(elm, field) ((elm)->field.cqe_next) ++#define CIRCLEQ_PREV(elm, field) ((elm)->field.cqe_prev) ++#define CIRCLEQ_EMPTY(head) \ ++ (CIRCLEQ_FIRST(head) == CIRCLEQ_ENDC(head)) ++ ++#define CIRCLEQ_LOOP_NEXT(head, elm, field) \ ++ (((elm)->field.cqe_next == CIRCLEQ_ENDC(head)) \ ++ ? ((head)->cqh_first) \ ++ : (elm->field.cqe_next)) ++#define CIRCLEQ_LOOP_PREV(head, elm, field) \ ++ (((elm)->field.cqe_prev == CIRCLEQ_ENDC(head)) \ ++ ? ((head)->cqh_last) \ ++ : (elm->field.cqe_prev)) ++#endif /* !_KERNEL */ ++ ++#endif /* !_SYS_QUEUE_H_ */ diff --git a/meta/recipes-extended/libtirpc/libtirpc/remove-des-functionality.patch b/meta/recipes-extended/libtirpc/libtirpc/remove-des-functionality.patch new file mode 100644 index 0000000000..512e93497d --- /dev/null +++ b/meta/recipes-extended/libtirpc/libtirpc/remove-des-functionality.patch @@ -0,0 +1,144 @@ +uclibc and musl does not provide des functionality. Lets disable it. + +Upstream-Status: Inappropriate [uclibc and musl specific] + +Signed-off-by: Khem Raj <raj.khem@gmail.com> +Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com> +Signed-off-by: Maxin B. John <maxin.john@intel.com> +--- +diff -Naur libtirpc-1.0.1-orig/src/Makefile.am libtirpc-1.0.1/src/Makefile.am +--- libtirpc-1.0.1-orig/src/Makefile.am 2015-10-30 17:15:14.000000000 +0200 ++++ libtirpc-1.0.1/src/Makefile.am 2015-12-21 15:56:17.094702429 +0200 +@@ -22,9 +22,8 @@ + pmap_prot.c pmap_prot2.c pmap_rmt.c rpc_prot.c rpc_commondata.c \ + rpc_callmsg.c rpc_generic.c rpc_soc.c rpcb_clnt.c rpcb_prot.c \ + rpcb_st_xdr.c svc.c svc_auth.c svc_dg.c svc_auth_unix.c svc_auth_none.c \ +- svc_auth_des.c \ + svc_generic.c svc_raw.c svc_run.c svc_simple.c svc_vc.c getpeereid.c \ +- auth_time.c auth_des.c authdes_prot.c debug.c ++ debug.c + + ## XDR + libtirpc_la_SOURCES += xdr.c xdr_rec.c xdr_array.c xdr_float.c xdr_mem.c xdr_reference.c xdr_stdio.c xdr_sizeof.c +@@ -41,8 +40,8 @@ + libtirpc_la_CFLAGS = -DHAVE_RPCSEC_GSS $(GSSAPI_CFLAGS) + endif + +-libtirpc_la_SOURCES += key_call.c key_prot_xdr.c getpublickey.c +-libtirpc_la_SOURCES += netname.c netnamer.c rpcdname.c rtime.c ++#libtirpc_la_SOURCES += key_call.c key_prot_xdr.c getpublickey.c ++#libtirpc_la_SOURCES += netname.c netnamer.c rpcdname.c rtime.c + + CLEANFILES = cscope.* *~ + DISTCLEANFILES = Makefile.in +diff -Naur libtirpc-1.0.1-orig/src/rpc_soc.c libtirpc-1.0.1/src/rpc_soc.c +--- libtirpc-1.0.1-orig/src/rpc_soc.c 2015-10-30 17:15:14.000000000 +0200 ++++ libtirpc-1.0.1/src/rpc_soc.c 2015-12-21 15:56:17.095702416 +0200 +@@ -61,7 +61,6 @@ + #include <string.h> + #include <unistd.h> + #include <fcntl.h> +-#include <rpcsvc/nis.h> + + #include "rpc_com.h" + +@@ -522,86 +521,6 @@ + } + + /* +- * Create the client des authentication object. Obsoleted by +- * authdes_seccreate(). +- */ +-AUTH * +-authdes_create(servername, window, syncaddr, ckey) +- char *servername; /* network name of server */ +- u_int window; /* time to live */ +- struct sockaddr *syncaddr; /* optional hostaddr to sync with */ +- des_block *ckey; /* optional conversation key to use */ +-{ +- AUTH *nauth; +- char hostname[NI_MAXHOST]; +- +- if (syncaddr) { +- /* +- * Change addr to hostname, because that is the way +- * new interface takes it. +- */ +- switch (syncaddr->sa_family) { +- case AF_INET: +- if (getnameinfo(syncaddr, sizeof(struct sockaddr_in), hostname, +- sizeof hostname, NULL, 0, 0) != 0) +- goto fallback; +- break; +- case AF_INET6: +- if (getnameinfo(syncaddr, sizeof(struct sockaddr_in6), hostname, +- sizeof hostname, NULL, 0, 0) != 0) +- goto fallback; +- break; +- default: +- goto fallback; +- } +- nauth = authdes_seccreate(servername, window, hostname, ckey); +- return (nauth); +- } +-fallback: +- return authdes_seccreate(servername, window, NULL, ckey); +-} +- +-/* +- * Create the client des authentication object. Obsoleted by +- * authdes_pk_seccreate(). +- */ +-extern AUTH *authdes_pk_seccreate(const char *, netobj *, u_int, const char *, +- const des_block *, nis_server *); +- +-AUTH * +-authdes_pk_create(servername, pkey, window, syncaddr, ckey) +- char *servername; /* network name of server */ +- netobj *pkey; /* public key */ +- u_int window; /* time to live */ +- struct sockaddr *syncaddr; /* optional hostaddr to sync with */ +- des_block *ckey; /* optional conversation key to use */ +-{ +- AUTH *nauth; +- char hostname[NI_MAXHOST]; +- +- if (syncaddr) { +- /* +- * Change addr to hostname, because that is the way +- * new interface takes it. +- */ +- switch (syncaddr->sa_family) { +- case AF_INET: +- if (getnameinfo(syncaddr, sizeof(struct sockaddr_in), hostname, +- sizeof hostname, NULL, 0, 0) != 0) +- goto fallback; +- break; +- default: +- goto fallback; +- } +- nauth = authdes_pk_seccreate(servername, pkey, window, hostname, ckey, NULL); +- return (nauth); +- } +-fallback: +- return authdes_pk_seccreate(servername, pkey, window, NULL, ckey, NULL); +-} +- +- +-/* + * Create a client handle for a unix connection. Obsoleted by clnt_vc_create() + */ + CLIENT * +diff -Naur libtirpc-1.0.1-orig/src/svc_auth.c libtirpc-1.0.1/src/svc_auth.c +--- libtirpc-1.0.1-orig/src/svc_auth.c 2015-10-30 17:15:14.000000000 +0200 ++++ libtirpc-1.0.1/src/svc_auth.c 2015-12-21 15:56:17.095702416 +0200 +@@ -114,9 +114,6 @@ + case AUTH_SHORT: + dummy = _svcauth_short(rqst, msg); + return (dummy); +- case AUTH_DES: +- dummy = _svcauth_des(rqst, msg); +- return (dummy); + #ifdef HAVE_RPCSEC_GSS + case RPCSEC_GSS: + dummy = _svcauth_gss(rqst, msg, no_dispatch); diff --git a/meta/recipes-extended/libtirpc/libtirpc/remove-des-uclibc.patch b/meta/recipes-extended/libtirpc/libtirpc/remove-des-uclibc.patch deleted file mode 100644 index 553b1ffb82..0000000000 --- a/meta/recipes-extended/libtirpc/libtirpc/remove-des-uclibc.patch +++ /dev/null @@ -1,38 +0,0 @@ -uclibc does not provide des functionality unlike eglibc so lets disable ssl support - -Upstream-Status: Inappropriate [uclibc specific] -Signed-off-by: Khem Raj <raj.khem@gmail.com> - -Index: libtirpc-0.2.5/src/rpc_soc.c -=================================================================== ---- libtirpc-0.2.5.orig/src/rpc_soc.c -+++ libtirpc-0.2.5/src/rpc_soc.c -@@ -520,6 +520,7 @@ clnt_broadcast(prog, vers, proc, xargs, - (resultproc_t) rpc_wrap_bcast, "udp"); - } - -+#if 0 - /* - * Create the client des authentication object. Obsoleted by - * authdes_seccreate(). -@@ -551,6 +552,7 @@ fallback: - dummy = authdes_seccreate(servername, window, NULL, ckey); - return (dummy); - } -+#endif - - /* - * Create a client handle for a unix connection. Obsoleted by clnt_vc_create() -Index: libtirpc-0.2.5/src/Makefile.am -=================================================================== ---- libtirpc-0.2.5.orig/src/Makefile.am -+++ libtirpc-0.2.5/src/Makefile.am -@@ -51,7 +51,7 @@ libtirpc_la_SOURCES = auth_none.c auth_u - rpc_callmsg.c rpc_generic.c rpc_soc.c rpcb_clnt.c rpcb_prot.c \ - rpcb_st_xdr.c svc.c svc_auth.c svc_dg.c svc_auth_unix.c svc_auth_none.c \ - svc_generic.c svc_raw.c svc_run.c svc_simple.c svc_vc.c getpeereid.c \ -- auth_time.c auth_des.c authdes_prot.c debug.c -+ auth_time.c debug.c - - ## XDR - libtirpc_la_SOURCES += xdr.c xdr_rec.c xdr_array.c xdr_float.c xdr_mem.c xdr_reference.c xdr_stdio.c diff --git a/meta/recipes-extended/libtirpc/libtirpc_0.2.5.bb b/meta/recipes-extended/libtirpc/libtirpc_1.0.1.bb index 330b829911..302dc50625 100644 --- a/meta/recipes-extended/libtirpc/libtirpc_0.2.5.bb +++ b/meta/recipes-extended/libtirpc/libtirpc_1.0.1.bb @@ -13,14 +13,19 @@ PROVIDES = "virtual/librpc" SRC_URI = "${SOURCEFORGE_MIRROR}/${BPN}/${BP}.tar.bz2;name=libtirpc \ ${GENTOO_MIRROR}/${BPN}-glibc-nfs.tar.xz;name=glibc-nfs \ file://libtirpc-0.2.1-fortify.patch \ + file://0001-Add-missing-rwlock_unlocks-in-xprt_register.patch \ " -SRC_URI_append_libc-uclibc = " file://remove-des-uclibc.patch \ +SRC_URI_append_libc-uclibc = " file://remove-des-functionality.patch \ file://va_list.patch \ " -SRC_URI[libtirpc.md5sum] = "8cd41a5ef5a9b50d0fb6abb98af15368" -SRC_URI[libtirpc.sha256sum] = "62f9de7c2c8686c568757730e1fef66502a0e00d6cacf33546d0267984e002db" +SRC_URI_append_libc-musl = " file://remove-des-functionality.patch \ + file://Use-netbsd-queue.h.patch \ + " + +SRC_URI[libtirpc.md5sum] = "36ce1c0ff80863bb0839d54aa0b94014" +SRC_URI[libtirpc.sha256sum] = "5156974f31be7ccbc8ab1de37c4739af6d9d42c87b1d5caf4835dda75fcbb89e" SRC_URI[glibc-nfs.md5sum] = "5ae500b9d0b6b72cb875bc04944b9445" SRC_URI[glibc-nfs.sha256sum] = "2677cfedf626f3f5a8f6e507aed5bb8f79a7453b589d684dbbc086e755170d83" |