X-Git-Url: https://granicus.if.org/sourcecode?a=blobdiff_plain;f=net.c;h=fba521be564ee65e4e0ffbdedde0bfa94f782688;hb=e0bc222263cf47a43e1b26d55edb2ffadc8ccbff;hp=6efa8710a4676fb2287e3a363fe7d05e31c00d03;hpb=05e5e79a706a560188c28aba8d765e1a8534e87b;p=strace diff --git a/net.c b/net.c index 6efa8710..fba521be 100644 --- a/net.c +++ b/net.c @@ -26,87 +26,75 @@ * 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. - * - * $Id$ */ #include "defs.h" - +#include #include #include #include - #if defined(HAVE_SIN6_SCOPE_ID_LINUX) -#define in6_addr in6_addr_libc -#define ipv6_mreq ipv6_mreq_libc -#define sockaddr_in6 sockaddr_in6_libc +# define in6_addr in6_addr_libc +# define ipv6_mreq ipv6_mreq_libc +# define sockaddr_in6 sockaddr_in6_libc #endif - #include #ifdef HAVE_NETINET_TCP_H -#include +# include #endif #ifdef HAVE_NETINET_UDP_H -#include +# include +#endif +#ifdef HAVE_NETINET_SCTP_H +# include #endif #include #include -#if defined(LINUX) #include #if defined(__GLIBC__) && (__GLIBC__ >= 2) && (__GLIBC__ + __GLIBC_MINOR__ >= 3) -# include +# include #else -# include -#endif -#endif /* LINUX */ - -#if defined (__GLIBC__) && (((__GLIBC__ < 2) || (__GLIBC__ == 2 && __GLIBC_MINOR__ < 1)) || defined(HAVE_SIN6_SCOPE_ID_LINUX)) -#if defined(HAVE_LINUX_IN6_H) -#if defined(HAVE_SIN6_SCOPE_ID_LINUX) -#undef in6_addr -#undef ipv6_mreq -#undef sockaddr_in6 -#define in6_addr in6_addr_kernel -#define ipv6_mreq ipv6_mreq_kernel -#define sockaddr_in6 sockaddr_in6_kernel -#endif -#include -#if defined(HAVE_SIN6_SCOPE_ID_LINUX) -#undef in6_addr -#undef ipv6_mreq -#undef sockaddr_in6 -#define in6_addr in6_addr_libc -#define ipv6_mreq ipv6_mreq_libc -#define sockaddr_in6 sockaddr_in6_kernel -#endif -#endif +# include +#endif + +#if defined(__GLIBC__) && (((__GLIBC__ < 2) || (__GLIBC__ == 2 && __GLIBC_MINOR__ < 1)) || defined(HAVE_SIN6_SCOPE_ID_LINUX)) +# if defined(HAVE_LINUX_IN6_H) +# if defined(HAVE_SIN6_SCOPE_ID_LINUX) +# undef in6_addr +# undef ipv6_mreq +# undef sockaddr_in6 +# define in6_addr in6_addr_kernel +# define ipv6_mreq ipv6_mreq_kernel +# define sockaddr_in6 sockaddr_in6_kernel +# endif +# include +# if defined(HAVE_SIN6_SCOPE_ID_LINUX) +# undef in6_addr +# undef ipv6_mreq +# undef sockaddr_in6 +# define in6_addr in6_addr_libc +# define ipv6_mreq ipv6_mreq_libc +# define sockaddr_in6 sockaddr_in6_kernel +# endif +# endif #endif #if defined(HAVE_SYS_UIO_H) -#include +# include #endif - #if defined(HAVE_LINUX_NETLINK_H) -#include +# include #endif - #if defined(HAVE_LINUX_IF_PACKET_H) -#include +# include #endif - #if defined(HAVE_LINUX_ICMP_H) -#include +# include #endif - #ifndef PF_UNSPEC -#define PF_UNSPEC AF_UNSPEC -#endif - -#if UNIXWARE >= 7 -#define HAVE_SENDMSG 1 /* HACK - *FIXME* */ +# define PF_UNSPEC AF_UNSPEC #endif -#ifdef LINUX /* Under Linux these are enums so we can't test for them with ifdef. */ #define IPPROTO_EGP IPPROTO_EGP #define IPPROTO_PUP IPPROTO_PUP @@ -114,111 +102,238 @@ #define IPPROTO_IGMP IPPROTO_IGMP #define IPPROTO_RAW IPPROTO_RAW #define IPPROTO_MAX IPPROTO_MAX -#endif -static struct xlat domains[] = { - { PF_UNSPEC, "PF_UNSPEC" }, - { PF_UNIX, "PF_UNIX" }, - { PF_INET, "PF_INET" }, -#ifdef PF_NETLINK - { PF_NETLINK, "PF_NETLINK" }, +static const struct xlat domains[] = { +#ifdef PF_AAL5 + { PF_AAL5, "PF_AAL5" }, #endif -#ifdef PF_PACKET - { PF_PACKET, "PF_PACKET" }, +#ifdef PF_APPLETALK + { PF_APPLETALK, "PF_APPLETALK" }, #endif -#ifdef PF_INET6 - { PF_INET6, "PF_INET6" }, +#ifdef PF_ASH + { PF_ASH, "PF_ASH" }, +#endif +#ifdef PF_ATMPVC + { PF_ATMPVC, "PF_ATMPVC" }, #endif #ifdef PF_ATMSVC - { PF_ATMSVC, "PF_INET6" }, + { PF_ATMSVC, "PF_ATMSVC" }, +#endif +#ifdef PF_AX25 + { PF_AX25, "PF_AX25" }, +#endif +#ifdef PF_BLUETOOTH + { PF_BLUETOOTH, "PF_BLUETOOTH" }, +#endif +#ifdef PF_BRIDGE + { PF_BRIDGE, "PF_BRIDGE" }, +#endif +#ifdef PF_DECnet + { PF_DECnet, "PF_DECnet" }, +#endif +#ifdef PF_DECNET + { PF_DECNET, "PF_DECNET" }, +#endif +#ifdef PF_ECONET + { PF_ECONET, "PF_ECONET" }, +#endif +#ifdef PF_FILE + { PF_FILE, "PF_FILE" }, +#endif +#ifdef PF_IMPLINK + { PF_IMPLINK, "PF_IMPLINK" }, +#endif +#ifdef PF_INET + { PF_INET, "PF_INET" }, #endif #ifdef PF_INET6 { PF_INET6, "PF_INET6" }, #endif -#ifdef PF_LOCAL - { PF_LOCAL, "PS_LOCAL" }, +#ifdef PF_IPX + { PF_IPX, "PF_IPX" }, +#endif +#ifdef PF_IRDA + { PF_IRDA, "PF_IRDA" }, #endif #ifdef PF_ISO { PF_ISO, "PF_ISO" }, #endif -#ifdef PF_AX25 - { PF_AX25, "PF_AX25" }, +#ifdef PF_KEY + { PF_KEY, "PF_KEY" }, #endif -#ifdef PF_IPX - { PF_IPX, "PF_IPX" }, +#ifdef PF_UNIX + { PF_UNIX, "PF_UNIX" }, #endif -#ifdef PF_APPLETALK - { PF_APPLETALK, "PF_APPLETALK" }, +#ifdef PF_LOCAL + { PF_LOCAL, "PF_LOCAL" }, +#endif +#ifdef PF_NETBEUI + { PF_NETBEUI, "PF_NETBEUI" }, +#endif +#ifdef PF_NETLINK + { PF_NETLINK, "PF_NETLINK" }, #endif #ifdef PF_NETROM { PF_NETROM, "PF_NETROM" }, #endif -#ifdef PF_BRIDGE - { PF_BRIDGE, "PF_BRIDGE" }, -#endif -#ifdef PF_AAL5 - { PF_AAL5, "PF_AAL5" }, +#ifdef PF_PACKET + { PF_PACKET, "PF_PACKET" }, #endif -#ifdef PF_X25 - { PF_X25, "PF_X25" }, +#ifdef PF_PPPOX + { PF_PPPOX, "PF_PPPOX" }, #endif #ifdef PF_ROSE { PF_ROSE, "PF_ROSE" }, #endif -#ifdef PF_DECNET - { PF_DECNET, "PF_DECNET" }, +#ifdef PF_ROUTE + { PF_ROUTE, "PF_ROUTE" }, #endif -#ifdef PF_NETBEUI - { PF_NETBEUI, "PF_NETBEUI" }, +#ifdef PF_SECURITY + { PF_SECURITY, "PF_SECURITY" }, #endif -#ifdef PF_IMPLINK - { PF_IMPLINK, "PF_IMPLINK" }, +#ifdef PF_SNA + { PF_SNA, "PF_SNA" }, +#endif +#ifdef PF_UNSPEC + { PF_UNSPEC, "PF_UNSPEC" }, +#endif +#ifdef PF_WANPIPE + { PF_WANPIPE, "PF_WANPIPE" }, +#endif +#ifdef PF_X25 + { PF_X25, "PF_X25" }, #endif { 0, NULL }, }; -static struct xlat addrfams[] = { - { AF_UNSPEC, "AF_UNSPEC" }, - { AF_UNIX, "AF_UNIX" }, +const struct xlat addrfams[] = { +#ifdef AF_APPLETALK + { AF_APPLETALK, "AF_APPLETALK" }, +#endif +#ifdef AF_ASH + { AF_ASH, "AF_ASH" }, +#endif +#ifdef AF_ATMPVC + { AF_ATMPVC, "AF_ATMPVC" }, +#endif +#ifdef AF_ATMSVC + { AF_ATMSVC, "AF_ATMSVC" }, +#endif +#ifdef AF_AX25 + { AF_AX25, "AF_AX25" }, +#endif +#ifdef AF_BLUETOOTH + { AF_BLUETOOTH, "AF_BLUETOOTH" }, +#endif +#ifdef AF_BRIDGE + { AF_BRIDGE, "AF_BRIDGE" }, +#endif +#ifdef AF_DECnet + { AF_DECnet, "AF_DECnet" }, +#endif +#ifdef AF_ECONET + { AF_ECONET, "AF_ECONET" }, +#endif +#ifdef AF_FILE + { AF_FILE, "AF_FILE" }, +#endif +#ifdef AF_IMPLINK + { AF_IMPLINK, "AF_IMPLINK" }, +#endif +#ifdef AF_INET { AF_INET, "AF_INET" }, +#endif #ifdef AF_INET6 { AF_INET6, "AF_INET6" }, #endif - { AF_DECnet, "AF_DECnet" }, -#ifdef PF_ATMSVC - { AF_ATMSVC, "AF_ATMSVC" }, +#ifdef AF_IPX + { AF_IPX, "AF_IPX" }, #endif -#ifdef AF_PACKET - { AF_PACKET, "AF_PACKET" }, +#ifdef AF_IRDA + { AF_IRDA, "AF_IRDA" }, +#endif +#ifdef AF_ISO + { AF_ISO, "AF_ISO" }, +#endif +#ifdef AF_KEY + { AF_KEY, "AF_KEY" }, +#endif +#ifdef AF_UNIX + { AF_UNIX, "AF_UNIX" }, +#endif +#ifdef AF_LOCAL + { AF_LOCAL, "AF_LOCAL" }, +#endif +#ifdef AF_NETBEUI + { AF_NETBEUI, "AF_NETBEUI" }, #endif #ifdef AF_NETLINK { AF_NETLINK, "AF_NETLINK" }, #endif -#ifdef AF_ISO - { AF_ISO, "AF_ISO" }, +#ifdef AF_NETROM + { AF_NETROM, "AF_NETROM" }, #endif -#ifdef AF_IMPLINK - { AF_IMPLINK, "AF_IMPLINK" }, +#ifdef AF_PACKET + { AF_PACKET, "AF_PACKET" }, +#endif +#ifdef AF_PPPOX + { AF_PPPOX, "AF_PPPOX" }, +#endif +#ifdef AF_ROSE + { AF_ROSE, "AF_ROSE" }, +#endif +#ifdef AF_ROUTE + { AF_ROUTE, "AF_ROUTE" }, +#endif +#ifdef AF_SECURITY + { AF_SECURITY, "AF_SECURITY" }, +#endif +#ifdef AF_SNA + { AF_SNA, "AF_SNA" }, +#endif +#ifdef AF_UNSPEC + { AF_UNSPEC, "AF_UNSPEC" }, +#endif +#ifdef AF_WANPIPE + { AF_WANPIPE, "AF_WANPIPE" }, +#endif +#ifdef AF_X25 + { AF_X25, "AF_X25" }, #endif { 0, NULL }, }; -static struct xlat socktypes[] = { +static const struct xlat socktypes[] = { { SOCK_STREAM, "SOCK_STREAM" }, { SOCK_DGRAM, "SOCK_DGRAM" }, #ifdef SOCK_RAW { SOCK_RAW, "SOCK_RAW" }, #endif +#ifdef SOCK_RDM + { SOCK_RDM, "SOCK_RDM" }, +#endif #ifdef SOCK_SEQPACKET { SOCK_SEQPACKET,"SOCK_SEQPACKET"}, #endif -#ifdef SOCK_RDM - { SOCK_RDM, "SOCK_RDM" }, +#ifdef SOCK_DCCP + { SOCK_DCCP, "SOCK_DCCP" }, #endif #ifdef SOCK_PACKET { SOCK_PACKET, "SOCK_PACKET" }, #endif { 0, NULL }, }; -static struct xlat socketlayers[] = { +static const struct xlat sock_type_flags[] = { +#ifdef SOCK_CLOEXEC + { SOCK_CLOEXEC, "SOCK_CLOEXEC" }, +#endif +#ifdef SOCK_NONBLOCK + { SOCK_NONBLOCK,"SOCK_NONBLOCK" }, +#endif + { 0, NULL }, +}; +#ifndef SOCK_TYPE_MASK +# define SOCK_TYPE_MASK 0xf +#endif +static const struct xlat socketlayers[] = { #if defined(SOL_IP) { SOL_IP, "SOL_IP" }, #endif @@ -237,15 +352,18 @@ static struct xlat socketlayers[] = { #if defined(SOL_ICMPV6) { SOL_ICMPV6, "SOL_ICMPV6" }, #endif +#if defined(SOL_SCTP) + { SOL_SCTP, "SOL_SCTP" }, +#endif +#if defined(SOL_UDPLITE) + { SOL_UDPLITE, "SOL_UDPLITE" }, +#endif #if defined(SOL_RAW) { SOL_RAW, "SOL_RAW" }, #endif #if defined(SOL_IPX) { SOL_IPX, "SOL_IPX" }, #endif -#if defined(SOL_IPX) - { SOL_IPX, "SOL_IPX" }, -#endif #if defined(SOL_AX25) { SOL_AX25, "SOL_AX25" }, #endif @@ -275,19 +393,62 @@ static struct xlat socketlayers[] = { #endif #if defined(SOL_IRDA) { SOL_IRDA, "SOL_IRDA" }, +#endif +#if defined(SOL_NETBEUI) + { SOL_NETBEUI, "SOL_NETBEUI" }, +#endif +#if defined(SOL_LLC) + { SOL_LLC, "SOL_LLC" }, +#endif +#if defined(SOL_DCCP) + { SOL_DCCP, "SOL_DCCP" }, +#endif +#if defined(SOL_NETLINK) + { SOL_NETLINK, "SOL_NETLINK" }, +#endif +#if defined(SOL_TIPC) + { SOL_TIPC, "SOL_TIPC" }, +#endif +#if defined(SOL_RXRPC) + { SOL_RXRPC, "SOL_RXRPC" }, +#endif +#if defined(SOL_PPPOL2TP) + { SOL_PPPOL2TP, "SOL_PPPOL2TP" }, +#endif +#if defined(SOL_BLUETOOTH) + { SOL_BLUETOOTH,"SOL_BLUETOOTH" }, +#endif +#if defined(SOL_PNPIPE) + { SOL_PNPIPE, "SOL_PNPIPE" }, +#endif +#if defined(SOL_RDS) + { SOL_RDS, "SOL_RDS" }, +#endif +#if defined(SOL_IUVC) + { SOL_IUCV, "SOL_IUCV" }, +#endif +#if defined(SOL_CAIF) + { SOL_CAIF, "SOL_CAIF" }, #endif { SOL_SOCKET, "SOL_SOCKET" }, /* Never used! */ + /* The SOL_* array should remain not NULL-terminated. */ }; /*** WARNING: DANGER WILL ROBINSON: NOTE "socketlayers" array above falls into "protocols" array below!!!! This is intended!!! ***/ -static struct xlat protocols[] = { +static const struct xlat protocols[] = { { IPPROTO_IP, "IPPROTO_IP" }, { IPPROTO_ICMP, "IPPROTO_ICMP" }, { IPPROTO_TCP, "IPPROTO_TCP" }, { IPPROTO_UDP, "IPPROTO_UDP" }, +#ifdef IPPROTO_IGMP + { IPPROTO_IGMP, "IPPROTO_IGMP" }, +#endif #ifdef IPPROTO_GGP { IPPROTO_GGP, "IPPROTO_GGP" }, #endif +#ifdef IPPROTO_IPIP + { IPPROTO_IPIP, "IPPROTO_IPIP" }, +#endif #ifdef IPPROTO_EGP { IPPROTO_EGP, "IPPROTO_EGP" }, #endif @@ -297,197 +458,272 @@ static struct xlat protocols[] = { #ifdef IPPROTO_IDP { IPPROTO_IDP, "IPPROTO_IDP" }, #endif +#ifdef IPPROTO_TP + { IPPROTO_TP, "IPPROTO_TP" }, +#endif +#ifdef IPPROTO_DCCP + { IPPROTO_DCCP, "IPPROTO_DCCP" }, +#endif #ifdef IPPROTO_IPV6 { IPPROTO_IPV6, "IPPROTO_IPV6" }, #endif +#ifdef IPPROTO_ROUTING + { IPPROTO_ROUTING, "IPPROTO_ROUTING" }, +#endif +#ifdef IPPROTO_FRAGMENT + { IPPROTO_FRAGMENT, "IPPROTO_FRAGMENT" }, +#endif +#ifdef IPPROTO_RSVP + { IPPROTO_RSVP, "IPPROTO_RSVP" }, +#endif +#ifdef IPPROTO_GRE + { IPPROTO_GRE, "IPPROTO_GRE" }, +#endif +#ifdef IPPROTO_ESP + { IPPROTO_ESP, "IPPROTO_ESP" }, +#endif +#ifdef IPPROTO_AH + { IPPROTO_AH, "IPPROTO_AH" }, +#endif #ifdef IPPROTO_ICMPV6 - { IPPROTO_ICMPV6,"IPPROTO_ICMPV6"}, + { IPPROTO_ICMPV6, "IPPROTO_ICMPV6" }, #endif -#ifdef IPPROTO_IGMP - { IPPROTO_IGMP, "IPPROTO_IGMP" }, +#ifdef IPPROTO_NONE + { IPPROTO_NONE, "IPPROTO_NONE" }, +#endif +#ifdef IPPROTO_DSTOPTS + { IPPROTO_DSTOPTS, "IPPROTO_DSTOPTS" }, #endif #ifdef IPPROTO_HELLO - { IPPROTO_HELLO,"IPPROTO_HELLO" }, + { IPPROTO_HELLO, "IPPROTO_HELLO" }, #endif #ifdef IPPROTO_ND { IPPROTO_ND, "IPPROTO_ND" }, #endif +#ifdef IPPROTO_MTP + { IPPROTO_MTP, "IPPROTO_MTP" }, +#endif +#ifdef IPPROTO_ENCAP + { IPPROTO_ENCAP, "IPPROTO_ENCAP" }, +#endif +#ifdef IPPROTO_PIM + { IPPROTO_PIM, "IPPROTO_PIM" }, +#endif +#ifdef IPPROTO_COMP + { IPPROTO_COMP, "IPPROTO_COMP" }, +#endif +#ifdef IPPROTO_SCTP + { IPPROTO_SCTP, "IPPROTO_SCTP" }, +#endif +#ifdef IPPROTO_UDPLITE + { IPPROTO_UDPLITE, "IPPROTO_UDPLITE" }, +#endif #ifdef IPPROTO_RAW { IPPROTO_RAW, "IPPROTO_RAW" }, #endif #ifdef IPPROTO_MAX { IPPROTO_MAX, "IPPROTO_MAX" }, -#endif -#ifdef IPPROTO_IPIP - { IPPROTO_IPIP, "IPPROTO_IPIP" }, #endif { 0, NULL }, }; -static struct xlat msg_flags[] = { - { MSG_OOB, "MSG_OOB" }, +static const struct xlat msg_flags[] = { + { MSG_OOB, "MSG_OOB" }, #ifdef MSG_DONTROUTE - { MSG_DONTROUTE,"MSG_DONTROUTE" }, + { MSG_DONTROUTE, "MSG_DONTROUTE" }, #endif #ifdef MSG_PEEK - { MSG_PEEK, "MSG_PEEK" }, + { MSG_PEEK, "MSG_PEEK" }, #endif #ifdef MSG_CTRUNC - { MSG_CTRUNC, "MSG_CTRUNC" }, + { MSG_CTRUNC, "MSG_CTRUNC" }, #endif #ifdef MSG_PROXY - { MSG_PROXY, "MSG_PROXY" }, + { MSG_PROXY, "MSG_PROXY" }, #endif #ifdef MSG_EOR - { MSG_EOR, "MSG_EOR" }, + { MSG_EOR, "MSG_EOR" }, #endif #ifdef MSG_WAITALL - { MSG_WAITALL, "MSG_WAITALL" }, + { MSG_WAITALL, "MSG_WAITALL" }, #endif #ifdef MSG_TRUNC - { MSG_TRUNC, "MSG_TRUNC" }, + { MSG_TRUNC, "MSG_TRUNC" }, #endif #ifdef MSG_CTRUNC - { MSG_CTRUNC, "MSG_CTRUNC" }, + { MSG_CTRUNC, "MSG_CTRUNC" }, #endif #ifdef MSG_ERRQUEUE - { MSG_ERRQUEUE, "MSG_ERRQUEUE" }, + { MSG_ERRQUEUE, "MSG_ERRQUEUE" }, #endif #ifdef MSG_DONTWAIT - { MSG_DONTWAIT, "MSG_DONTWAIT" }, + { MSG_DONTWAIT, "MSG_DONTWAIT" }, #endif #ifdef MSG_CONFIRM - { MSG_CONFIRM, "MSG_CONFIRM" }, + { MSG_CONFIRM, "MSG_CONFIRM" }, #endif #ifdef MSG_PROBE - { MSG_PROBE, "MSG_PROBE" }, + { MSG_PROBE, "MSG_PROBE" }, #endif #ifdef MSG_FIN - { MSG_FIN, "MSG_FIN" }, + { MSG_FIN, "MSG_FIN" }, #endif #ifdef MSG_SYN - { MSG_SYN, "MSG_SYN" }, + { MSG_SYN, "MSG_SYN" }, #endif #ifdef MSG_RST - { MSG_RST, "MSG_RST" }, + { MSG_RST, "MSG_RST" }, #endif #ifdef MSG_NOSIGNAL - { MSG_NOSIGNAL, "MSG_NOSIGNAL" }, + { MSG_NOSIGNAL, "MSG_NOSIGNAL" }, #endif #ifdef MSG_MORE - { MSG_MORE, "MSG_MORE" }, + { MSG_MORE, "MSG_MORE" }, #endif - { 0, NULL }, +#ifdef MSG_WAITFORONE + { MSG_WAITFORONE, "MSG_WAITFORONE" }, +#endif +#ifdef MSG_CMSG_CLOEXEC + { MSG_CMSG_CLOEXEC, "MSG_CMSG_CLOEXEC" }, +#endif + { 0, NULL }, }; -static struct xlat sockoptions[] = { -#ifdef SO_PEERCRED - { SO_PEERCRED, "SO_PEERCRED" }, +static const struct xlat sockoptions[] = { +#ifdef SO_ACCEPTCONN + { SO_ACCEPTCONN, "SO_ACCEPTCONN" }, #endif -#ifdef SO_PASSCRED - { SO_PASSCRED, "SO_PASSCRED" }, +#ifdef SO_ALLRAW + { SO_ALLRAW, "SO_ALLRAW" }, +#endif +#ifdef SO_ATTACH_FILTER + { SO_ATTACH_FILTER, "SO_ATTACH_FILTER" }, +#endif +#ifdef SO_BINDTODEVICE + { SO_BINDTODEVICE, "SO_BINDTODEVICE" }, +#endif +#ifdef SO_BROADCAST + { SO_BROADCAST, "SO_BROADCAST" }, +#endif +#ifdef SO_BSDCOMPAT + { SO_BSDCOMPAT, "SO_BSDCOMPAT" }, #endif #ifdef SO_DEBUG { SO_DEBUG, "SO_DEBUG" }, #endif -#ifdef SO_REUSEADDR - { SO_REUSEADDR, "SO_REUSEADDR" }, -#endif -#ifdef SO_KEEPALIVE - { SO_KEEPALIVE, "SO_KEEPALIVE" }, +#ifdef SO_DETACH_FILTER + { SO_DETACH_FILTER, "SO_DETACH_FILTER" }, #endif #ifdef SO_DONTROUTE { SO_DONTROUTE, "SO_DONTROUTE" }, #endif -#ifdef SO_BROADCAST - { SO_BROADCAST, "SO_BROADCAST" }, +#ifdef SO_ERROR + { SO_ERROR, "SO_ERROR" }, +#endif +#ifdef SO_ICS + { SO_ICS, "SO_ICS" }, +#endif +#ifdef SO_IMASOCKET + { SO_IMASOCKET, "SO_IMASOCKET" }, +#endif +#ifdef SO_KEEPALIVE + { SO_KEEPALIVE, "SO_KEEPALIVE" }, #endif #ifdef SO_LINGER { SO_LINGER, "SO_LINGER" }, #endif +#ifdef SO_LISTENING + { SO_LISTENING, "SO_LISTENING" }, +#endif +#ifdef SO_MGMT + { SO_MGMT, "SO_MGMT" }, +#endif +#ifdef SO_NO_CHECK + { SO_NO_CHECK, "SO_NO_CHECK" }, +#endif #ifdef SO_OOBINLINE { SO_OOBINLINE, "SO_OOBINLINE" }, #endif -#ifdef SO_TYPE - { SO_TYPE, "SO_TYPE" }, +#ifdef SO_ORDREL + { SO_ORDREL, "SO_ORDREL" }, #endif -#ifdef SO_ERROR - { SO_ERROR, "SO_ERROR" }, +#ifdef SO_PARALLELSVR + { SO_PARALLELSVR, "SO_PARALLELSVR" }, #endif -#ifdef SO_SNDBUF - { SO_SNDBUF, "SO_SNDBUF" }, +#ifdef SO_PASSCRED + { SO_PASSCRED, "SO_PASSCRED" }, #endif -#ifdef SO_RCVBUF - { SO_RCVBUF, "SO_RCVBUF" }, +#ifdef SO_PEERCRED + { SO_PEERCRED, "SO_PEERCRED" }, #endif -#ifdef SO_NO_CHECK - { SO_NO_CHECK, "SO_NO_CHECK" }, +#ifdef SO_PEERNAME + { SO_PEERNAME, "SO_PEERNAME" }, +#endif +#ifdef SO_PEERSEC + { SO_PEERSEC, "SO_PEERSEC" }, #endif #ifdef SO_PRIORITY { SO_PRIORITY, "SO_PRIORITY" }, #endif -#ifdef SO_ACCEPTCONN - { SO_ACCEPTCONN,"SO_ACCEPTCONN" }, -#endif -#ifdef SO_USELOOPBACK - { SO_USELOOPBACK,"SO_USELOOPBACK"}, +#ifdef SO_PROTOTYPE + { SO_PROTOTYPE, "SO_PROTOTYPE" }, #endif -#ifdef SO_SNDLOWAT - { SO_SNDLOWAT, "SO_SNDLOWAT" }, +#ifdef SO_RCVBUF + { SO_RCVBUF, "SO_RCVBUF" }, #endif #ifdef SO_RCVLOWAT { SO_RCVLOWAT, "SO_RCVLOWAT" }, #endif -#ifdef SO_SNDTIMEO - { SO_SNDTIMEO, "SO_SNDTIMEO" }, -#endif #ifdef SO_RCVTIMEO { SO_RCVTIMEO, "SO_RCVTIMEO" }, #endif -#ifdef SO_BSDCOMPAT - { SO_BSDCOMPAT, "SO_BSDCOMPAT" }, +#ifdef SO_RDWR + { SO_RDWR, "SO_RDWR" }, +#endif +#ifdef SO_REUSEADDR + { SO_REUSEADDR, "SO_REUSEADDR" }, #endif #ifdef SO_REUSEPORT { SO_REUSEPORT, "SO_REUSEPORT" }, #endif -#ifdef SO_ORDREL - { SO_ORDREL, "SO_ORDREL" }, -#endif -#ifdef SO_IMASOCKET - { SO_IMASOCKET, "SO_IMASOCKET" }, -#endif -#ifdef SO_MGMT - { SO_MGMT, "SO_MGMT" }, +#ifdef SO_SECURITY_AUTHENTICATION + { SO_SECURITY_AUTHENTICATION,"SO_SECURITY_AUTHENTICATION"}, #endif -#ifdef SO_LISTENING - { SO_LISTENING, "SO_LISTENING" }, +#ifdef SO_SECURITY_ENCRYPTION_NETWORK + { SO_SECURITY_ENCRYPTION_NETWORK,"SO_SECURITY_ENCRYPTION_NETWORK"}, #endif -#ifdef SO_RDWR - { SO_RDWR, "SO_RDWR" }, +#ifdef SO_SECURITY_ENCRYPTION_TRANSPORT + { SO_SECURITY_ENCRYPTION_TRANSPORT,"SO_SECURITY_ENCRYPTION_TRANSPORT"}, #endif #ifdef SO_SEMA { SO_SEMA, "SO_SEMA" }, #endif -#ifdef SO_PARALLELSVR - { SO_PARALLELSVR,"SO_PARALLELSVR"}, +#ifdef SO_SNDBUF + { SO_SNDBUF, "SO_SNDBUF" }, #endif -#ifdef SO_PROTOTYPE - { SO_PROTOTYPE, "SO_PROTOTYPE" }, +#ifdef SO_SNDLOWAT + { SO_SNDLOWAT, "SO_SNDLOWAT" }, #endif -#ifdef SO_ALLRAW - { SO_ALLRAW, "SO_ALLRAW" }, +#ifdef SO_SNDTIMEO + { SO_SNDTIMEO, "SO_SNDTIMEO" }, #endif -#ifdef SO_ICS - { SO_ICS, "SO_ICS" }, +#ifdef SO_TIMESTAMP + { SO_TIMESTAMP, "SO_TIMESTAMP" }, +#endif +#ifdef SO_TYPE + { SO_TYPE, "SO_TYPE" }, +#endif +#ifdef SO_USELOOPBACK + { SO_USELOOPBACK, "SO_USELOOPBACK" }, #endif { 0, NULL }, }; -#if !defined (SOL_IP) && defined (IPPROTO_IP) +#if !defined(SOL_IP) && defined(IPPROTO_IP) #define SOL_IP IPPROTO_IP #endif #ifdef SOL_IP -static struct xlat sockipoptions[] = { +static const struct xlat sockipoptions[] = { #ifdef IP_TOS { IP_TOS, "IP_TOS" }, #endif @@ -531,10 +767,10 @@ static struct xlat sockipoptions[] = { { IP_RECVERR, "IP_RECVERR" }, #endif #ifdef IP_RECVTTL - { IP_RECVTTL, "IP_RECRECVTTL" }, + { IP_RECVTTL, "IP_RECVTTL" }, #endif #ifdef IP_RECVTOS - { IP_RECVTOS, "IP_RECRECVTOS" }, + { IP_RECVTOS, "IP_RECVTOS" }, #endif #ifdef IP_MTU { IP_MTU, "IP_MTU" }, @@ -559,20 +795,98 @@ static struct xlat sockipoptions[] = { #endif #ifdef IP_RECVIFINDEX { IP_RECVIFINDEX, "IP_RECVIFINDEX" }, +#endif +#ifdef IP_MSFILTER + { IP_MSFILTER, "IP_MSFILTER" }, +#endif +#ifdef MCAST_MSFILTER + { MCAST_MSFILTER, "MCAST_MSFILTER" }, +#endif +#ifdef IP_FREEBIND + { IP_FREEBIND, "IP_FREEBIND" }, #endif { 0, NULL }, }; #endif /* SOL_IP */ +#ifdef SOL_IPV6 +static const struct xlat sockipv6options[] = { +#ifdef IPV6_ADDRFORM + { IPV6_ADDRFORM, "IPV6_ADDRFORM" }, +#endif +#ifdef MCAST_FILTER + { MCAST_FILTER, "MCAST_FILTER" }, +#endif +#ifdef IPV6_PKTOPTIONS + { IPV6_PKTOPTIONS, "IPV6_PKTOPTIONS" }, +#endif +#ifdef IPV6_MTU + { IPV6_MTU, "IPV6_MTU" }, +#endif +#ifdef IPV6_V6ONLY + { IPV6_V6ONLY, "IPV6_V6ONLY" }, +#endif +#ifdef IPV6_PKTINFO + { IPV6_PKTINFO, "IPV6_PKTINFO" }, +#endif +#ifdef IPV6_HOPLIMIT + { IPV6_HOPLIMIT, "IPV6_HOPLIMIT" }, +#endif +#ifdef IPV6_RTHDR + { IPV6_RTHDR, "IPV6_RTHDR" }, +#endif +#ifdef IPV6_HOPOPTS + { IPV6_HOPOPTS, "IPV6_HOPOPTS" }, +#endif +#ifdef IPV6_DSTOPTS + { IPV6_DSTOPTS, "IPV6_DSTOPTS" }, +#endif +#ifdef IPV6_FLOWINFO + { IPV6_FLOWINFO, "IPV6_FLOWINFO" }, +#endif +#ifdef IPV6_UNICAST_HOPS + { IPV6_UNICAST_HOPS, "IPV6_UNICAST_HOPS" }, +#endif +#ifdef IPV6_MULTICAST_HOPS + { IPV6_MULTICAST_HOPS, "IPV6_MULTICAST_HOPS" }, +#endif +#ifdef IPV6_MULTICAST_LOOP + { IPV6_MULTICAST_LOOP, "IPV6_MULTICAST_LOOP" }, +#endif +#ifdef IPV6_MULTICAST_IF + { IPV6_MULTICAST_IF, "IPV6_MULTICAST_IF" }, +#endif +#ifdef IPV6_MTU_DISCOVER + { IPV6_MTU_DISCOVER, "IPV6_MTU_DISCOVER" }, +#endif +#ifdef IPV6_RECVERR + { IPV6_RECVERR, "IPV6_RECVERR" }, +#endif +#ifdef IPV6_FLOWINFO_SEND + { IPV6_FLOWINFO_SEND, "IPV6_FLOWINFO_SEND" }, +#endif +#ifdef IPV6_ADD_MEMBERSHIP + { IPV6_ADD_MEMBERSHIP, "IPV6_ADD_MEMBERSHIP" }, +#endif +#ifdef IPV6_DROP_MEMBERSHIP + { IPV6_DROP_MEMBERSHIP, "IPV6_DROP_MEMBERSHIP" }, +#endif +#ifdef IPV6_ROUTER_ALERT + { IPV6_ROUTER_ALERT, "IPV6_ROUTER_ALERT" }, +#endif + { 0, NULL }, +}; +#endif /* SOL_IPV6 */ + #ifdef SOL_IPX -static struct xlat sockipxoptions[] = { - { IPX_TYPE, "IPX_TYPE" }, - { 0, NULL }, +static const struct xlat sockipxoptions[] = { + { IPX_TYPE, "IPX_TYPE" }, + { 0, NULL }, }; #endif /* SOL_IPX */ #ifdef SOL_RAW -static struct xlat sockrawoptions[] = { +static const struct xlat sockrawoptions[] = { #if defined(ICMP_FILTER) { ICMP_FILTER, "ICMP_FILTER" }, #endif @@ -581,9 +895,13 @@ static struct xlat sockrawoptions[] = { #endif /* SOL_RAW */ #ifdef SOL_PACKET -static struct xlat sockpacketoptions[] = { +static const struct xlat sockpacketoptions[] = { +#ifdef PACKET_ADD_MEMBERSHIP { PACKET_ADD_MEMBERSHIP, "PACKET_ADD_MEMBERSHIP" }, +#endif +#ifdef PACKET_DROP_MEMBERSHIP { PACKET_DROP_MEMBERSHIP, "PACKET_DROP_MEMBERSHIP"}, +#endif #if defined(PACKET_RECV_OUTPUT) { PACKET_RECV_OUTPUT, "PACKET_RECV_OUTPUT" }, #endif @@ -592,17 +910,167 @@ static struct xlat sockpacketoptions[] = { #endif #if defined(PACKET_STATISTICS) { PACKET_STATISTICS, "PACKET_STATISTICS" }, +#endif +#if defined(PACKET_COPY_THRESH) + { PACKET_COPY_THRESH, "PACKET_COPY_THRESH" }, +#endif +#if defined(PACKET_AUXDATA) + { PACKET_AUXDATA, "PACKET_AUXDATA" }, +#endif +#if defined(PACKET_ORIGDEV) + { PACKET_ORIGDEV, "PACKET_ORIGDEV" }, +#endif +#if defined(PACKET_VERSION) + { PACKET_VERSION, "PACKET_VERSION" }, +#endif +#if defined(PACKET_HDRLEN) + { PACKET_HDRLEN, "PACKET_HDRLEN" }, +#endif +#if defined(PACKET_RESERVE) + { PACKET_RESERVE, "PACKET_RESERVE" }, +#endif +#if defined(PACKET_TX_RING) + { PACKET_TX_RING, "PACKET_TX_RING" }, +#endif +#if defined(PACKET_LOSS) + { PACKET_LOSS, "PACKET_LOSS" }, #endif { 0, NULL }, }; #endif /* SOL_PACKET */ -#if !defined (SOL_TCP) && defined (IPPROTO_TCP) +#ifdef SOL_SCTP +static const struct xlat socksctpoptions[] = { +#if defined(SCTP_RTOINFO) + { SCTP_RTOINFO, "SCTP_RTOINFO" }, +#endif +#if defined(SCTP_ASSOCINFO) + { SCTP_ASSOCINFO, "SCTP_ASSOCINFO"}, +#endif +#if defined(SCTP_INITMSG) + { SCTP_INITMSG, "SCTP_INITMSG" }, +#endif +#if defined(SCTP_NODELAY) + { SCTP_NODELAY, "SCTP_NODELAY" }, +#endif +#if defined(SCTP_AUTOCLOSE) + { SCTP_AUTOCLOSE, "SCTP_AUTOCLOSE"}, +#endif +#if defined(SCTP_SET_PEER_PRIMARY_ADDR) + { SCTP_SET_PEER_PRIMARY_ADDR, "SCTP_SET_PEER_PRIMARY_ADDR"}, +#endif +#if defined(SCTP_PRIMARY_ADDR) + { SCTP_PRIMARY_ADDR, "SCTP_PRIMARY_ADDR" }, +#endif +#if defined(SCTP_ADAPTATION_LAYER) + { SCTP_ADAPTATION_LAYER, "SCTP_ADAPTATION_LAYER" }, +#endif +#if defined(SCTP_DISABLE_FRAGMENTS) + { SCTP_DISABLE_FRAGMENTS, "SCTP_DISABLE_FRAGMENTS"}, +#endif +#if defined(SCTP_PEER_ADDR_PARAMS) + { SCTP_PEER_ADDR_PARAMS, "SCTP_PEER_ADDR_PARAMS" }, +#endif +#if defined(SCTP_DEFAULT_SEND_PARAM) + { SCTP_DEFAULT_SEND_PARAM, "SCTP_DEFAULT_SEND_PARAM"}, +#endif +#if defined(SCTP_EVENTS) + { SCTP_EVENTS, "SCTP_EVENTS" }, +#endif +#if defined(SCTP_I_WANT_MAPPED_V4_ADDR) + { SCTP_I_WANT_MAPPED_V4_ADDR, "SCTP_I_WANT_MAPPED_V4_ADDR"}, +#endif +#if defined(SCTP_MAXSEG) + { SCTP_MAXSEG, "SCTP_MAXSEG" }, +#endif +#if defined(SCTP_STATUS) + { SCTP_STATUS, "SCTP_STATUS" }, +#endif +#if defined(SCTP_GET_PEER_ADDR_INFO) + { SCTP_GET_PEER_ADDR_INFO, "SCTP_GET_PEER_ADDR_INFO"}, +#endif +#if defined(SCTP_DELAYED_ACK) + { SCTP_DELAYED_ACK, "SCTP_DELAYED_ACK" }, +#endif +#if defined(SCTP_CONTEXT) + { SCTP_CONTEXT, "SCTP_CONTEXT" }, +#endif +#if defined(SCTP_FRAGMENT_INTERLEAVE) + { SCTP_FRAGMENT_INTERLEAVE, "SCTP_FRAGMENT_INTERLEAVE"}, +#endif +#if defined(SCTP_PARTIAL_DELIVERY_POINT) + { SCTP_PARTIAL_DELIVERY_POINT, "SCTP_PARTIAL_DELIVERY_POINT"}, +#endif +#if defined(SCTP_MAX_BURST) + { SCTP_MAX_BURST, "SCTP_MAX_BURST" }, +#endif +#if defined(SCTP_AUTH_CHUNK) + { SCTP_AUTH_CHUNK, "SCTP_AUTH_CHUNK" }, +#endif +#if defined(SCTP_HMAC_IDENT) + { SCTP_HMAC_IDENT, "SCTP_HMAC_IDENT" }, +#endif +#if defined(SCTP_AUTH_KEY) + { SCTP_AUTH_KEY, "SCTP_AUTH_KEY" }, +#endif +#if defined(SCTP_AUTH_ACTIVE_KEY) + { SCTP_AUTH_ACTIVE_KEY, "SCTP_AUTH_ACTIVE_KEY" }, +#endif +#if defined(SCTP_AUTH_DELETE_KEY) + { SCTP_AUTH_DELETE_KEY, "SCTP_AUTH_DELETE_KEY" }, +#endif +#if defined(SCTP_PEER_AUTH_CHUNKS) + { SCTP_PEER_AUTH_CHUNKS, "SCTP_PEER_AUTH_CHUNKS" }, +#endif +#if defined(SCTP_LOCAL_AUTH_CHUNKS) + { SCTP_LOCAL_AUTH_CHUNKS, "SCTP_LOCAL_AUTH_CHUNKS"}, +#endif +#if defined(SCTP_GET_ASSOC_NUMBER) + { SCTP_GET_ASSOC_NUMBER, "SCTP_GET_ASSOC_NUMBER" }, +#endif + + /* linux specific things */ +#if defined(SCTP_SOCKOPT_BINDX_ADD) + { SCTP_SOCKOPT_BINDX_ADD, "SCTP_SOCKOPT_BINDX_ADD" }, +#endif +#if defined(SCTP_SOCKOPT_BINDX_REM) + { SCTP_SOCKOPT_BINDX_REM, "SCTP_SOCKOPT_BINDX_REM" }, +#endif +#if defined(SCTP_SOCKOPT_PEELOFF) + { SCTP_SOCKOPT_PEELOFF, "SCTP_SOCKOPT_PEELOFF" }, +#endif +#if defined(SCTP_GET_PEER_ADDRS_NUM_OLD) + { SCTP_GET_PEER_ADDRS_NUM_OLD, "SCTP_GET_PEER_ADDRS_NUM_OLD" }, +#endif +#if defined(SCTP_GET_PEER_ADDRS_OLD) + { SCTP_GET_PEER_ADDRS_OLD, "SCTP_GET_PEER_ADDRS_OLD" }, +#endif +#if defined(SCTP_GET_LOCAL_ADDRS_NUM_OLD) + { SCTP_GET_LOCAL_ADDRS_NUM_OLD, "SCTP_GET_LOCAL_ADDRS_NUM_OLD" }, +#endif +#if defined(SCTP_GET_LOCAL_ADDRS_OLD) + { SCTP_GET_LOCAL_ADDRS_OLD, "SCTP_GET_LOCAL_ADDRS_OLD" }, +#endif +#if defined(SCTP_SOCKOPT_CONNECTX_OLD) + { SCTP_SOCKOPT_CONNECTX_OLD, "SCTP_SOCKOPT_CONNECTX_OLD" }, +#endif +#if defined(SCTP_GET_PEER_ADDRS) + { SCTP_GET_PEER_ADDRS, "SCTP_GET_PEER_ADDRS" }, +#endif +#if defined(SCTP_GET_LOCAL_ADDRS) + { SCTP_GET_LOCAL_ADDRS, "SCTP_GET_LOCAL_ADDRS" }, +#endif + + { 0, NULL }, +}; +#endif + +#if !defined(SOL_TCP) && defined(IPPROTO_TCP) #define SOL_TCP IPPROTO_TCP #endif #ifdef SOL_TCP -static struct xlat socktcpoptions[] = { +static const struct xlat socktcpoptions[] = { { TCP_NODELAY, "TCP_NODELAY" }, { TCP_MAXSEG, "TCP_MAXSEG" }, #if defined(TCP_CORK) @@ -637,13 +1105,31 @@ static struct xlat socktcpoptions[] = { #endif #if defined(TCP_QUICKACK) { TCP_QUICKACK, "TCP_QUICKACK" }, +#endif +#if defined(TCP_CONGESTION) + { TCP_CONGESTION, "TCP_CONGESTION" }, +#endif +#if defined(TCP_MD5SIG) + { TCP_MD5SIG, "TCP_MD5SIG" }, +#endif +#if defined(TCP_COOKIE_TRANSACTIONS) + { TCP_COOKIE_TRANSACTIONS, "TCP_COOKIE_TRANSACTIONS" }, +#endif +#if defined(TCP_THIN_LINEAR_TIMEOUTS) + { TCP_THIN_LINEAR_TIMEOUTS, "TCP_THIN_LINEAR_TIMEOUTS" }, +#endif +#if defined(TCP_THIN_DUPACK) + { TCP_THIN_DUPACK, "TCP_THIN_DUPACK" }, +#endif +#if defined(TCP_USER_TIMEOUT) + { TCP_USER_TIMEOUT, "TCP_USER_TIMEOUT" }, #endif { 0, NULL }, }; #endif /* SOL_TCP */ #ifdef SOL_RAW -static struct xlat icmpfilterflags[] = { +static const struct xlat icmpfilterflags[] = { #if defined(ICMP_ECHOREPLY) { (1<sizeof(addrbuf))) - addrlen=sizeof(addrbuf); - if (umoven(tcp, addr, addrlen, (char*)&addrbuf) < 0) { - tprintf("{...}"); + if (addrlen < 2 || addrlen > sizeof(addrbuf)) + addrlen = sizeof(addrbuf); + + memset(&addrbuf, 0, sizeof(addrbuf)); + if (umoven(tcp, addr, addrlen, addrbuf.pad) < 0) { + tprints("{...}"); return; } + addrbuf.pad[sizeof(addrbuf.pad) - 1] = '\0'; - tprintf("{sa_family="); + tprints("{sa_family="); printxval(addrfams, addrbuf.sa.sa_family, "AF_???"); - tprintf(", "); + tprints(", "); switch (addrbuf.sa.sa_family) { case AF_UNIX: - if (addrlen==2) { - tprintf(""); + if (addrlen == 2) { + tprints("NULL"); } else if (addrbuf.sau.sun_path[0]) { - tprintf("path=\"%-.*s\"", addrlen-2, addrbuf.sau.sun_path); + tprints("sun_path="); + printpathn(tcp, addr + 2, strlen(addrbuf.sau.sun_path)); } else { - tprintf("path=@%-.*s", addrlen-3, addrbuf.sau.sun_path+1); + tprints("sun_path=@"); + printpathn(tcp, addr + 3, strlen(addrbuf.sau.sun_path + 1)); } break; case AF_INET: @@ -784,26 +1271,26 @@ int addrlen; #ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID { #if defined(HAVE_IF_INDEXTONAME) && defined(IN6_IS_ADDR_LINKLOCAL) && defined(IN6_IS_ADDR_MC_LINKLOCAL) - int numericscope = 0; - if (IN6_IS_ADDR_LINKLOCAL (&addrbuf.sa6.sin6_addr) - || IN6_IS_ADDR_MC_LINKLOCAL (&addrbuf.sa6.sin6_addr)) { - char scopebuf[IFNAMSIZ + 1]; + int numericscope = 0; + if (IN6_IS_ADDR_LINKLOCAL(&addrbuf.sa6.sin6_addr) + || IN6_IS_ADDR_MC_LINKLOCAL(&addrbuf.sa6.sin6_addr)) { + char scopebuf[IFNAMSIZ + 1]; - if (if_indextoname (addrbuf.sa6.sin6_scope_id, scopebuf) == NULL) - numericscope++; - else - tprintf(", sin6_scope_id=if_nametoindex(\"%s\")", scopebuf); - } else - numericscope++; + if (if_indextoname(addrbuf.sa6.sin6_scope_id, scopebuf) == NULL) + numericscope++; + else + tprintf(", sin6_scope_id=if_nametoindex(\"%s\")", scopebuf); + } else + numericscope++; - if (numericscope) + if (numericscope) #endif - tprintf(", sin6_scope_id=%u", addrbuf.sa6.sin6_scope_id); + tprintf(", sin6_scope_id=%u", addrbuf.sa6.sin6_scope_id); } #endif - break; + break; #endif -#if defined(AF_IPX) && defined(linux) +#if defined(AF_IPX) case AF_IPX: { int i; @@ -816,12 +1303,12 @@ int addrlen; * this way.. :) */ tprintf("%08lx:", (unsigned long)ntohl(addrbuf.sipx.sipx_network)); - for (i = 0; icmsg_len) ? len : cmsg->cmsg_len; + + if (cmsg->cmsg_type == SCM_RIGHTS + && CMSG_LEN(sizeof(int)) <= cmsg_len) { + int *fds = (int *) CMSG_DATA(cmsg); + int first = 1; + + tprints(", {"); + while ((char *) fds < ((char *) cmsg + cmsg_len)) { + if (!first) + tprints(", "); + tprintf("%d", *fds++); + first = 0; + } + tprints("}}"); + free(cmsg); + return; + } + if (cmsg->cmsg_type == SCM_CREDENTIALS + && CMSG_LEN(sizeof(struct ucred)) <= cmsg_len) { + struct ucred *uc = (struct ucred *) CMSG_DATA(cmsg); + + tprintf("{pid=%ld, uid=%ld, gid=%ld}}", + (long)uc->pid, (long)uc->uid, (long)uc->gid); + free(cmsg); + return; + } } - tprintf("}"); + free(cmsg); + tprints(", ...}"); } -#if HAVE_SENDMSG +static void +do_msghdr(struct tcb *tcp, struct msghdr *msg, unsigned long data_size) +{ + tprintf("{msg_name(%d)=", msg->msg_namelen); + printsock(tcp, (long)msg->msg_name, msg->msg_namelen); + + tprintf(", msg_iov(%lu)=", (unsigned long)msg->msg_iovlen); + tprint_iov_upto(tcp, (unsigned long)msg->msg_iovlen, + (unsigned long)msg->msg_iov, 1, data_size); + +#ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL + tprintf(", msg_controllen=%lu", (unsigned long)msg->msg_controllen); + if (msg->msg_controllen) + printcmsghdr(tcp, (unsigned long) msg->msg_control, + msg->msg_controllen); + tprints(", msg_flags="); + printflags(msg_flags, msg->msg_flags, "MSG_???"); +#else /* !HAVE_STRUCT_MSGHDR_MSG_CONTROL */ + tprintf("msg_accrights=%#lx, msg_accrightslen=%u", + (unsigned long) msg->msg_accrights, msg->msg_accrightslen); +#endif /* !HAVE_STRUCT_MSGHDR_MSG_CONTROL */ + tprints("}"); +} static void -printmsghdr(tcp, addr) -struct tcb *tcp; -long addr; +printmsghdr(struct tcb *tcp, long addr, unsigned long data_size) { struct msghdr msg; @@ -869,37 +1438,80 @@ long addr; tprintf("%#lx", addr); return; } - tprintf("{msg_name(%d)=", msg.msg_namelen); - printsock(tcp, (long)msg.msg_name, msg.msg_namelen); + do_msghdr(tcp, &msg, data_size); +} - tprintf(", msg_iov(%lu)=", (unsigned long)msg.msg_iovlen); - tprint_iov(tcp, msg.msg_iovlen, (long) msg.msg_iov); +static void +printmmsghdr(struct tcb *tcp, long addr, unsigned int idx) +{ + struct mmsghdr { + struct msghdr msg_hdr; + unsigned msg_len; + } mmsg; -#ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL - tprintf(", msg_controllen=%lu", (unsigned long)msg.msg_controllen); - if (msg.msg_controllen) - tprintf(", msg_control=%#lx, ", (unsigned long) msg.msg_control); - tprintf(", msg_flags="); - if (printflags(msg_flags, msg.msg_flags)==0) - tprintf("0"); -#else /* !HAVE_STRUCT_MSGHDR_MSG_CONTROL */ - tprintf("msg_accrights=%#lx, msg_accrightslen=%u", - (unsigned long) msg.msg_accrights, msg.msg_accrightslen); -#endif /* !HAVE_STRUCT_MSGHDR_MSG_CONTROL */ - tprintf("}"); + addr += sizeof(mmsg) * idx; + if (umove(tcp, addr, &mmsg) < 0) { + tprintf("%#lx", addr); + return; + } + tprints("{"); + do_msghdr(tcp, &mmsg.msg_hdr, ULONG_MAX); + tprintf(", %u}", mmsg.msg_len); +} + +static void +decode_mmsg(struct tcb *tcp) +{ + /* mmsgvec */ + if (syserror(tcp)) { + tprintf("%#lx", tcp->u_arg[1]); + } else { + unsigned int len = tcp->u_rval; + unsigned int i; + + tprints("{"); + for (i = 0; i < len; ++i) { + if (i) + tprints(", "); + printmmsghdr(tcp, tcp->u_arg[1], i); + } + tprints("}"); + } + /* vlen */ + tprintf(", %u, ", (unsigned int) tcp->u_arg[2]); + /* flags */ + printflags(msg_flags, tcp->u_arg[3], "MSG_???"); } #endif /* HAVE_SENDMSG */ +/* + * low bits of the socket type define real socket type, + * other bits are socket type flags. + */ +static void +tprint_sock_type(struct tcb *tcp, int flags) +{ + const char *str = xlookup(socktypes, flags & SOCK_TYPE_MASK); + + if (str) { + tprints(str); + flags &= ~SOCK_TYPE_MASK; + if (!flags) + return; + tprints("|"); + } + printflags(sock_type_flags, flags, "SOCK_???"); +} + int -sys_socket(tcp) -struct tcb *tcp; +sys_socket(struct tcb *tcp) { if (entering(tcp)) { printxval(domains, tcp->u_arg[0], "PF_???"); - tprintf(", "); - printxval(socktypes, tcp->u_arg[1], "SOCK_???"); - tprintf(", "); + tprints(", "); + tprint_sock_type(tcp, tcp->u_arg[1]); + tprints(", "); switch (tcp->u_arg[0]) { case PF_INET: #ifdef PF_INET6 @@ -910,9 +1522,9 @@ struct tcb *tcp; #ifdef PF_IPX case PF_IPX: /* BTW: I don't believe this.. */ - tprintf("["); + tprints("["); printxval(domains, tcp->u_arg[2], "PF_???"); - tprintf("]"); + tprints("]"); break; #endif /* PF_IPX */ default: @@ -924,35 +1536,7 @@ struct tcb *tcp; } int -sys_so_socket(tcp) -struct tcb *tcp; -{ - if (entering(tcp)) { - /* not sure really what these args are... but this - * is how truss prints it - */ - tprintf("%ld, %ld, %ld, ", - tcp->u_arg[0], tcp->u_arg[1], tcp->u_arg[2]); - printpath(tcp, tcp->u_arg[3]); - tprintf(", %ld", tcp->u_arg[4]); - } - return 0; -} - -int -sys_so_socketpair(tcp) -struct tcb *tcp; -{ - if (entering(tcp)) { - /* not sure what this arg is */ - tprintf("0x%lx", tcp->u_arg[0]); - } - return 0; -} - -int -sys_bind(tcp) -struct tcb *tcp; +sys_bind(struct tcb *tcp) { if (entering(tcp)) { tprintf("%ld, ", tcp->u_arg[0]); @@ -963,15 +1547,13 @@ struct tcb *tcp; } int -sys_connect(tcp) -struct tcb *tcp; +sys_connect(struct tcb *tcp) { return sys_bind(tcp); } int -sys_listen(tcp) -struct tcb *tcp; +sys_listen(struct tcb *tcp) { if (entering(tcp)) { tprintf("%ld, %lu", tcp->u_arg[0], tcp->u_arg[1]); @@ -979,54 +1561,70 @@ struct tcb *tcp; return 0; } -int -sys_accept(tcp) -struct tcb *tcp; +static int +do_accept(struct tcb *tcp, int flags_arg) { if (entering(tcp)) { tprintf("%ld, ", tcp->u_arg[0]); - } else if (!tcp->u_arg[2]) + return 0; + } + if (!tcp->u_arg[2]) tprintf("%#lx, NULL", tcp->u_arg[1]); else { - if (tcp->u_arg[1] == 0 || syserror(tcp)) { + int len; + if (tcp->u_arg[1] == 0 || syserror(tcp) + || umove(tcp, tcp->u_arg[2], &len) < 0) { tprintf("%#lx", tcp->u_arg[1]); } else { - printsock(tcp, tcp->u_arg[1], tcp->u_arg[2]); + printsock(tcp, tcp->u_arg[1], len); } - tprintf(", "); - printnum(tcp, tcp->u_arg[2], "%lu"); + tprints(", "); + printnum_int(tcp, tcp->u_arg[2], "%u"); + } + if (flags_arg >= 0) { + tprints(", "); + printflags(sock_type_flags, tcp->u_arg[flags_arg], + "SOCK_???"); } return 0; } int -sys_send(tcp) -struct tcb *tcp; +sys_accept(struct tcb *tcp) +{ + return do_accept(tcp, -1); +} + +int +sys_accept4(struct tcb *tcp) +{ + return do_accept(tcp, 3); +} + +int +sys_send(struct tcb *tcp) { if (entering(tcp)) { tprintf("%ld, ", tcp->u_arg[0]); printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]); tprintf(", %lu, ", tcp->u_arg[2]); /* flags */ - if (printflags(msg_flags, tcp->u_arg[3]) == 0) - tprintf("0"); + printflags(msg_flags, tcp->u_arg[3], "MSG_???"); } return 0; } int -sys_sendto(tcp) -struct tcb *tcp; +sys_sendto(struct tcb *tcp) { if (entering(tcp)) { tprintf("%ld, ", tcp->u_arg[0]); printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]); tprintf(", %lu, ", tcp->u_arg[2]); /* flags */ - if (printflags(msg_flags, tcp->u_arg[3]) == 0) - tprintf("0"); + printflags(msg_flags, tcp->u_arg[3], "MSG_???"); /* to address */ - tprintf(", "); + tprints(", "); printsock(tcp, tcp->u_arg[4], tcp->u_arg[5]); /* to length */ tprintf(", %lu", tcp->u_arg[5]); @@ -1037,16 +1635,32 @@ struct tcb *tcp; #ifdef HAVE_SENDMSG int -sys_sendmsg(tcp) -struct tcb *tcp; +sys_sendmsg(struct tcb *tcp) { if (entering(tcp)) { tprintf("%ld, ", tcp->u_arg[0]); - printmsghdr(tcp, tcp->u_arg[1]); + printmsghdr(tcp, tcp->u_arg[1], ULONG_MAX); /* flags */ - tprintf(", "); - if (printflags(msg_flags, tcp->u_arg[2]) == 0) - tprintf("0"); + tprints(", "); + printflags(msg_flags, tcp->u_arg[2], "MSG_???"); + } + return 0; +} + +int +sys_sendmmsg(struct tcb *tcp) +{ + if (entering(tcp)) { + /* sockfd */ + tprintf("%d, ", (int) tcp->u_arg[0]); + if (!verbose(tcp)) { + tprintf("%#lx, %u, ", + tcp->u_arg[1], (unsigned int) tcp->u_arg[2]); + printflags(msg_flags, tcp->u_arg[3], "MSG_???"); + } + } else { + if (verbose(tcp)) + decode_mmsg(tcp); } return 0; } @@ -1054,8 +1668,7 @@ struct tcb *tcp; #endif /* HAVE_SENDMSG */ int -sys_recv(tcp) -struct tcb *tcp; +sys_recv(struct tcb *tcp) { if (entering(tcp)) { tprintf("%ld, ", tcp->u_arg[0]); @@ -1066,15 +1679,13 @@ struct tcb *tcp; printstr(tcp, tcp->u_arg[1], tcp->u_rval); tprintf(", %lu, ", tcp->u_arg[2]); - if (printflags(msg_flags, tcp->u_arg[3]) == 0) - tprintf("0"); + printflags(msg_flags, tcp->u_arg[3], "MSG_???"); } return 0; } int -sys_recvfrom(tcp) -struct tcb *tcp; +sys_recvfrom(struct tcb *tcp) { int fromlen; @@ -1092,25 +1703,24 @@ struct tcb *tcp; /* len */ tprintf(", %lu, ", tcp->u_arg[2]); /* flags */ - if (printflags(msg_flags, tcp->u_arg[3]) == 0) - tprintf("0"); + printflags(msg_flags, tcp->u_arg[3], "MSG_???"); /* from address, len */ if (!tcp->u_arg[4] || !tcp->u_arg[5]) { if (tcp->u_arg[4] == 0) - tprintf(", NULL"); + tprints(", NULL"); else tprintf(", %#lx", tcp->u_arg[4]); if (tcp->u_arg[5] == 0) - tprintf(", NULL"); + tprints(", NULL"); else tprintf(", %#lx", tcp->u_arg[5]); return 0; } if (umove(tcp, tcp->u_arg[5], &fromlen) < 0) { - tprintf(", {...}, [?]"); + tprints(", {...}, [?]"); return 0; } - tprintf(", "); + tprints(", "); printsock(tcp, tcp->u_arg[4], tcp->u_arg[5]); /* from length */ tprintf(", [%u]", fromlen); @@ -1121,8 +1731,7 @@ struct tcb *tcp; #ifdef HAVE_SENDMSG int -sys_recvmsg(tcp) -struct tcb *tcp; +sys_recvmsg(struct tcb *tcp) { if (entering(tcp)) { tprintf("%ld, ", tcp->u_arg[0]); @@ -1130,90 +1739,139 @@ struct tcb *tcp; if (syserror(tcp) || !verbose(tcp)) tprintf("%#lx", tcp->u_arg[1]); else - printmsghdr(tcp, tcp->u_arg[1]); + printmsghdr(tcp, tcp->u_arg[1], tcp->u_rval); /* flags */ - tprintf(", "); - if (printflags(msg_flags, tcp->u_arg[2]) == 0) - tprintf("0"); + tprints(", "); + printflags(msg_flags, tcp->u_arg[2], "MSG_???"); } return 0; } +int +sys_recvmmsg(struct tcb *tcp) +{ + /* +5 chars are for "left " prefix */ + static char str[5 + TIMESPEC_TEXT_BUFSIZE]; + + if (entering(tcp)) { + tprintf("%ld, ", tcp->u_arg[0]); + if (verbose(tcp)) { + sprint_timespec(str, tcp, tcp->u_arg[4]); + /* Abusing tcp->auxstr as temp storage. + * Will be used and freed on syscall exit. + */ + tcp->auxstr = strdup(str); + } else { + tprintf("%#lx, %ld, ", tcp->u_arg[1], tcp->u_arg[2]); + printflags(msg_flags, tcp->u_arg[3], "MSG_???"); + tprints(", "); + print_timespec(tcp, tcp->u_arg[4]); + } + return 0; + } else { + if (verbose(tcp)) { + decode_mmsg(tcp); + /* timeout on entrance */ + tprintf(", %s", tcp->auxstr ? tcp->auxstr : "{...}"); + free((void *) tcp->auxstr); + tcp->auxstr = NULL; + } + if (syserror(tcp)) + return 0; + if (tcp->u_rval == 0) { + tcp->auxstr = "Timeout"; + return RVAL_STR; + } + if (!verbose(tcp)) + return 0; + /* timeout on exit */ + sprint_timespec(stpcpy(str, "left "), tcp, tcp->u_arg[4]); + tcp->auxstr = str; + return RVAL_STR; + } +} + #endif /* HAVE_SENDMSG */ +static const struct xlat shutdown_modes[] = { + { 0, "SHUT_RD" }, + { 1, "SHUT_WR" }, + { 2, "SHUT_RDWR" }, + { 0, NULL } +}; + int -sys_shutdown(tcp) -struct tcb *tcp; +sys_shutdown(struct tcb *tcp) { if (entering(tcp)) { - tprintf("%ld, %ld", tcp->u_arg[0], tcp->u_arg[1]); - switch (tcp->u_arg[1]) { - case 0: - tprintf("%s", " /* receive */"); - break; - case 1: - tprintf("%s", " /* send */"); - break; - case 2: - tprintf("%s", " /* send and receive */"); - break; - } + tprintf("%ld, ", tcp->u_arg[0]); + printxval(shutdown_modes, tcp->u_arg[1], "SHUT_???"); } return 0; } int -sys_getsockname(tcp) -struct tcb *tcp; +sys_getsockname(struct tcb *tcp) { return sys_accept(tcp); } int -sys_getpeername(tcp) -struct tcb *tcp; +sys_getpeername(struct tcb *tcp) { return sys_accept(tcp); } -int -sys_pipe(tcp) -struct tcb *tcp; +static int +do_pipe(struct tcb *tcp, int flags_arg) { - -#if defined(LINUX) && !defined(SPARC) && !defined(SH) && !defined(IA64) - int fds[2]; - if (exiting(tcp)) { if (syserror(tcp)) { tprintf("%#lx", tcp->u_arg[0]); - return 0; + } else { +#if !defined(SPARC) && !defined(SPARC64) && !defined(SH) && !defined(IA64) + int fds[2]; + + if (umoven(tcp, tcp->u_arg[0], sizeof fds, (char *) fds) < 0) + tprints("[...]"); + else + tprintf("[%u, %u]", fds[0], fds[1]); +#elif defined(SPARC) || defined(SPARC64) || defined(SH) || defined(IA64) + tprintf("[%lu, %lu]", tcp->u_rval, getrval2(tcp)); +#else + tprintf("%#lx", tcp->u_arg[0]); +#endif + } + if (flags_arg >= 0) { + tprints(", "); + printflags(open_mode_flags, tcp->u_arg[flags_arg], "O_???"); } - if (umoven(tcp, tcp->u_arg[0], sizeof fds, (char *) fds) < 0) - tprintf("[...]"); - else - tprintf("[%u, %u]", fds[0], fds[1]); } -#elif defined(SPARC) || defined(SH) || defined(SVR4) || defined(FREEBSD) || defined(IA64) - if (exiting(tcp)) - tprintf("[%lu, %lu]", tcp->u_rval, getrval2(tcp)); -#endif return 0; } int -sys_socketpair(tcp) -struct tcb *tcp; +sys_pipe(struct tcb *tcp) +{ + return do_pipe(tcp, -1); +} + +int +sys_pipe2(struct tcb *tcp) +{ + return do_pipe(tcp, 1); +} + +int +sys_socketpair(struct tcb *tcp) { -#ifdef LINUX int fds[2]; -#endif if (entering(tcp)) { printxval(domains, tcp->u_arg[0], "PF_???"); - tprintf(", "); - printxval(socktypes, tcp->u_arg[1], "SOCK_???"); - tprintf(", "); + tprints(", "); + tprint_sock_type(tcp, tcp->u_arg[1]); + tprints(", "); switch (tcp->u_arg[0]) { case PF_INET: printxval(protocols, tcp->u_arg[2], "IPPROTO_???"); @@ -1221,9 +1879,9 @@ struct tcb *tcp; #ifdef PF_IPX case PF_IPX: /* BTW: I don't believe this.. */ - tprintf("["); + tprints("["); printxval(domains, tcp->u_arg[2], "PF_???"); - tprintf("]"); + tprints("]"); break; #endif /* PF_IPX */ default: @@ -1235,27 +1893,21 @@ struct tcb *tcp; tprintf(", %#lx", tcp->u_arg[3]); return 0; } -#ifdef LINUX if (umoven(tcp, tcp->u_arg[3], sizeof fds, (char *) fds) < 0) - tprintf(", [...]"); + tprints(", [...]"); else tprintf(", [%u, %u]", fds[0], fds[1]); -#endif /* LINUX */ -#if defined(SUNOS4) || defined(SVR4) || defined(FREEBSD) - tprintf(", [%lu, %lu]", tcp->u_rval, getrval2(tcp)); -#endif /* SUNOS4 || SVR4 || FREEBSD */ } return 0; } int -sys_getsockopt(tcp) -struct tcb *tcp; +sys_getsockopt(struct tcb *tcp) { if (entering(tcp)) { tprintf("%ld, ", tcp->u_arg[0]); printxval(socketlayers, tcp->u_arg[1], "SOL_???"); - tprintf (", "); + tprints(", "); switch (tcp->u_arg[1]) { case SOL_SOCKET: printxval(sockoptions, tcp->u_arg[2], "SO_???"); @@ -1265,6 +1917,11 @@ struct tcb *tcp; printxval(sockipoptions, tcp->u_arg[2], "IP_???"); break; #endif +#ifdef SOL_IPV6 + case SOL_IPV6: + printxval(sockipv6options, tcp->u_arg[2], "IPV6_???"); + break; +#endif #ifdef SOL_IPX case SOL_IPX: printxval(sockipxoptions, tcp->u_arg[2], "IPX_???"); @@ -1280,6 +1937,11 @@ struct tcb *tcp; printxval(socktcpoptions, tcp->u_arg[2], "TCP_???"); break; #endif +#ifdef SOL_SCTP + case SOL_SCTP: + printxval(socksctpoptions, tcp->u_arg[2], "SCTP_???"); + break; +#endif /* SOL_AX25 SOL_ROSE SOL_ATALK SOL_NETROM SOL_UDP SOL_DECNET SOL_X25 * etc. still need work */ @@ -1287,10 +1949,11 @@ struct tcb *tcp; tprintf("%lu", tcp->u_arg[2]); break; } + tprints(", "); } else { - long len; - if (syserror(tcp) || umove (tcp, tcp->u_arg[4], &len) < 0) { - tprintf(", %#lx, %#lx", + int len; + if (syserror(tcp) || umove(tcp, tcp->u_arg[4], &len) < 0) { + tprintf("%#lx, %#lx", tcp->u_arg[3], tcp->u_arg[4]); return 0; } @@ -1300,46 +1963,82 @@ struct tcb *tcp; switch (tcp->u_arg[2]) { #ifdef SO_LINGER case SO_LINGER: - if (len == sizeof (struct linger)) { + if (len == sizeof(struct linger)) { struct linger linger; - if (umove (tcp, + if (umove(tcp, tcp->u_arg[3], &linger) < 0) break; - tprintf(", {onoff=%d, linger=%d}, " - "[%ld]", + tprintf("{onoff=%d, linger=%d}, " + "[%d]", linger.l_onoff, linger.l_linger, len); return 0; } break; +#endif +#ifdef SO_PEERCRED + case SO_PEERCRED: + if (len == sizeof(struct ucred)) { + struct ucred uc; + if (umove(tcp, + tcp->u_arg[3], + &uc) < 0) + break; + tprintf("{pid=%ld, uid=%ld, gid=%ld}, " + "[%d]", + (long)uc.pid, + (long)uc.uid, + (long)uc.gid, + len); + return 0; + } + break; +#endif + } + break; + case SOL_PACKET: + switch (tcp->u_arg[2]) { +#ifdef PACKET_STATISTICS + case PACKET_STATISTICS: + if (len == sizeof(struct tpacket_stats)) { + struct tpacket_stats stats; + if (umove(tcp, + tcp->u_arg[3], + &stats) < 0) + break; + tprintf("{packets=%u, drops=%u}, " + "[%d]", + stats.tp_packets, + stats.tp_drops, + len); + return 0; + } + break; #endif } break; } - tprintf (", "); - if (len == sizeof (int)) { - printnum(tcp, tcp->u_arg[3], "%ld"); + if (len == sizeof(int)) { + printnum_int(tcp, tcp->u_arg[3], "%d"); } else { - printstr (tcp, tcp->u_arg[3], len); + printstr(tcp, tcp->u_arg[3], len); } - tprintf(", [%ld]", len); + tprintf(", [%d]", len); } return 0; } #if defined(ICMP_FILTER) -static void printicmpfilter(tcp, addr) -struct tcb *tcp; -long addr; +static void printicmpfilter(struct tcb *tcp, long addr) { struct icmp_filter filter; if (!addr) { - tprintf("NULL"); + tprints("NULL"); return; } if (syserror(tcp) || !verbose(tcp)) { @@ -1347,36 +2046,30 @@ long addr; return; } if (umove(tcp, addr, &filter) < 0) { - tprintf("{...}"); + tprints("{...}"); return; } - tprintf("~("); - if (printflags(icmpfilterflags, ~filter.data) == 0) - tprintf("0"); - tprintf(")"); + tprints("~("); + printflags(icmpfilterflags, ~filter.data, "ICMP_???"); + tprints(")"); } #endif /* ICMP_FILTER */ static int -printsockopt (tcp, level, name, addr, len) -struct tcb *tcp; -int level; -int name; -long addr; -int len; +printsockopt(struct tcb *tcp, int level, int name, long addr, int len) { printxval(socketlayers, level, "SOL_??"); - tprintf (", "); + tprints(", "); switch (level) { - case SOL_SOCKET: + case SOL_SOCKET: printxval(sockoptions, name, "SO_???"); switch (name) { #if defined(SO_LINGER) - case SO_LINGER: - if (len == sizeof (struct linger)) { + case SO_LINGER: + if (len == sizeof(struct linger)) { struct linger linger; - if (umove (tcp, addr, &linger) < 0) + if (umove(tcp, addr, &linger) < 0) break; tprintf(", {onoff=%d, linger=%d}", linger.l_onoff, @@ -1388,35 +2081,67 @@ int len; } break; #ifdef SOL_IP - case SOL_IP: + case SOL_IP: printxval(sockipoptions, name, "IP_???"); break; #endif +#ifdef SOL_IPV6 + case SOL_IPV6: + printxval(sockipv6options, name, "IPV6_???"); + break; +#endif #ifdef SOL_IPX - case SOL_IPX: + case SOL_IPX: printxval(sockipxoptions, name, "IPX_???"); break; #endif #ifdef SOL_PACKET - case SOL_PACKET: + case SOL_PACKET: printxval(sockpacketoptions, name, "PACKET_???"); /* TODO: decode packate_mreq for PACKET_*_MEMBERSHIP */ + switch (name) { +#ifdef PACKET_RX_RING + case PACKET_RX_RING: +#endif +#ifdef PACKET_TX_RING + case PACKET_TX_RING: +#endif +#if defined(PACKET_RX_RING) || defined(PACKET_TX_RING) + if (len == sizeof(struct tpacket_req)) { + struct tpacket_req req; + if (umove(tcp, addr, &req) < 0) + break; + tprintf(", {block_size=%u, block_nr=%u, frame_size=%u, frame_nr=%u}", + req.tp_block_size, + req.tp_block_nr, + req.tp_frame_size, + req.tp_frame_nr); + return 0; + } + break; +#endif /* PACKET_RX_RING || PACKET_TX_RING */ + } break; #endif #ifdef SOL_TCP - case SOL_TCP: + case SOL_TCP: printxval(socktcpoptions, name, "TCP_???"); break; #endif +#ifdef SOL_SCTP + case SOL_SCTP: + printxval(socksctpoptions, name, "SCTP_???"); + break; +#endif #ifdef SOL_RAW - case SOL_RAW: + case SOL_RAW: printxval(sockrawoptions, name, "RAW_???"); switch (name) { #if defined(ICMP_FILTER) - case ICMP_FILTER: - tprintf(", "); - printicmpfilter(tcp, addr); - return 0; + case ICMP_FILTER: + tprints(", "); + printicmpfilter(tcp, addr); + return 0; #endif } break; @@ -1425,31 +2150,27 @@ int len; /* SOL_AX25 SOL_ATALK SOL_NETROM SOL_UDP SOL_DECNET SOL_X25 * etc. still need work */ - default: + default: tprintf("%u", name); } /* default arg printing */ - tprintf (", "); + tprints(", "); - if (len == sizeof (int)) { - printnum(tcp, addr, "%ld"); + if (len == sizeof(int)) { + printnum_int(tcp, addr, "%d"); } else { - printstr (tcp, addr, len); + printstr(tcp, addr, len); } return 0; } - #ifdef HAVE_STRUCT_OPTHDR void -print_sock_optmgmt (tcp, addr, len) -struct tcb *tcp; -long addr; -int len; +print_sock_optmgmt(struct tcb *tcp, long addr, int len) { int c = 0; struct opthdr hdr; @@ -1457,193 +2178,38 @@ int len; while (len >= (int) sizeof hdr) { if (umove(tcp, addr, &hdr) < 0) break; if (c++) { - tprintf (", "); + tprints(", "); } else if (len > hdr.len + sizeof hdr) { - tprintf ("["); + tprints("["); } - tprintf ("{"); + tprints("{"); addr += sizeof hdr; len -= sizeof hdr; - printsockopt (tcp, hdr.level, hdr.name, addr, hdr.len); + printsockopt(tcp, hdr.level, hdr.name, addr, hdr.len); if (hdr.len > 0) { addr += hdr.len; len -= hdr.len; } - tprintf ("}"); + tprints("}"); } if (len > 0) { - if (c++) tprintf (", "); - printstr (tcp, addr, len); + if (c++) tprints(", "); + printstr(tcp, addr, len); } - if (c > 1) tprintf ("]"); + if (c > 1) tprints("]"); } #endif int -sys_setsockopt(tcp) -struct tcb *tcp; +sys_setsockopt(struct tcb *tcp) { if (entering(tcp)) { tprintf("%ld, ", tcp->u_arg[0]); - printsockopt (tcp, tcp->u_arg[1], tcp->u_arg[2], + printsockopt(tcp, tcp->u_arg[1], tcp->u_arg[2], tcp->u_arg[3], tcp->u_arg[4]); tprintf(", %lu", tcp->u_arg[4]); } return 0; } - -#if UNIXWARE >= 7 - -static struct xlat sock_version[] = { - { __NETLIB_UW211_SVR4, "UW211_SVR4" }, - { __NETLIB_UW211_XPG4, "UW211_XPG4" }, - { __NETLIB_GEMINI_SVR4, "GEMINI_SVR4" }, - { __NETLIB_GEMINI_XPG4, "GEMINI_XPG4" }, - { __NETLIB_FP1_SVR4, "FP1_SVR4" }, - { __NETLIB_FP1_XPG4, "FP1_XPG4" }, - { 0, NULL }, -}; - - -int -netlib_call(tcp, func) -struct tcb *tcp; -int (*func) (); -{ - if (entering(tcp)) { - int i; - printxval (sock_version, tcp->u_arg[0], "__NETLIB_???"); - tprintf(", "); - --tcp->u_nargs; - for (i = 0; i < tcp->u_nargs; i++) - tcp->u_arg[i] = tcp->u_arg[i + 1]; - return func (tcp); - - } - - return func (tcp); -} - -int -sys_xsocket(tcp) -struct tcb *tcp; -{ - return netlib_call (tcp, sys_socket); -} - -int -sys_xsocketpair(tcp) -struct tcb *tcp; -{ - return netlib_call (tcp, sys_socketpair); -} - -int -sys_xbind(tcp) -struct tcb *tcp; -{ - return netlib_call (tcp, sys_bind); -} - -int -sys_xconnect(tcp) -struct tcb *tcp; -{ - return netlib_call (tcp, sys_connect); -} - -int -sys_xlisten(tcp) -struct tcb *tcp; -{ - return netlib_call (tcp, sys_listen); -} - -int -sys_xaccept(tcp) -struct tcb *tcp; -{ - return netlib_call (tcp, sys_accept); -} - -int -sys_xsendmsg(tcp) -struct tcb *tcp; -{ - return netlib_call (tcp, sys_sendmsg); -} - -int -sys_xrecvmsg(tcp) -struct tcb *tcp; -{ - return netlib_call (tcp, sys_recvmsg); -} - -int -sys_xgetsockaddr(tcp) -struct tcb *tcp; -{ - if (entering(tcp)) { - printxval (sock_version, tcp->u_arg[0], "__NETLIB_???"); - tprintf(", "); - if (tcp->u_arg[1] == 0) { - tprintf ("LOCALNAME, "); - } - else if (tcp->u_arg[1] == 1) { - tprintf ("REMOTENAME, "); - } - else { - tprintf ("%ld, ", tcp->u_arg [1]); - } - tprintf ("%ld, ", tcp->u_arg [2]); - } - else { - if (tcp->u_arg[3] == 0 || syserror(tcp)) { - tprintf("%#lx", tcp->u_arg[3]); - } else { - printsock(tcp, tcp->u_arg[3], tcp->u_arg[4]); - } - tprintf(", "); - printnum(tcp, tcp->u_arg[4], "%lu"); - } - - return 0; - -} - -#if 0 - -int -sys_xsetsockaddr(tcp) -struct tcb *tcp; -{ - return netlib_call (tcp, sys_setsockaddr); -} - -#endif - -int -sys_xgetsockopt(tcp) -struct tcb *tcp; -{ - return netlib_call (tcp, sys_getsockopt); -} - -int -sys_xsetsockopt(tcp) -struct tcb *tcp; -{ - return netlib_call (tcp, sys_setsockopt); -} - -int -sys_xshutdown(tcp) -struct tcb *tcp; -{ - return netlib_call (tcp, sys_shutdown); -} - -#endif