static isc_result_t
printsection(dig_query_t *query, dns_message_t *msg, isc_boolean_t headers,
dns_section_t section) {
isc_result_t result, loopresult;
dns_name_t *name;
dns_rdataset_t *rdataset = NULL;
dns_rdata_t rdata = DNS_RDATA_INIT;
char namebuf[DNS_NAME_FORMATSIZE];
UNUSED(query);
UNUSED(headers);
debug("printsection()");
result = dns_message_firstname(msg, section);
if (result == ISC_R_NOMORE)
return (ISC_R_SUCCESS);
else if (result != ISC_R_SUCCESS)
return (result);
for (;;) {
name = NULL;
dns_message_currentname(msg, section,
&name);
for (rdataset = ISC_LIST_HEAD(name->list);
rdataset != NULL;
rdataset = ISC_LIST_NEXT(rdataset, link)) {
loopresult = dns_rdataset_first(rdataset);
while (loopresult == ISC_R_SUCCESS) {
dns_rdataset_current(rdataset, &rdata);
switch (rdata.type) {
case dns_rdatatype_a:
case dns_rdatatype_aaaa:
if (section != DNS_SECTION_ANSWER)
goto def_short_section;
dns_name_format(name, namebuf,
sizeof(namebuf));
printf("Name:\t%s\n", namebuf);
printaddr(&rdata);
break;
case dns_rdatatype_soa:
dns_name_format(name, namebuf,
sizeof(namebuf));
printf("%s\n", namebuf);
printsoa(&rdata);
break;
default:
def_short_section:
dns_name_format(name, namebuf,
sizeof(namebuf));
printf("%s\t", namebuf);
printrdata(&rdata);
break;
}
dns_rdata_reset(&rdata);
loopresult = dns_rdataset_next(rdataset);
}
}
result = dns_message_nextname(msg, section);
if (result == ISC_R_NOMORE)
break;
else if (result != ISC_R_SUCCESS) {
return (result);
}
}
return (ISC_R_SUCCESS);
}
static void
decode_seccomp_set_mode_strict(unsigned int flags, unsigned long addr)
{
tprintf("%u, ", flags);
printaddr(addr);
}
static char *authenticate(struct conninfo *ci)
{
char buf[1024];
int n;
int noauth=0;
int uidpw=0;
D(DEBUG_CONNECT)
{
fprintf(stderr, "DEBUG: Connection from ");
printaddr(stderr, &ci->clientaddr);
fprintf(stderr, "\n");
fflush(stderr);
}
readfd(ci, buf, 2);
if (buf[0] != 5)
{
fprintf(stderr, "ERR: ");
printaddr(stderr, &ci->clientaddr);
fprintf(stderr, " - received unknown protocol version: %d\n",
(int)(unsigned char)buf[0]);
fflush(stderr);
exit(0);
}
readfd(ci, buf+2, (int)(unsigned char)buf[1]);
for (n=0; n<(int)(unsigned char)buf[1]; n++)
switch (buf[2+n]) {
case 0:
noauth=1;
break;
case 2:
uidpw=1;
break;
}
if (uidpw)
{
int uidl;
int pwdl;
char *pw;
buf[0]=5;
buf[1]=2;
writefd(ci, buf, 2);
readfd(ci, buf, 2);
if (buf[0] != 1)
{
fprintf(stderr, "ERR: ");
printaddr(stderr, &ci->clientaddr);
fprintf(stderr, " - received unknown userid/password authentication version: %d\n",
(int)(unsigned char)buf[0]);
fflush(stderr);
exit(0);
}
uidl=(int)(unsigned char)buf[1];
readfd(ci, buf, uidl+1);
pw=buf+uidl;
pwdl=(int)(unsigned char)*pw;
*pw++=0;
readfd(ci, pw, pwdl);
pw[pwdl]=0;
if (buf[0] == 0)
{
/* Empty userid - no authentication */
buf[0]=5;
buf[1]=0;
writefd(ci, buf, 2);
D(DEBUG_CONNECT)
{
fprintf(stderr,"DEBUG: Empty userid - unauthenticated connection from ");
printaddr(stderr, &ci->clientaddr);
fprintf(stderr, "\n");
fflush(stderr);
}
return NULL;
}
if (validateuseridpw(buf, pw))
{
buf[0]=5;
buf[1]=1;
writefd(ci, buf, 2);
fprintf(stderr, "ERR: ");
printaddr(stderr, &ci->clientaddr);
fprintf(stderr, " - userid/password invalid.\n");
fflush(stderr);
fcntl(ci->clientfd, F_SETFL, 0);
close(ci->clientfd);
exit(0);
}
pw=strdup(buf);
buf[0]=5;
buf[1]=0;
writefd(ci, buf, 2);
D(DEBUG_CONNECT)
{
fprintf(stderr, "DEBUG: Connection from ");
printaddr(stderr, &ci->clientaddr);
fprintf(stderr, " authenticated as %s\n",
buf);
fflush(stderr);
}
if (!pw)
{
perror("ERR: malloc");
exit(0);
}
return pw;
}
static void
print_setsockopt(struct tcb *tcp, unsigned int level, unsigned int name,
long addr, int len)
{
if (addr && verbose(tcp))
switch (level) {
case SOL_SOCKET:
switch (name) {
case SO_LINGER:
print_linger(tcp, addr, len);
goto done;
}
break;
case SOL_IP:
switch (name) {
#ifdef IP_ADD_MEMBERSHIP
case IP_ADD_MEMBERSHIP:
case IP_DROP_MEMBERSHIP:
print_mreq(tcp, addr, len);
goto done;
#endif /* IP_ADD_MEMBERSHIP */
#ifdef MCAST_JOIN_GROUP
case MCAST_JOIN_GROUP:
case MCAST_LEAVE_GROUP:
print_group_req(tcp, addr, len);
goto done;
#endif /* MCAST_JOIN_GROUP */
}
break;
case SOL_IPV6:
switch (name) {
#ifdef IPV6_ADD_MEMBERSHIP
case IPV6_ADD_MEMBERSHIP:
case IPV6_DROP_MEMBERSHIP:
# ifdef IPV6_JOIN_ANYCAST
case IPV6_JOIN_ANYCAST:
# endif
# ifdef IPV6_LEAVE_ANYCAST
case IPV6_LEAVE_ANYCAST:
# endif
print_mreq6(tcp, addr, len);
goto done;
#endif /* IPV6_ADD_MEMBERSHIP */
}
break;
case SOL_PACKET:
switch (name) {
#ifdef PACKET_RX_RING
case PACKET_RX_RING:
# ifdef PACKET_TX_RING
case PACKET_TX_RING:
# endif
print_tpacket_req(tcp, addr, len);
goto done;
#endif /* PACKET_RX_RING */
#ifdef PACKET_ADD_MEMBERSHIP
case PACKET_ADD_MEMBERSHIP:
case PACKET_DROP_MEMBERSHIP:
print_packet_mreq(tcp, addr, len);
goto done;
#endif /* PACKET_ADD_MEMBERSHIP */
}
break;
case SOL_RAW:
switch (name) {
case ICMP_FILTER:
print_icmp_filter(tcp, addr, len);
goto done;
}
break;
}
/* default arg printing */
if (verbose(tcp)) {
if (len == sizeof(int)) {
printnum_int(tcp, addr, "%d");
} else {
printstr(tcp, addr, len);
}
} else {
printaddr(addr);
}
done:
tprintf(", %d", len);
}
static int
decode_ifconf(struct tcb *tcp, const long addr)
{
struct ifconf ifc;
if (entering(tcp)) {
tprints(", ");
if (umove_or_printaddr(tcp, addr, &ifc))
return RVAL_DECODED | 1;
if (ifc.ifc_buf) {
tprints("{");
print_ifc_len(ifc.ifc_len);
}
return 1;
}
if (syserror(tcp) || umove(tcp, addr, &ifc) < 0) {
if (ifc.ifc_buf)
tprints("}");
else
printaddr(addr);
return RVAL_DECODED | 1;
}
if (!ifc.ifc_buf) {
tprints("{");
print_ifc_len(ifc.ifc_len);
tprints(", NULL}");
return RVAL_DECODED | 1;
}
tprints(" => ");
const unsigned int nifra = print_ifc_len(ifc.ifc_len);
if (!nifra) {
tprints("}");
return RVAL_DECODED | 1;
}
struct ifreq ifra[nifra > max_strlen ? max_strlen : nifra];
tprints(", ");
if (umove_or_printaddr(tcp, (unsigned long) ifc.ifc_buf, &ifra)) {
tprints("}");
return RVAL_DECODED | 1;
}
tprints("[");
unsigned int i;
for (i = 0; i < ARRAY_SIZE(ifra); ++i) {
if (i > 0)
tprints(", ");
tprints("{ifr_name=");
print_ifname(ifra[i].ifr_name);
tprints(", ");
if (verbose(tcp)) {
tprints("ifr_addr=");
print_ifreq_addr(tcp, &ifra[i],
addr + i * sizeof(ifra[0]));
} else
tprints("...");
tprints("}");
}
if (i < nifra)
tprints(", ...");
tprints("]}");
return RVAL_DECODED | 1;
}
static void
print_si_info(const siginfo_t *sip)
{
if (sip->si_errno) {
tprints(", si_errno=");
if ((unsigned) sip->si_errno < nerrnos
&& errnoent[sip->si_errno])
tprints(errnoent[sip->si_errno]);
else
tprintf("%d", sip->si_errno);
}
if (SI_FROMUSER(sip)) {
switch (sip->si_code) {
case SI_USER:
printsigsource(sip);
break;
case SI_TKILL:
printsigsource(sip);
break;
#if defined HAVE_SIGINFO_T_SI_TIMERID && defined HAVE_SIGINFO_T_SI_OVERRUN
case SI_TIMER:
tprintf(", si_timerid=%#x, si_overrun=%d",
sip->si_timerid, sip->si_overrun);
printsigval(sip);
break;
#endif
default:
printsigsource(sip);
if (sip->si_ptr)
printsigval(sip);
break;
}
} else {
switch (sip->si_signo) {
case SIGCHLD:
printsigsource(sip);
tprints(", si_status=");
if (sip->si_code == CLD_EXITED)
tprintf("%d", sip->si_status);
else
printsignal(sip->si_status);
tprintf(", si_utime=%llu, si_stime=%llu",
zero_extend_signed_to_ull(sip->si_utime),
zero_extend_signed_to_ull(sip->si_stime));
break;
case SIGILL: case SIGFPE:
case SIGSEGV: case SIGBUS:
tprints(", si_addr=");
printaddr(ptr_to_kulong(sip->si_addr));
break;
case SIGPOLL:
switch (sip->si_code) {
case POLL_IN: case POLL_OUT: case POLL_MSG:
tprintf(", si_band=%ld",
(long) sip->si_band);
break;
}
break;
#ifdef HAVE_SIGINFO_T_SI_SYSCALL
case SIGSYS: {
const char *scname =
syscall_name((unsigned) sip->si_syscall);
tprints(", si_call_addr=");
printaddr(ptr_to_kulong(sip->si_call_addr));
tprints(", si_syscall=");
if (scname)
tprintf("__NR_%s", scname);
else
tprintf("%u", (unsigned) sip->si_syscall);
tprints(", si_arch=");
printxval(audit_arch, sip->si_arch, "AUDIT_ARCH_???");
break;
}
#endif
default:
if (sip->si_pid || sip->si_uid)
printsigsource(sip);
if (sip->si_ptr)
printsigval(sip);
}
}
}
/** Various responses test */
static void test_turn (char *username, char *password, char *hostname, int port)
{
struct sockaddr_storage addr;
socklen_t addrlen = sizeof (addr);
struct sockaddr_storage alternate_addr;
socklen_t alternate_addrlen = sizeof (alternate_addr);
struct sockaddr_storage relay_addr;
socklen_t relay_addrlen = sizeof (relay_addr);
ssize_t val;
size_t len;
int fd;
uint8_t buf[STUN_MAX_MESSAGE_SIZE];
uint8_t req[STUN_MAX_MESSAGE_SIZE];
uint8_t refresh[STUN_MAX_MESSAGE_SIZE];
size_t req_len;
StunAgent agent;
StunMessage msg;
StunMessage req_msg;
StunMessage refresh_msg;
uint32_t bandwidth, lifetime;
struct addrinfo hints, *res;
int ret = -1;
memset (&hints, 0, sizeof (hints));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_flags = 0;
ret = getaddrinfo (hostname, port, &hints, &res);
assert (ret == 0);
stun_agent_init (&agent, STUN_ALL_KNOWN_ATTRIBUTES,
STUN_COMPATIBILITY_RFC5389, STUN_AGENT_USAGE_LONG_TERM_CREDENTIALS);
/* Allocate a client socket and connect to server */
fd = socket (AF_INET, SOCK_DGRAM, 0);
assert (fd != -1);
val = connect (fd,res->ai_addr, res->ai_addrlen);
#ifdef G_OS_WIN32
assert (val == 0 || (WSAGetLastError () == WSAEINPROGRESS));
#else
assert (val == 0 || (errno == EINPROGRESS));
#endif
freeaddrinfo (res);
/* Send old-style response */
req_len = stun_usage_turn_create (&agent, &req_msg, req, sizeof(req),
NULL,
STUN_USAGE_TURN_REQUEST_PORT_NORMAL,
-1, -1,
username, strlen (username), password, strlen(password),
STUN_USAGE_TURN_COMPATIBILITY_DRAFT9);
assert (req_len > 0);
val = send (fd, req, req_len, MSG_NOSIGNAL);
assert (val >= 0);
val = recv (fd, buf, 1000, 0);
assert (val >= 0);
assert (stun_agent_validate (&agent, &msg, buf, val, NULL, NULL)
== STUN_VALIDATION_SUCCESS);
val = stun_usage_turn_process (&msg,
(struct sockaddr *)&relay_addr, &relay_addrlen,
(struct sockaddr *)&addr, &addrlen,
(struct sockaddr *)&alternate_addr, &alternate_addrlen,
&bandwidth, &lifetime,
STUN_USAGE_TURN_COMPATIBILITY_DRAFT9);
assert (val == STUN_USAGE_TURN_RETURN_ERROR);
req_len = stun_usage_turn_create (&agent, &req_msg, req, sizeof(req),
&msg,
STUN_USAGE_TURN_REQUEST_PORT_NORMAL,
-1, -1,
username, strlen (username), password, strlen(password),
STUN_USAGE_TURN_COMPATIBILITY_DRAFT9);
assert (req_len > 0);
val = send (fd, req, req_len, MSG_NOSIGNAL);
assert (val >= 0);
val = recv (fd, buf, 1000, 0);
assert (val >= 0);
assert (stun_agent_validate (&agent, &msg, buf, val, NULL, NULL)
== STUN_VALIDATION_SUCCESS);
val = stun_usage_turn_process (&msg,
(struct sockaddr *)&relay_addr, &relay_addrlen,
(struct sockaddr *)&addr, &addrlen,
(struct sockaddr *)&alternate_addr, &alternate_addrlen,
&bandwidth, &lifetime,
STUN_USAGE_TURN_COMPATIBILITY_DRAFT9);
assert (val == STUN_USAGE_TURN_RETURN_MAPPED_SUCCESS);
printaddr ("Relay address found : ", (struct sockaddr *)&relay_addr, relay_addrlen);
printaddr ("Mapped address found : ",(struct sockaddr *) &addr, addrlen);
req_len = stun_usage_turn_create_refresh (&agent, &refresh_msg, refresh,
sizeof(refresh), &req_msg, 0, username, strlen (username),
password, strlen(password),STUN_USAGE_TURN_COMPATIBILITY_DRAFT9);
assert (req_len > 0);
val = send (fd, refresh, req_len, MSG_NOSIGNAL);
assert (val >= 0);
val = recv (fd, buf, 1000, 0);
assert (val >= 0);
assert (stun_agent_validate (&agent, &msg, buf, val, NULL, NULL)
== STUN_VALIDATION_SUCCESS);
val = close (fd);
assert (val == 0);
}
static int
decode_select(struct tcb *tcp, long *args,
void (*print_tv_ts) (struct tcb *, const long),
const char * (*sprint_tv_ts) (struct tcb *, const long))
{
int i, j;
int nfds, fdsize;
fd_set *fds = NULL;
const char *sep;
long arg;
/* Kernel truncates arg[0] to int, we do the same. */
nfds = (int) args[0];
/* Kernel rejects negative nfds, so we don't parse it either. */
if (nfds < 0)
nfds = 0;
/* Beware of select(2^31-1, NULL, NULL, NULL) and similar... */
if (nfds > 1024*1024)
nfds = 1024*1024;
/*
* We had bugs a-la "while (j < args[0])" and "umoven(args[0])" below.
* Instead of args[0], use nfds for fd count, fdsize for array lengths.
*/
fdsize = (((nfds + 7) / 8) + current_wordsize-1) & -current_wordsize;
if (entering(tcp)) {
tprintf("%d", (int) args[0]);
if (verbose(tcp) && fdsize > 0)
fds = malloc(fdsize);
for (i = 0; i < 3; i++) {
arg = args[i+1];
tprints(", ");
if (!fds) {
printaddr(arg);
continue;
}
if (umoven_or_printaddr(tcp, arg, fdsize, fds))
continue;
tprints("[");
for (j = 0, sep = "";; j++) {
j = next_set_bit(fds, j, nfds);
if (j < 0)
break;
tprints(sep);
printfd(tcp, j);
sep = " ";
}
tprints("]");
}
free(fds);
tprints(", ");
print_tv_ts(tcp, args[4]);
} else {
static char outstr[1024];
char *outptr;
#define end_outstr (outstr + sizeof(outstr))
int ready_fds;
if (syserror(tcp))
return 0;
ready_fds = tcp->u_rval;
if (ready_fds == 0) {
tcp->auxstr = "Timeout";
return RVAL_STR;
}
fds = malloc(fdsize);
outptr = outstr;
sep = "";
for (i = 0; i < 3 && ready_fds > 0; i++) {
int first = 1;
arg = args[i+1];
if (!arg || !fds || umoven(tcp, arg, fdsize, fds) < 0)
continue;
for (j = 0;; j++) {
j = next_set_bit(fds, j, nfds);
if (j < 0)
break;
/* +2 chars needed at the end: ']',NUL */
if (outptr < end_outstr - (sizeof(", except [") + sizeof(int)*3 + 2)) {
if (first) {
outptr += sprintf(outptr, "%s%s [%u",
sep,
i == 0 ? "in" : i == 1 ? "out" : "except",
j
);
first = 0;
sep = ", ";
}
else {
outptr += sprintf(outptr, " %u", j);
}
}
if (--ready_fds == 0)
break;
}
if (outptr != outstr)
*outptr++ = ']';
}
free(fds);
/* This contains no useful information on SunOS. */
if (args[4]) {
const char *str = sprint_tv_ts(tcp, args[4]);
if (outptr + sizeof("left ") + strlen(sep) + strlen(str) < end_outstr) {
outptr += sprintf(outptr, "%sleft %s", sep, str);
}
}
*outptr = '\0';
tcp->auxstr = outstr;
return RVAL_STR;
#undef end_outstr
}
return 0;
}
static void
decode_msg_control(struct tcb *tcp, unsigned long addr,
const size_t in_control_len)
{
if (!in_control_len)
return;
tprints(", msg_control=");
const size_t cmsg_size =
#if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
(current_wordsize < sizeof(long)) ? sizeof(struct cmsghdr32) :
#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) {
printaddr(addr);
free(buf);
return;
}
union_cmsghdr u = { .ptr = buf };
tprints("[");
while (buf_len >= cmsg_size) {
const size_t cmsg_len =
#if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
(current_wordsize < sizeof(long)) ? u.cmsg32->cmsg_len :
#endif
u.cmsg->cmsg_len;
const int cmsg_level =
#if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
(current_wordsize < sizeof(long)) ? u.cmsg32->cmsg_level :
#endif
u.cmsg->cmsg_level;
const 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=");
size_t len = cmsg_len > buf_len ? buf_len : cmsg_len;
print_cmsg_type_data(tcp, cmsg_level, cmsg_type,
(const void *) (u.ptr + cmsg_size),
len > cmsg_size ? len - cmsg_size: 0);
tprints("}");
if (len < cmsg_size) {
buf_len -= cmsg_size;
break;
}
len = (cmsg_len + current_wordsize - 1) &
(size_t) ~(current_wordsize - 1);
if (len >= buf_len) {
buf_len = 0;
break;
}
u.ptr += len;
buf_len -= len;
}
if (buf_len) {
tprints(", ");
printaddr(addr + (control_len - buf_len));
} else if (control_len < in_control_len) {
tprints(", ...");
}
tprints("]");
free(buf);
}
static void
printcmsghdr(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);
char *buf = len < cmsg_size ? NULL : malloc(len);
if (!buf || umoven(tcp, addr, len, buf) < 0) {
tprints(", msg_control=");
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
displaysock(struct sock *s, int pos)
{
void *p;
int hash, first;
struct addr *laddr, *faddr;
struct sock *s_tmp;
while (pos < 29)
pos += xprintf(" ");
pos += xprintf("%s", s->protoname);
if (s->vflag & INP_IPV4)
pos += xprintf("4 ");
if (s->vflag & INP_IPV6)
pos += xprintf("6 ");
laddr = s->laddr;
faddr = s->faddr;
first = 1;
while (laddr != NULL || faddr != NULL) {
while (pos < 36)
pos += xprintf(" ");
switch (s->family) {
case AF_INET:
case AF_INET6:
if (laddr != NULL) {
pos += printaddr(&laddr->address);
if (s->family == AF_INET6 && pos >= 58)
pos += xprintf(" ");
}
while (pos < 58)
pos += xprintf(" ");
if (faddr != NULL)
pos += printaddr(&faddr->address);
break;
case AF_UNIX:
if ((laddr == NULL) || (faddr == NULL))
errx(1, "laddr = %p or faddr = %p is NULL",
(void *)laddr, (void *)faddr);
/* server */
if (laddr->address.ss_len > 0) {
pos += printaddr(&laddr->address);
break;
}
/* client */
p = *(void **)&(faddr->address);
if (p == NULL) {
pos += xprintf("(not connected)");
break;
}
pos += xprintf("-> ");
for (hash = 0; hash < HASHSIZE; ++hash) {
for (s_tmp = sockhash[hash];
s_tmp != NULL;
s_tmp = s_tmp->next)
if (s_tmp->pcb == p)
break;
if (s_tmp != NULL)
break;
}
if (s_tmp == NULL ||
s_tmp->laddr == NULL ||
s_tmp->laddr->address.ss_len == 0)
pos += xprintf("??");
else
pos += printaddr(&s_tmp->laddr->address);
break;
default:
abort();
}
if (first && opt_s &&
(s->proto == IPPROTO_SCTP || s->proto == IPPROTO_TCP)) {
while (pos < 80)
pos += xprintf(" ");
switch (s->proto) {
case IPPROTO_SCTP:
pos += xprintf("%s", sctp_state(s->state));
break;
case IPPROTO_TCP:
if (s->state >= 0 && s->state < TCP_NSTATES)
pos +=
xprintf("%s", tcpstates[s->state]);
else
pos += xprintf("?");
break;
}
}
if (laddr != NULL)
laddr = laddr->next;
if (faddr != NULL)
faddr = faddr->next;
if ((laddr != NULL) || (faddr != NULL)) {
xprintf("\n");
pos = 0;
}
first = 0;
}
xprintf("\n");
}
static int
ff_effect_ioctl(struct tcb *const tcp, const kernel_ulong_t arg)
{
tprints(", ");
struct_ff_effect ffe;
if (umove_or_printaddr(tcp, arg, &ffe))
return 1;
tprints("{type=");
printxval(evdev_ff_types, ffe.type, "FF_???");
tprintf(", id=%" PRIu16
", direction=%" PRIu16 ", ",
ffe.id,
ffe.direction);
if (abbrev(tcp)) {
tprints("...}");
return 1;
}
tprintf("trigger={button=%" PRIu16
", interval=%" PRIu16 "}"
", replay={length=%" PRIu16
", delay=%" PRIu16 "}",
ffe.trigger.button,
ffe.trigger.interval,
ffe.replay.length,
ffe.replay.delay);
switch (ffe.type) {
case FF_CONSTANT:
tprintf(", constant={level=%" PRId16,
ffe.u.constant.level);
decode_envelope(&ffe.u.constant.envelope);
tprints("}");
break;
case FF_RAMP:
tprintf(", ramp={start_level=%" PRId16
", end_level=%" PRId16,
ffe.u.ramp.start_level,
ffe.u.ramp.end_level);
decode_envelope(&ffe.u.ramp.envelope);
tprints("}");
break;
case FF_PERIODIC:
tprintf(", periodic={waveform=%" PRIu16
", period=%" PRIu16
", magnitude=%" PRId16
", offset=%" PRId16
", phase=%" PRIu16,
ffe.u.periodic.waveform,
ffe.u.periodic.period,
ffe.u.periodic.magnitude,
ffe.u.periodic.offset,
ffe.u.periodic.phase);
decode_envelope(&ffe.u.periodic.envelope);
tprintf(", custom_len=%u, custom_data=",
ffe.u.periodic.custom_len);
printaddr(ptr_to_kulong(ffe.u.periodic.custom_data));
tprints("}");
break;
case FF_RUMBLE:
tprintf(", rumble={strong_magnitude=%" PRIu16
", weak_magnitude=%" PRIu16 "}",
ffe.u.rumble.strong_magnitude,
ffe.u.rumble.weak_magnitude);
break;
default:
break;
}
tprints("}");
return 1;
}
static int
evdev_read_ioctl(struct tcb *const tcp, const unsigned int code,
const kernel_ulong_t arg)
{
/* fixed-number fixed-length commands */
switch (code) {
case EVIOCGVERSION:
tprints(", ");
printnum_int(tcp, arg, "%#x");
return 1;
case EVIOCGEFFECTS:
tprints(", ");
printnum_int(tcp, arg, "%u");
return 1;
case EVIOCGID:
return getid_ioctl(tcp, arg);
# ifdef EVIOCGREP
case EVIOCGREP:
return repeat_ioctl(tcp, arg);
# endif
case EVIOCGKEYCODE:
return keycode_ioctl(tcp, arg);
# ifdef EVIOCGKEYCODE_V2
case EVIOCGKEYCODE_V2:
return keycode_V2_ioctl(tcp, arg);
# endif
}
/* fixed-number variable-length commands */
switch (_IOC_NR(code)) {
# ifdef EVIOCGMTSLOTS
case _IOC_NR(EVIOCGMTSLOTS(0)):
return mtslots_ioctl(tcp, code, arg);
# endif
case _IOC_NR(EVIOCGNAME(0)):
case _IOC_NR(EVIOCGPHYS(0)):
case _IOC_NR(EVIOCGUNIQ(0)):
tprints(", ");
if (syserror(tcp))
printaddr(arg);
else
printstrn(tcp, arg, tcp->u_rval);
return 1;
# ifdef EVIOCGPROP
case _IOC_NR(EVIOCGPROP(0)):
return decode_bitset(tcp, arg, evdev_prop,
INPUT_PROP_MAX, "PROP_???");
# endif
case _IOC_NR(EVIOCGSND(0)):
return decode_bitset(tcp, arg, evdev_snd,
SND_MAX, "SND_???");
# ifdef EVIOCGSW
case _IOC_NR(EVIOCGSW(0)):
return decode_bitset(tcp, arg, evdev_switch,
SW_MAX, "SW_???");
# endif
case _IOC_NR(EVIOCGKEY(0)):
return decode_bitset(tcp, arg, evdev_keycode,
KEY_MAX, "KEY_???");
case _IOC_NR(EVIOCGLED(0)):
return decode_bitset(tcp, arg, evdev_leds,
LED_MAX, "LED_???");
}
/* multi-number fixed-length commands */
if ((_IOC_NR(code) & ~ABS_MAX) == _IOC_NR(EVIOCGABS(0)))
return abs_ioctl(tcp, arg);
/* multi-number variable-length commands */
if ((_IOC_NR(code) & ~EV_MAX) == _IOC_NR(EVIOCGBIT(0, 0)))
return bit_ioctl(tcp, _IOC_NR(code) & EV_MAX, arg);
return 0;
}
static void
printcmsghdr(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);
char *buf = len < cmsg_size ? NULL : malloc(len);
if (!buf || umoven(tcp, addr, len, buf) < 0) {
tprints(", msg_control=");
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;
if (cmsg_level == SOL_SOCKET) {
printxval(scmvals, cmsg_type, "SCM_???");
switch (cmsg_type) {
case SCM_RIGHTS:
if (print_scm_rights(tcp, cmsg_size, u.ptr, cmsg_len))
goto next_cmsg;
break;
case SCM_CREDENTIALS:
if (print_scm_creds(tcp, cmsg_size, u.ptr, cmsg_len))
goto next_cmsg;
break;
case SCM_SECURITY:
if (print_scm_security(tcp, cmsg_size, u.ptr, cmsg_len))
goto next_cmsg;
break;
}
} else {
tprintf("%u", cmsg_type);
}
tprints(", ...}");
next_cmsg:
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_group_req(struct tcb *tcp, long addr, int len)
{
struct group_req greq;
if (len != sizeof(greq) ||
umove(tcp, addr, &greq) < 0) {
printaddr(addr);
return;
}
union {
struct sockaddr *sa;
struct sockaddr_in *sin;
#ifdef HAVE_INET_NTOP
struct sockaddr_in6 *sin6;
#endif
} a = { .sa = (struct sockaddr *) &greq.gr_group };
#ifdef HAVE_INET_NTOP
char str[INET6_ADDRSTRLEN];
#endif
tprintf("{gr_interface=%u, gr_group={sa_family=", greq.gr_interface);
printxval(addrfams, a.sa->sa_family, "AF_???");
switch (a.sa->sa_family) {
case AF_INET:
tprintf(", sin_port=htons(%u), sin_addr=inet_addr(\"%s\")}}",
ntohs(a.sin->sin_port),
inet_ntoa(a.sin->sin_addr));
return;
#ifdef HAVE_INET_NTOP
case AF_INET6:
if (!inet_ntop(AF_INET6, &a.sin6->sin6_addr, str, sizeof(str)))
break;
tprintf(", sin6_port=htons(%u)"
", inet_pton(AF_INET6, \"%s\", &sin6_addr)}}",
ntohs(a.sin6->sin6_port), str);
return;
#endif /* HAVE_INET_NTOP */
}
tprints(", sa_data=");
print_quoted_string(a.sa->sa_data, sizeof(a.sa->sa_data), 0);
tprintf("}}");
}
#endif /* MCAST_JOIN_GROUP */
#ifdef PACKET_RX_RING
static void
print_tpacket_req(struct tcb *tcp, long addr, int len)
{
struct tpacket_req req;
if (len != sizeof(req) ||
umove(tcp, addr, &req) < 0) {
printaddr(addr);
} else {
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);
}
}
#endif /* PACKET_RX_RING */
#ifdef PACKET_ADD_MEMBERSHIP
# include "xlat/packet_mreq_type.h"
static void
print_packet_mreq(struct tcb *tcp, long addr, int len)
{
struct packet_mreq mreq;
if (len != sizeof(mreq) ||
umove(tcp, addr, &mreq) < 0) {
printaddr(addr);
} else {
unsigned int i;
tprintf("{mr_ifindex=%u, mr_type=", mreq.mr_ifindex);
printxval(packet_mreq_type, mreq.mr_type, "PACKET_MR_???");
tprintf(", mr_alen=%u, mr_address=", mreq.mr_alen);
if (mreq.mr_alen > ARRAY_SIZE(mreq.mr_address))
mreq.mr_alen = ARRAY_SIZE(mreq.mr_address);
for (i = 0; i < mreq.mr_alen; ++i)
tprintf("%02x", mreq.mr_address[i]);
tprints("}");
}
}
#endif /* PACKET_ADD_MEMBERSHIP */
static void
print_setsockopt(struct tcb *tcp, int level, int name, long addr, int len)
{
if (addr && verbose(tcp))
switch (level) {
case SOL_SOCKET:
switch (name) {
#ifdef SO_LINGER
case SO_LINGER:
print_linger(tcp, addr, len);
goto done;
#endif
}
break;
case SOL_IP:
switch (name) {
#ifdef IP_ADD_MEMBERSHIP
case IP_ADD_MEMBERSHIP:
case IP_DROP_MEMBERSHIP:
print_mreq(tcp, addr, len);
goto done;
#endif /* IP_ADD_MEMBERSHIP */
#ifdef MCAST_JOIN_GROUP
case MCAST_JOIN_GROUP:
case MCAST_LEAVE_GROUP:
print_group_req(tcp, addr, len);
goto done;
#endif /* MCAST_JOIN_GROUP */
}
break;
case SOL_IPV6:
switch (name) {
#ifdef IPV6_ADD_MEMBERSHIP
case IPV6_ADD_MEMBERSHIP:
case IPV6_DROP_MEMBERSHIP:
# ifdef IPV6_JOIN_ANYCAST
case IPV6_JOIN_ANYCAST:
# endif
# ifdef IPV6_LEAVE_ANYCAST
case IPV6_LEAVE_ANYCAST:
# endif
print_mreq6(tcp, addr, len);
goto done;
#endif /* IPV6_ADD_MEMBERSHIP */
}
break;
case SOL_PACKET:
switch (name) {
#ifdef PACKET_RX_RING
case PACKET_RX_RING:
# ifdef PACKET_TX_RING
case PACKET_TX_RING:
# endif
print_tpacket_req(tcp, addr, len);
goto done;
#endif /* PACKET_RX_RING */
#ifdef PACKET_ADD_MEMBERSHIP
case PACKET_ADD_MEMBERSHIP:
case PACKET_DROP_MEMBERSHIP:
print_packet_mreq(tcp, addr, len);
goto done;
#endif /* PACKET_ADD_MEMBERSHIP */
}
break;
case SOL_RAW:
switch (name) {
#ifdef ICMP_FILTER
case ICMP_FILTER:
print_icmp_filter(tcp, addr, len);
goto done;
#endif
}
break;
}
/* default arg printing */
if (verbose(tcp)) {
if (len == sizeof(int)) {
printnum_int(tcp, addr, "%d");
} else {
printstr(tcp, addr, len);
}
} else {
printaddr(addr);
}
done:
tprintf(", %d", len);
}
SYS_FUNC(setsockopt)
{
print_sockopt_fd_level_name(tcp, tcp->u_arg[0],
tcp->u_arg[1], tcp->u_arg[2]);
print_setsockopt(tcp, tcp->u_arg[1], tcp->u_arg[2],
tcp->u_arg[3], tcp->u_arg[4]);
return RVAL_DECODED;
}
