net.c: move all msghdr and mmsghdr parsers to a separate file
* defs.h (msg_flags, socketlayers, decode_msghdr, decode_mmsg):
New prototypes.
* msghdr.c: New file.
* Makefile.am (strace_SOURCES): Add it.
* net.c: Move all msghdr and mmsghdr parsers to msghdr.c.
diff --git a/msghdr.c b/msghdr.c
new file mode 100644
index 0000000..aa283b0
--- /dev/null
+++ b/msghdr.c
@@ -0,0 +1,429 @@
+/*
+ * Copyright (c) 1991, 1992 Paul Kranenburg <pk@cs.few.eur.nl>
+ * Copyright (c) 1993 Branko Lankester <branko@hacktic.nl>
+ * Copyright (c) 1993, 1994, 1995, 1996 Rick Sladkey <jrs@world.std.com>
+ * Copyright (c) 1996-2000 Wichert Akkerman <wichert@cistron.nl>
+ * Copyright (c) 2005-2016 Dmitry V. Levin <ldv@altlinux.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "defs.h"
+#include "msghdr.h"
+#include <arpa/inet.h>
+#include <netinet/in.h>
+
+#include "xlat/msg_flags.h"
+#include "xlat/scmvals.h"
+#include "xlat/ip_cmsg_types.h"
+
+#if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
+struct cmsghdr32 {
+ uint32_t cmsg_len;
+ int cmsg_level;
+ int cmsg_type;
+};
+#endif
+
+typedef union {
+ char *ptr;
+ struct cmsghdr *cmsg;
+#if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
+ struct cmsghdr32 *cmsg32;
+#endif
+} union_cmsghdr;
+
+static void
+print_scm_rights(struct tcb *tcp, const void *cmsg_data,
+ const size_t data_len)
+{
+ const int *fds = cmsg_data;
+ const char *end = (const char *) cmsg_data + data_len;
+ bool seen = false;
+
+ if (sizeof(*fds) > data_len)
+ return;
+
+ tprints(", [");
+ while ((const char *) fds < end) {
+ if (seen)
+ tprints(", ");
+ else
+ seen = true;
+ printfd(tcp, *fds++);
+ }
+ tprints("]");
+}
+
+static void
+print_scm_creds(struct tcb *tcp, const void *cmsg_data,
+ const size_t data_len)
+{
+ const struct ucred *uc = cmsg_data;
+
+ if (sizeof(*uc) > data_len)
+ return;
+
+ tprintf(", {pid=%u, uid=%u, gid=%u}",
+ (unsigned) uc->pid, (unsigned) uc->uid, (unsigned) uc->gid);
+}
+
+static void
+print_scm_security(struct tcb *tcp, const void *cmsg_data,
+ const size_t data_len)
+{
+ if (!data_len)
+ return;
+
+ tprints(", ");
+ print_quoted_string(cmsg_data, data_len, 0);
+}
+
+static void
+print_cmsg_ip_pktinfo(struct tcb *tcp, const void *cmsg_data,
+ const size_t data_len)
+{
+ const struct in_pktinfo *info = cmsg_data;
+
+ if (sizeof(*info) > data_len)
+ return;
+
+ tprints(", {ipi_ifindex=");
+ print_ifindex(info->ipi_ifindex);
+ tprintf(", ipi_spec_dst=inet_addr(\"%s\"), ipi_addr=inet_addr(\"%s\")}",
+ inet_ntoa(info->ipi_spec_dst), inet_ntoa(info->ipi_addr));
+}
+
+static void
+print_cmsg_ip_ttl(struct tcb *tcp, const void *cmsg_data,
+ const size_t data_len)
+{
+ const unsigned int *ttl = cmsg_data;
+
+ if (sizeof(*ttl) > data_len)
+ return;
+
+ tprintf(", {ttl=%u}", *ttl);
+}
+
+static void
+print_cmsg_ip_tos(struct tcb *tcp, const void *cmsg_data,
+ const size_t data_len)
+{
+ const uint8_t *tos = cmsg_data;
+
+ if (sizeof(*tos) > data_len)
+ return;
+
+ tprintf(", {tos=%x}", *tos);
+}
+
+static void
+print_cmsg_ip_checksum(struct tcb *tcp, const void *cmsg_data,
+ const size_t data_len)
+{
+ const uint32_t *csum = cmsg_data;
+
+ if (sizeof(*csum) > data_len)
+ return;
+
+ tprintf(", {csum=%u}", *csum);
+}
+
+static void
+print_cmsg_ip_opts(struct tcb *tcp, const void *cmsg_data,
+ const size_t data_len)
+{
+ const unsigned char *opts = cmsg_data;
+ size_t i;
+
+ if (!data_len)
+ return;
+
+ tprints(", {opts=0x");
+ for (i = 0; i < data_len; ++i)
+ tprintf("%02x", opts[i]);
+ tprints("}");
+}
+
+static void
+print_cmsg_ip_recverr(struct tcb *tcp, const void *cmsg_data,
+ const size_t data_len)
+{
+ const struct {
+ uint32_t ee_errno;
+ uint8_t ee_origin;
+ uint8_t ee_type;
+ uint8_t ee_code;
+ uint8_t ee_pad;
+ uint32_t ee_info;
+ uint32_t ee_data;
+ struct sockaddr_in offender;
+ } *err = cmsg_data;
+
+ if (sizeof(*err) > data_len)
+ return;
+
+ tprintf(", {ee_errno=%u, ee_origin=%u, ee_type=%u, ee_code=%u"
+ ", ee_info=%u, ee_data=%u, offender=",
+ err->ee_errno, err->ee_origin, err->ee_type,
+ err->ee_code, err->ee_info, err->ee_data);
+ print_sockaddr(tcp, &err->offender, sizeof(err->offender));
+ tprints("}");
+}
+
+static void
+print_cmsg_ip_origdstaddr(struct tcb *tcp, const void *cmsg_data,
+ const size_t data_len)
+{
+ if (sizeof(struct sockaddr_in) > data_len)
+ return;
+
+ tprints(", ");
+ print_sockaddr(tcp, cmsg_data, data_len);
+}
+
+static void
+print_cmsg_type_data(struct tcb *tcp, const int cmsg_level, const int cmsg_type,
+ const void *cmsg_data, const size_t data_len)
+{
+ switch (cmsg_level) {
+ case SOL_SOCKET:
+ printxval(scmvals, cmsg_type, "SCM_???");
+ switch (cmsg_type) {
+ case SCM_RIGHTS:
+ print_scm_rights(tcp, cmsg_data, data_len);
+ break;
+ case SCM_CREDENTIALS:
+ print_scm_creds(tcp, cmsg_data, data_len);
+ break;
+ case SCM_SECURITY:
+ print_scm_security(tcp, cmsg_data, data_len);
+ break;
+ }
+ break;
+ case SOL_IP:
+ printxval(ip_cmsg_types, cmsg_type, "IP_???");
+ switch (cmsg_type) {
+ case IP_PKTINFO:
+ print_cmsg_ip_pktinfo(tcp, cmsg_data, data_len);
+ break;
+ case IP_TTL:
+ print_cmsg_ip_ttl(tcp, cmsg_data, data_len);
+ break;
+ case IP_TOS:
+ print_cmsg_ip_tos(tcp, cmsg_data, data_len);
+ break;
+ case IP_RECVOPTS:
+ case IP_RETOPTS:
+ print_cmsg_ip_opts(tcp, cmsg_data, data_len);
+ break;
+ case IP_RECVERR:
+ print_cmsg_ip_recverr(tcp, cmsg_data, data_len);
+ break;
+ case IP_ORIGDSTADDR:
+ print_cmsg_ip_origdstaddr(tcp, cmsg_data, data_len);
+ break;
+ case IP_CHECKSUM:
+ print_cmsg_ip_checksum(tcp, cmsg_data, data_len);
+ break;
+ case SCM_SECURITY:
+ print_scm_security(tcp, cmsg_data, data_len);
+ break;
+ }
+ break;
+ default:
+ tprintf("%u", cmsg_type);
+ }
+}
+
+static void
+decode_msg_control(struct tcb *tcp, unsigned long addr, size_t len)
+{
+ const size_t cmsg_size =
+#if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
+ (current_wordsize < sizeof(long)) ? sizeof(struct cmsghdr32) :
+#endif
+ sizeof(struct cmsghdr);
+
+ if (!len)
+ return;
+ tprints(", msg_control=");
+
+ char *buf = len < cmsg_size ? NULL : malloc(len);
+ if (!buf || umoven(tcp, addr, len, buf) < 0) {
+ printaddr(addr);
+ free(buf);
+ return;
+ }
+
+ union_cmsghdr u = { .ptr = buf };
+
+ tprints("[");
+ while (len >= cmsg_size) {
+ size_t cmsg_len =
+#if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
+ (current_wordsize < sizeof(long)) ? u.cmsg32->cmsg_len :
+#endif
+ u.cmsg->cmsg_len;
+ int cmsg_level =
+#if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
+ (current_wordsize < sizeof(long)) ? u.cmsg32->cmsg_level :
+#endif
+ u.cmsg->cmsg_level;
+ int cmsg_type =
+#if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
+ (current_wordsize < sizeof(long)) ? u.cmsg32->cmsg_type :
+#endif
+ u.cmsg->cmsg_type;
+
+ if (u.ptr != buf)
+ tprints(", ");
+ tprintf("{cmsg_len=%lu, cmsg_level=", (unsigned long) cmsg_len);
+ printxval(socketlayers, cmsg_level, "SOL_???");
+ tprints(", cmsg_type=");
+
+ if (cmsg_len > len)
+ cmsg_len = len;
+
+ print_cmsg_type_data(tcp, cmsg_level, cmsg_type,
+ (const void *) (u.ptr + cmsg_size),
+ cmsg_len > cmsg_size ? cmsg_len - cmsg_size: 0);
+ tprints("}");
+
+ if (cmsg_len < cmsg_size) {
+ len -= cmsg_size;
+ break;
+ }
+ cmsg_len = (cmsg_len + current_wordsize - 1) &
+ (size_t) ~(current_wordsize - 1);
+ if (cmsg_len >= len) {
+ len = 0;
+ break;
+ }
+ u.ptr += cmsg_len;
+ len -= cmsg_len;
+ }
+ if (len)
+ tprints(", ...");
+ tprints("]");
+ free(buf);
+}
+
+static void
+print_msghdr(struct tcb *tcp, struct msghdr *msg, unsigned long data_size)
+{
+ tprints("{msg_name=");
+ decode_sockaddr(tcp, (long)msg->msg_name, msg->msg_namelen);
+ tprintf(", msg_namelen=%d", msg->msg_namelen);
+
+ tprints(", msg_iov=");
+ tprint_iov_upto(tcp, (unsigned long) msg->msg_iovlen,
+ (unsigned long) msg->msg_iov, IOV_DECODE_STR, data_size);
+ tprintf(", msg_iovlen=%lu", (unsigned long) msg->msg_iovlen);
+
+ decode_msg_control(tcp, (unsigned long) msg->msg_control,
+ msg->msg_controllen);
+ tprintf(", msg_controllen=%lu", (unsigned long) msg->msg_controllen);
+
+ tprints(", msg_flags=");
+ printflags(msg_flags, msg->msg_flags, "MSG_???");
+ tprints("}");
+}
+
+void
+decode_msghdr(struct tcb *tcp, long addr, unsigned long data_size)
+{
+ struct msghdr msg;
+
+ if (addr && verbose(tcp) && fetch_struct_msghdr(tcp, addr, &msg))
+ print_msghdr(tcp, &msg, data_size);
+ else
+ printaddr(addr);
+}
+
+void
+dumpiov_in_msghdr(struct tcb *tcp, long addr, unsigned long data_size)
+{
+ struct msghdr msg;
+
+ if (fetch_struct_msghdr(tcp, addr, &msg))
+ dumpiov_upto(tcp, msg.msg_iovlen, (long)msg.msg_iov, data_size);
+}
+
+static int
+decode_mmsghdr(struct tcb *tcp, long addr, bool use_msg_len)
+{
+ struct mmsghdr mmsg;
+ int fetched = fetch_struct_mmsghdr(tcp, addr, &mmsg);
+
+ if (fetched) {
+ tprints("{");
+ print_msghdr(tcp, &mmsg.msg_hdr, use_msg_len ? mmsg.msg_len : -1UL);
+ tprintf(", %u}", mmsg.msg_len);
+ } else {
+ printaddr(addr);
+ }
+
+ return fetched;
+}
+
+void
+decode_mmsgvec(struct tcb *tcp, unsigned long addr, unsigned int len,
+ bool use_msg_len)
+{
+ if (syserror(tcp)) {
+ printaddr(addr);
+ } else {
+ unsigned int i, fetched;
+
+ tprints("[");
+ for (i = 0; i < len; ++i, addr += fetched) {
+ if (i)
+ tprints(", ");
+ fetched = decode_mmsghdr(tcp, addr, use_msg_len);
+ if (!fetched)
+ break;
+ }
+ tprints("]");
+ }
+}
+
+void
+dumpiov_in_mmsghdr(struct tcb *tcp, long addr)
+{
+ unsigned int len = tcp->u_rval;
+ unsigned int i, fetched;
+ struct mmsghdr mmsg;
+
+ for (i = 0; i < len; ++i, addr += fetched) {
+ fetched = fetch_struct_mmsghdr(tcp, addr, &mmsg);
+ if (!fetched)
+ break;
+ tprintf(" = %lu buffers in vector %u\n",
+ (unsigned long)mmsg.msg_hdr.msg_iovlen, i);
+ dumpiov_upto(tcp, mmsg.msg_hdr.msg_iovlen,
+ (long)mmsg.msg_hdr.msg_iov, mmsg.msg_len);
+ }
+}