X-Git-Url: https://granicus.if.org/sourcecode?a=blobdiff_plain;f=net.c;h=51a599762b3a1ca43b95c812e84079f6691db7cc;hb=5940e6593911dcace424c668a1c0934c71fccb9e;hp=3c23b41759f14e4ea8f791b717a72f3732349e30;hpb=5a8146a20860eca692d182553ebe28b258c11af5;p=strace diff --git a/net.c b/net.c index 3c23b417..51a59976 100644 --- a/net.c +++ b/net.c @@ -49,6 +49,9 @@ #ifdef HAVE_NETINET_UDP_H #include #endif +#ifdef HAVE_NETINET_SCTP_H +#include +#endif #include #include #if defined(LINUX) @@ -116,7 +119,7 @@ #define IPPROTO_MAX IPPROTO_MAX #endif -static struct xlat domains[] = { +static const struct xlat domains[] = { #ifdef PF_AAL5 { PF_AAL5, "PF_AAL5" }, #endif @@ -218,7 +221,7 @@ static struct xlat domains[] = { #endif { 0, NULL }, }; -static struct xlat addrfams[] = { +const struct xlat addrfams[] = { #ifdef AF_APPLETALK { AF_APPLETALK, "AF_APPLETALK" }, #endif @@ -314,24 +317,39 @@ static struct xlat addrfams[] = { #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 @@ -350,15 +368,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 @@ -388,19 +409,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 @@ -410,187 +474,259 @@ 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_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 }, }; @@ -600,7 +736,7 @@ static struct xlat sockoptions[] = { #endif #ifdef SOL_IP -static struct xlat sockipoptions[] = { +static const struct xlat sockipoptions[] = { #ifdef IP_TOS { IP_TOS, "IP_TOS" }, #endif @@ -644,10 +780,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" }, @@ -672,20 +808,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 @@ -694,9 +908,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 @@ -705,17 +923,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 */ +#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) @@ -756,7 +1124,7 @@ static struct xlat socktcpoptions[] = { #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) { + if (addrlen < 2 || addrlen > sizeof(addrbuf)) + addrlen = sizeof(addrbuf); + + memset(&addrbuf, 0, sizeof(addrbuf)); + if (umoven(tcp, addr, addrlen, addrbuf.pad) < 0) { tprintf("{...}"); return; } + addrbuf.pad[sizeof(addrbuf.pad) - 1] = '\0'; tprintf("{sa_family="); printxval(addrfams, addrbuf.sa.sa_family, "AF_???"); @@ -876,12 +1244,14 @@ int addrlen; switch (addrbuf.sa.sa_family) { case AF_UNIX: - if (addrlen==2) { - tprintf(""); + if (addrlen == 2) { + tprintf("NULL"); } else if (addrbuf.sau.sun_path[0]) { - tprintf("path=\"%-.*s\"", addrlen-2, addrbuf.sau.sun_path); + tprintf("path="); + printpathn(tcp, addr + 2, strlen(addrbuf.sau.sun_path)); } else { - tprintf("path=@%-.*s", addrlen-3, addrbuf.sau.sun_path+1); + tprintf("path=@"); + printpathn(tcp, addr + 3, strlen(addrbuf.sau.sun_path + 1)); } break; case AF_INET: @@ -897,24 +1267,24 @@ 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) case AF_IPX: @@ -929,7 +1299,7 @@ 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; + + tprintf(", {"); + while ((char *) fds < ((char *) cmsg + cmsg_len)) { + if (!first) + tprintf(", "); + tprintf("%d", *fds++); + first = 0; + } + tprintf("}}"); + 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; + } + } + free(cmsg); + tprintf(", ...}"); +} + +static void +do_msghdr(struct tcb *tcp, struct msghdr *msg) +{ + 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(tcp, (unsigned long)msg->msg_iovlen, + (unsigned long)msg->msg_iov, 1); #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_controllen=%lu", (unsigned long)msg->msg_controllen); + if (msg->msg_controllen) + printcmsghdr(tcp, (unsigned long) msg->msg_control, + msg->msg_controllen); tprintf(", msg_flags="); - if (printflags(msg_flags, msg.msg_flags)==0) - tprintf("0"); + 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); + (unsigned long) msg->msg_accrights, msg->msg_accrightslen); #endif /* !HAVE_STRUCT_MSGHDR_MSG_CONTROL */ tprintf("}"); } +static void +printmsghdr(struct tcb *tcp, long addr) +{ + struct msghdr msg; + + if (umove(tcp, addr, &msg) < 0) { + tprintf("%#lx", addr); + return; + } + do_msghdr(tcp, &msg); +} + +#ifdef LINUX +static void +printmmsghdr(struct tcb *tcp, long addr) +{ + struct mmsghdr { + struct msghdr msg_hdr; + unsigned msg_len; + } mmsg; + + if (umove(tcp, addr, &mmsg) < 0) { + tprintf("%#lx", addr); + return; + } + tprintf("{"); + do_msghdr(tcp, &mmsg.msg_hdr); + tprintf(", %u}", mmsg.msg_len); +} +#endif + #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; + tprintf("|"); + } + 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_???"); + tprint_sock_type(tcp, tcp->u_arg[1]); tprintf(", "); switch (tcp->u_arg[0]) { case PF_INET: @@ -1036,9 +1508,9 @@ struct tcb *tcp; return 0; } +#ifdef SVR4 int -sys_so_socket(tcp) -struct tcb *tcp; +sys_so_socket(struct tcb *tcp) { if (entering(tcp)) { /* not sure really what these args are... but this @@ -1053,19 +1525,18 @@ struct tcb *tcp; } int -sys_so_socketpair(tcp) -struct tcb *tcp; +sys_so_socketpair(struct tcb *tcp) { if (entering(tcp)) { - /* not sure what this arg is */ + /* not sure what this arg is */ tprintf("0x%lx", tcp->u_arg[0]); } return 0; } +#endif /* SVR4 */ int -sys_bind(tcp) -struct tcb *tcp; +sys_bind(struct tcb *tcp) { if (entering(tcp)) { tprintf("%ld, ", tcp->u_arg[0]); @@ -1076,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]); @@ -1092,52 +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"); + printnum_int(tcp, tcp->u_arg[2], "%u"); + } + if (flags_arg >= 0) { + tprintf(", "); + 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); +} + +#ifdef LINUX +int +sys_accept4(struct tcb *tcp) +{ + return do_accept(tcp, 3); +} +#endif + +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(", "); printsock(tcp, tcp->u_arg[4], tcp->u_arg[5]); @@ -1150,16 +1637,14 @@ 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]); /* flags */ tprintf(", "); - if (printflags(msg_flags, tcp->u_arg[2]) == 0) - tprintf("0"); + printflags(msg_flags, tcp->u_arg[2], "MSG_???"); } return 0; } @@ -1167,8 +1652,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]); @@ -1179,15 +1663,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; @@ -1205,8 +1687,7 @@ 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) @@ -1234,8 +1715,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]); @@ -1246,77 +1726,135 @@ struct tcb *tcp; printmsghdr(tcp, tcp->u_arg[1]); /* flags */ tprintf(", "); - if (printflags(msg_flags, tcp->u_arg[2]) == 0) - tprintf("0"); + printflags(msg_flags, tcp->u_arg[2], "MSG_???"); } return 0; } +#ifdef LINUX +int +sys_recvmmsg(struct tcb *tcp) +{ + static char str[128]; + if (entering(tcp)) { + + tprintf("%ld, ", tcp->u_arg[0]); + if (verbose(tcp)) { + sprint_timespec(str, tcp, tcp->u_arg[4]); + tcp->auxstr = strdup(str); + } else { + tprintf("%#lx, %ld, ", tcp->u_arg[1], tcp->u_arg[2]); + printflags(msg_flags, tcp->u_arg[3], "MSG_???"); + tprintf(", "); + print_timespec(tcp, tcp->u_arg[4]); + } + return 0; + } else { + if (verbose(tcp)) { + if (syserror(tcp)) + tprintf("%#lx", tcp->u_arg[1]); + else + printmmsghdr(tcp, tcp->u_arg[1]); + tprintf(", %ld, ", tcp->u_arg[2]); + /* flags */ + printflags(msg_flags, tcp->u_arg[3], "MSG_???"); + /* 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 */ + strcpy(str, "left "); + sprint_timespec(str + strlen(str), tcp, tcp->u_arg[4]); + tcp->auxstr = str; + return RVAL_STR; + } +} +#endif + #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(LINUX) && !defined(SPARC) && !defined(SPARC64) && !defined(SH) && !defined(IA64) + int fds[2]; + + 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(SPARC64) || defined(SH) || defined(SVR4) || defined(FREEBSD) || defined(IA64) + tprintf("[%lu, %lu]", tcp->u_rval, getrval2(tcp)); +#else + tprintf("%#lx", tcp->u_arg[0]); +#endif + } + if (flags_arg >= 0) { + tprintf(", "); + 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); +} + +#ifdef LINUX +int +sys_pipe2(struct tcb *tcp) +{ + return do_pipe(tcp, 1); +} +#endif + +int +sys_socketpair(struct tcb *tcp) { #ifdef LINUX int fds[2]; @@ -1325,7 +1863,7 @@ struct tcb *tcp; if (entering(tcp)) { printxval(domains, tcp->u_arg[0], "PF_???"); tprintf(", "); - printxval(socktypes, tcp->u_arg[1], "SOCK_???"); + tprint_sock_type(tcp, tcp->u_arg[1]); tprintf(", "); switch (tcp->u_arg[0]) { case PF_INET: @@ -1362,13 +1900,12 @@ struct tcb *tcp; } 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 (", "); + tprintf(", "); switch (tcp->u_arg[1]) { case SOL_SOCKET: printxval(sockoptions, tcp->u_arg[2], "SO_???"); @@ -1378,6 +1915,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_???"); @@ -1393,6 +1935,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 */ @@ -1400,10 +1947,11 @@ struct tcb *tcp; tprintf("%lu", tcp->u_arg[2]); break; } + tprintf(", "); } 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; } @@ -1413,41 +1961,77 @@ 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; @@ -1465,31 +2049,25 @@ long addr; } tprintf("~("); - if (printflags(icmpfilterflags, ~filter.data) == 0) - tprintf("0"); + printflags(icmpfilterflags, ~filter.data, "ICMP_???"); tprintf(")"); } #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 (", "); + tprintf(", "); switch (level) { case SOL_SOCKET: printxval(sockoptions, name, "SO_???"); switch (name) { #if defined(SO_LINGER) case SO_LINGER: - if (len == sizeof (struct 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, @@ -1505,6 +2083,11 @@ int len; printxval(sockipoptions, name, "IP_???"); break; #endif +#ifdef SOL_IPV6 + case SOL_IPV6: + printxval(sockipv6options, name, "IPV6_???"); + break; +#endif #ifdef SOL_IPX case SOL_IPX: printxval(sockipxoptions, name, "IPX_???"); @@ -1514,6 +2097,28 @@ int len; 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 @@ -1521,6 +2126,11 @@ int len; printxval(socktcpoptions, name, "TCP_???"); break; #endif +#ifdef SOL_SCTP + case SOL_SCTP: + printxval(socksctpoptions, name, "SCTP_???"); + break; +#endif #ifdef SOL_RAW case SOL_RAW: printxval(sockrawoptions, name, "RAW_???"); @@ -1544,13 +2154,13 @@ int len; /* default arg printing */ - tprintf (", "); + tprintf(", "); - 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; } @@ -1559,10 +2169,7 @@ int len; #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; @@ -1570,37 +2177,36 @@ int len; while (len >= (int) sizeof hdr) { if (umove(tcp, addr, &hdr) < 0) break; if (c++) { - tprintf (", "); + tprintf(", "); } else if (len > hdr.len + sizeof hdr) { - tprintf ("["); + tprintf("["); } - tprintf ("{"); + tprintf("{"); 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 ("}"); + tprintf("}"); } if (len > 0) { - if (c++) tprintf (", "); - printstr (tcp, addr, len); + if (c++) tprintf(", "); + printstr(tcp, addr, len); } - if (c > 1) tprintf ("]"); + if (c > 1) tprintf("]"); } #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]); } @@ -1609,109 +2215,97 @@ struct tcb *tcp; #if UNIXWARE >= 7 -static struct xlat sock_version[] = { +static const 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 }, + { 0, NULL }, }; int -netlib_call(tcp, func) -struct tcb *tcp; -int (*func) (); +netlib_call(struct tcb *tcp, int (*func)()) { if (entering(tcp)) { int i; - printxval (sock_version, tcp->u_arg[0], "__NETLIB_???"); + 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); } - return func (tcp); + return func(tcp); } int -sys_xsocket(tcp) -struct tcb *tcp; +sys_xsocket(struct tcb *tcp) { - return netlib_call (tcp, sys_socket); + return netlib_call(tcp, sys_socket); } int -sys_xsocketpair(tcp) -struct tcb *tcp; +sys_xsocketpair(struct tcb *tcp) { - return netlib_call (tcp, sys_socketpair); + return netlib_call(tcp, sys_socketpair); } int -sys_xbind(tcp) -struct tcb *tcp; +sys_xbind(struct tcb *tcp) { - return netlib_call (tcp, sys_bind); + return netlib_call(tcp, sys_bind); } int -sys_xconnect(tcp) -struct tcb *tcp; +sys_xconnect(struct tcb *tcp) { - return netlib_call (tcp, sys_connect); + return netlib_call(tcp, sys_connect); } int -sys_xlisten(tcp) -struct tcb *tcp; +sys_xlisten(struct tcb *tcp) { - return netlib_call (tcp, sys_listen); + return netlib_call(tcp, sys_listen); } int -sys_xaccept(tcp) -struct tcb *tcp; +sys_xaccept(struct tcb *tcp) { - return netlib_call (tcp, sys_accept); + return netlib_call(tcp, sys_accept); } int -sys_xsendmsg(tcp) -struct tcb *tcp; +sys_xsendmsg(struct tcb *tcp) { - return netlib_call (tcp, sys_sendmsg); + return netlib_call(tcp, sys_sendmsg); } int -sys_xrecvmsg(tcp) -struct tcb *tcp; +sys_xrecvmsg(struct tcb *tcp) { - return netlib_call (tcp, sys_recvmsg); + return netlib_call(tcp, sys_recvmsg); } int -sys_xgetsockaddr(tcp) -struct tcb *tcp; +sys_xgetsockaddr(struct tcb *tcp) { if (entering(tcp)) { - printxval (sock_version, tcp->u_arg[0], "__NETLIB_???"); + printxval(sock_version, tcp->u_arg[0], "__NETLIB_???"); tprintf(", "); if (tcp->u_arg[1] == 0) { - tprintf ("LOCALNAME, "); + tprintf("LOCALNAME, "); } else if (tcp->u_arg[1] == 1) { - tprintf ("REMOTENAME, "); + tprintf("REMOTENAME, "); } else { - tprintf ("%ld, ", tcp->u_arg [1]); + tprintf("%ld, ", tcp->u_arg[1]); } - tprintf ("%ld, ", tcp->u_arg [2]); + tprintf("%ld, ", tcp->u_arg[2]); } else { if (tcp->u_arg[3] == 0 || syserror(tcp)) { @@ -1727,36 +2321,22 @@ struct tcb *tcp; } -#if 0 - int -sys_xsetsockaddr(tcp) -struct tcb *tcp; +sys_xgetsockopt(struct tcb *tcp) { - return netlib_call (tcp, sys_setsockaddr); -} - -#endif - -int -sys_xgetsockopt(tcp) -struct tcb *tcp; -{ - return netlib_call (tcp, sys_getsockopt); + return netlib_call(tcp, sys_getsockopt); } int -sys_xsetsockopt(tcp) -struct tcb *tcp; +sys_xsetsockopt(struct tcb *tcp) { - return netlib_call (tcp, sys_setsockopt); + return netlib_call(tcp, sys_setsockopt); } int -sys_xshutdown(tcp) -struct tcb *tcp; +sys_xshutdown(struct tcb *tcp) { - return netlib_call (tcp, sys_shutdown); + return netlib_call(tcp, sys_shutdown); } -#endif +#endif /* UNIXWARE */