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; }