#include "defs.h"
#include "msghdr.h"
+#include <limits.h>
#include <arpa/inet.h>
#include <netinet/in.h>
for (i = 0; i < nfds; ++i) {
if (i)
tprints(", ");
+ if (abbrev(tcp) && i >= max_strlen) {
+ tprints("...");
+ break;
+ }
printfd(tcp, fds[i]);
}
for (i = 0; i < data_len; ++i) {
if (i)
tprints(", ");
+ if (abbrev(tcp) && i >= max_strlen) {
+ tprints("...");
+ break;
+ }
tprintf("0x%02x", opts[i]);
}
tprints("]");
}
}
+static unsigned int
+get_optmem_max(void)
+{
+ static int optmem_max;
+
+ if (!optmem_max) {
+ if (read_int_from_file("/proc/sys/net/core/optmem_max",
+ &optmem_max) || optmem_max <= 0) {
+ optmem_max = sizeof(long long) * (2 * IOV_MAX + 512);
+ } else {
+ optmem_max = (optmem_max + sizeof(long long) - 1)
+ & ~(sizeof(long long) - 1);
+ }
+ }
+
+ return optmem_max;
+}
+
static void
-decode_msg_control(struct tcb *tcp, unsigned long addr, const size_t control_len)
+decode_msg_control(struct tcb *tcp, unsigned long addr,
+ const size_t in_control_len)
{
- if (!control_len)
+ if (!in_control_len)
return;
tprints(", msg_control=");
#endif
sizeof(struct cmsghdr);
+ size_t control_len =
+ in_control_len > get_optmem_max()
+ ? get_optmem_max() : in_control_len;
size_t buf_len = control_len;
char *buf = buf_len < cmsg_size ? NULL : malloc(buf_len);
if (!buf || umoven(tcp, addr, buf_len, buf) < 0) {
if (buf_len) {
tprints(", ");
printaddr(addr + (control_len - buf_len));
+ } else if (control_len < in_control_len) {
+ tprints(", ...");
}
tprints("]");
free(buf);
}
-static void
-print_msghdr(struct tcb *tcp, struct msghdr *msg, unsigned long data_size)
+void
+print_struct_msghdr(struct tcb *tcp, const struct msghdr *msg,
+ const int *const p_user_msg_namelen,
+ const unsigned long data_size)
{
+ const int msg_namelen =
+ p_user_msg_namelen && (int) msg->msg_namelen > *p_user_msg_namelen
+ ? *p_user_msg_namelen : (int) msg->msg_namelen;
+
tprints("{msg_name=");
- decode_sockaddr(tcp, (long)msg->msg_name, msg->msg_namelen);
- tprintf(", msg_namelen=%d", msg->msg_namelen);
+ const int family =
+ decode_sockaddr(tcp, (long) msg->msg_name, msg_namelen);
+ const enum iov_decode decode =
+ (family == AF_NETLINK) ? IOV_DECODE_NETLINK : IOV_DECODE_STR;
+
+ tprints(", msg_namelen=");
+ if (p_user_msg_namelen && *p_user_msg_namelen != (int) msg->msg_namelen)
+ tprintf("%d->", *p_user_msg_namelen);
+ tprintf("%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);
+ (unsigned long) msg->msg_iov, decode, data_size);
tprintf(", msg_iovlen=%lu", (unsigned long) msg->msg_iovlen);
decode_msg_control(tcp, (unsigned long) msg->msg_control,
tprints("}");
}
-void
-decode_msghdr(struct tcb *tcp, long addr, unsigned long data_size)
+static bool
+fetch_msghdr_namelen(struct tcb *tcp, const long addr, int *const p_msg_namelen)
+{
+ struct msghdr msg;
+
+ if (addr && verbose(tcp) && fetch_struct_msghdr(tcp, addr, &msg)) {
+ *p_msg_namelen = msg.msg_namelen;
+ return true;
+ } else {
+ return false;
+ }
+}
+
+static void
+decode_msghdr(struct tcb *tcp, const int *const p_user_msg_namelen,
+ const long addr, const unsigned long data_size)
{
struct msghdr msg;
if (addr && verbose(tcp) && fetch_struct_msghdr(tcp, addr, &msg))
- print_msghdr(tcp, &msg, data_size);
+ print_struct_msghdr(tcp, &msg, p_user_msg_namelen, data_size);
else
printaddr(addr);
}
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)
+SYS_FUNC(sendmsg)
{
- struct mmsghdr mmsg;
- int fetched = fetch_struct_mmsghdr(tcp, addr, &mmsg);
-
- if (fetched) {
- tprints("{msg_hdr=");
- print_msghdr(tcp, &mmsg.msg_hdr, use_msg_len ? mmsg.msg_len : -1UL);
- tprintf(", msg_len=%u}", mmsg.msg_len);
- } else {
- printaddr(addr);
- }
-
- return fetched;
+ printfd(tcp, tcp->u_arg[0]);
+ tprints(", ");
+ decode_msghdr(tcp, 0, tcp->u_arg[1], (unsigned long) -1L);
+ /* flags */
+ tprints(", ");
+ printflags(msg_flags, tcp->u_arg[2], "MSG_???");
+
+ return RVAL_DECODED;
}
-void
-decode_mmsgvec(struct tcb *tcp, unsigned long addr, unsigned int len,
- bool use_msg_len)
+SYS_FUNC(recvmsg)
{
- 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;
+ int msg_namelen;
+
+ if (entering(tcp)) {
+ printfd(tcp, tcp->u_arg[0]);
+ tprints(", ");
+ if (fetch_msghdr_namelen(tcp, tcp->u_arg[1], &msg_namelen)) {
+ set_tcb_priv_ulong(tcp, msg_namelen);
+ return 0;
}
- tprints("]");
+ printaddr(tcp->u_arg[1]);
+ } else {
+ msg_namelen = get_tcb_priv_ulong(tcp);
+
+ if (syserror(tcp))
+ tprintf("{msg_namelen=%d}", msg_namelen);
+ else
+ decode_msghdr(tcp, &msg_namelen, tcp->u_arg[1],
+ tcp->u_rval);
}
-}
-void
-dumpiov_in_mmsghdr(struct tcb *tcp, long addr)
-{
- unsigned int len = tcp->u_rval;
- unsigned int i, fetched;
- struct mmsghdr mmsg;
+ /* flags */
+ tprints(", ");
+ printflags(msg_flags, tcp->u_arg[2], "MSG_???");
- 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);
- }
+ return RVAL_DECODED;
}
projects / strace / blobdiff