void store_fpr (sim_cpu *cpu, address_word cia, int fpr, FP_formats fmt, uword64 value) { int err = 0; #ifdef DEBUG printf ("DBG: StoreFPR: fpr = %d, fmt = %s, value = 0x%s : PC = 0x%s : SizeFGR () = %d, \n", fpr, fpu_format_name (fmt), pr_uword64 (value), pr_addr (cia), SizeFGR ()); #endif /* DEBUG */ if (SizeFGR () == 64) { switch (fmt) { case fmt_uninterpreted_32: fmt = fmt_uninterpreted; case fmt_single: case fmt_word: if (STATE_VERBOSE_P (SD)) sim_io_eprintf (SD, "Warning: PC 0x%s: interp.c store_fpr DEADCODE\n", pr_addr (cia)); FGR[fpr] = (((uword64) 0xDEADC0DE << 32) | (value & 0xFFFFFFFF)); FPR_STATE[fpr] = fmt; break; case fmt_uninterpreted_64: fmt = fmt_uninterpreted; case fmt_uninterpreted: case fmt_double: case fmt_long: case fmt_ps: FGR[fpr] = value; FPR_STATE[fpr] = fmt; break; default: FPR_STATE[fpr] = fmt_unknown; err = -1; break; } } else { switch (fmt) { case fmt_uninterpreted_32: fmt = fmt_uninterpreted; case fmt_single: case fmt_word: FGR[fpr] = (value & 0xFFFFFFFF); FPR_STATE[fpr] = fmt; break; case fmt_uninterpreted_64: fmt = fmt_uninterpreted; case fmt_uninterpreted: case fmt_double: case fmt_long: if ((fpr & 1) == 0) { /* Even register numbers only. */ FGR[fpr+1] = (value >> 32); FGR[fpr] = (value & 0xFFFFFFFF); FPR_STATE[fpr + 1] = fmt; FPR_STATE[fpr] = fmt; } else { FPR_STATE[fpr] = fmt_unknown; FPR_STATE[fpr ^ 1] = fmt_unknown; SignalException (ReservedInstruction, 0); } break; case fmt_ps: FPR_STATE[fpr] = fmt_unknown; SignalException (ReservedInstruction, 0); break; default: FPR_STATE[fpr] = fmt_unknown; err = -1; break; }
int main(int argc, char *argv[]) { int ch, hold, packlen; u_char *packet; char *target; struct addrinfo hints, *ai; int gai; struct sockaddr_in6 firsthop; int socket_errno = 0; struct icmp6_filter filter; int err; #ifdef __linux__ int csum_offset, sz_opt; #endif static uint32_t scope_id = 0; #ifdef ANDROID android_check_security(); #endif limit_capabilities(); #ifdef USE_IDN setlocale(LC_ALL, ""); #endif icmp_sock = socket(AF_INET6, SOCK_DGRAM, IPPROTO_ICMPV6); if (icmp_sock < 0) { enable_capability_raw(); icmp_sock = socket(AF_INET6, SOCK_RAW, IPPROTO_ICMPV6); socket_errno = errno; disable_capability_raw(); using_ping_socket = 0; } source.sin6_family = AF_INET6; memset(&firsthop, 0, sizeof(firsthop)); firsthop.sin6_family = AF_INET6; preload = 1; while ((ch = getopt(argc, argv, COMMON_OPTSTR "F:N:")) != EOF) { switch(ch) { case 'F': flowlabel = hextoui(optarg); if (errno || (flowlabel & ~IPV6_FLOWINFO_FLOWLABEL)) { fprintf(stderr, "ping: Invalid flowinfo %s\n", optarg); exit(2); } options |= F_FLOWINFO; break; case 'Q': tclass = hextoui(optarg); if (errno || (tclass & ~0xff)) { fprintf(stderr, "ping: Invalid tclass %s\n", optarg); exit(2); } options |= F_TCLASS; break; case 'I': if (strchr(optarg, ':')) { char *p, *addr = strdup(optarg); if (!addr) { fprintf(stderr, "ping: out of memory\n"); exit(2); } p = strchr(addr, SCOPE_DELIMITER); if (p) { *p = '\0'; device = optarg + (p - addr) + 1; } if (inet_pton(AF_INET6, addr, (char*)&source.sin6_addr) <= 0) { fprintf(stderr, "ping: invalid source address %s\n", optarg); exit(2); } options |= F_STRICTSOURCE; free(addr); } else { device = optarg; } break; case 'M': if (strcmp(optarg, "do") == 0) pmtudisc = IPV6_PMTUDISC_DO; else if (strcmp(optarg, "dont") == 0) pmtudisc = IPV6_PMTUDISC_DONT; else if (strcmp(optarg, "want") == 0) pmtudisc = IPV6_PMTUDISC_WANT; else { fprintf(stderr, "ping: wrong value for -M: do, dont, want are valid ones.\n"); exit(2); } break; case 'V': printf("ping6 utility, iputils-%s\n", SNAPSHOT); exit(0); case 'N': if (using_ping_socket) { fprintf(stderr, "ping: -N requires raw socket permissions\n"); exit(2); } if (niquery_option_handler(optarg) < 0) { usage(); break; } break; COMMON_OPTIONS common_options(ch); break; default: usage(); } } argc -= optind; argv += optind; #ifdef ENABLE_PING6_RTHDR while (argc > 1) { struct in6_addr *addr; if (srcrt == NULL) { int space; fprintf(stderr, "ping6: Warning: " "Source routing is deprecated by RFC5095.\n"); #ifdef ENABLE_PING6_RTHDR_RFC3542 space = inet6_rth_space(IPV6_RTHDR_TYPE_0, argc - 1); #else space = inet6_srcrt_space(IPV6_SRCRT_TYPE_0, argc - 1); #endif if (space == 0) { fprintf(stderr, "srcrt_space failed\n"); exit(2); } #ifdef ENABLE_PING6_RTHDR_RFC3542 if (cmsglen + CMSG_SPACE(space) > sizeof(cmsgbuf)) { fprintf(stderr, "no room for options\n"); exit(2); } #else if (space + cmsglen > sizeof(cmsgbuf)) { fprintf(stderr, "no room for options\n"); exit(2); } #endif srcrt = (struct cmsghdr*)(cmsgbuf+cmsglen); #ifdef ENABLE_PING6_RTHDR_RFC3542 memset(srcrt, 0, CMSG_SPACE(0)); srcrt->cmsg_len = CMSG_LEN(space); srcrt->cmsg_level = IPPROTO_IPV6; srcrt->cmsg_type = IPV6_RTHDR; inet6_rth_init(CMSG_DATA(srcrt), space, IPV6_RTHDR_TYPE_0, argc - 1); cmsglen += CMSG_SPACE(space); #else cmsglen += CMSG_ALIGN(space); inet6_srcrt_init(srcrt, IPV6_SRCRT_TYPE_0); #endif } target = *argv; memset(&hints, 0, sizeof(hints)); hints.ai_family = AF_INET6; #ifdef USE_IDN hints.ai_flags = AI_IDN; #endif gai = getaddrinfo(target, NULL, &hints, &ai); if (gai) { fprintf(stderr, "unknown host\n"); exit(2); } addr = &((struct sockaddr_in6 *)(ai->ai_addr))->sin6_addr; #ifdef ENABLE_PING6_RTHDR_RFC3542 inet6_rth_add(CMSG_DATA(srcrt), addr); #else inet6_srcrt_add(srcrt, addr); #endif if (IN6_IS_ADDR_UNSPECIFIED(&firsthop.sin6_addr)) { memcpy(&firsthop.sin6_addr, addr, 16); #ifdef HAVE_SIN6_SCOPEID firsthop.sin6_scope_id = ((struct sockaddr_in6 *)(ai->ai_addr))->sin6_scope_id; /* Verify scope_id is the same as previous nodes */ if (firsthop.sin6_scope_id && scope_id && firsthop.sin6_scope_id != scope_id) { fprintf(stderr, "scope discrepancy among the nodes\n"); exit(2); } else if (!scope_id) { scope_id = firsthop.sin6_scope_id; } #endif } freeaddrinfo(ai); argv++; argc--; } #endif if (niquery_is_enabled()) { niquery_init_nonce(); if (!niquery_is_subject_valid()) { ni_subject = &whereto.sin6_addr; ni_subject_len = sizeof(whereto.sin6_addr); ni_subject_type = NI_SUBJ_IPV6; } } if (argc > 1) { #ifndef ENABLE_PING6_RTHDR fprintf(stderr, "ping6: Source routing is deprecated by RFC5095.\n"); #endif usage(); } else if (argc == 1) { target = *argv; } else { if (ni_query < 0 && ni_subject_type != NI_SUBJ_NAME) usage(); target = ni_group; } memset(&hints, 0, sizeof(hints)); hints.ai_family = AF_INET6; #ifdef USE_IDN hints.ai_flags = AI_IDN; #endif gai = getaddrinfo(target, NULL, &hints, &ai); if (gai) { fprintf(stderr, "unknown host\n"); exit(2); } memcpy(&whereto, ai->ai_addr, sizeof(whereto)); whereto.sin6_port = htons(IPPROTO_ICMPV6); if (memchr(target, ':', strlen(target))) options |= F_NUMERIC; freeaddrinfo(ai); if (IN6_IS_ADDR_UNSPECIFIED(&firsthop.sin6_addr)) { memcpy(&firsthop.sin6_addr, &whereto.sin6_addr, 16); #ifdef HAVE_SIN6_SCOPEID firsthop.sin6_scope_id = whereto.sin6_scope_id; /* Verify scope_id is the same as intermediate nodes */ if (firsthop.sin6_scope_id && scope_id && firsthop.sin6_scope_id != scope_id) { fprintf(stderr, "scope discrepancy among the nodes\n"); exit(2); } else if (!scope_id) { scope_id = firsthop.sin6_scope_id; } #endif } hostname = target; if (IN6_IS_ADDR_UNSPECIFIED(&source.sin6_addr)) { socklen_t alen; int probe_fd = socket(AF_INET6, SOCK_DGRAM, 0); if (probe_fd < 0) { perror("socket"); exit(2); } if (device) { #if defined(IPV6_RECVPKTINFO) || defined(HAVE_SIN6_SCOPEID) unsigned int iface = if_name2index(device); #endif #ifdef IPV6_RECVPKTINFO struct in6_pktinfo ipi; memset(&ipi, 0, sizeof(ipi)); ipi.ipi6_ifindex = iface; #endif #ifdef HAVE_SIN6_SCOPEID if (IN6_IS_ADDR_LINKLOCAL(&firsthop.sin6_addr) || IN6_IS_ADDR_MC_LINKLOCAL(&firsthop.sin6_addr)) firsthop.sin6_scope_id = iface; #endif enable_capability_raw(); if ( #ifdef IPV6_RECVPKTINFO setsockopt(probe_fd, IPPROTO_IPV6, IPV6_PKTINFO, &ipi, sizeof(ipi)) == -1 && #endif setsockopt(probe_fd, SOL_SOCKET, SO_BINDTODEVICE, device, strlen(device)+1) == -1) { perror("setsockopt(SO_BINDTODEVICE)"); exit(2); } disable_capability_raw(); } firsthop.sin6_port = htons(1025); if (connect(probe_fd, (struct sockaddr*)&firsthop, sizeof(firsthop)) == -1) { perror("connect"); exit(2); } alen = sizeof(source); if (getsockname(probe_fd, (struct sockaddr*)&source, &alen) == -1) { perror("getsockname"); exit(2); } source.sin6_port = 0; close(probe_fd); #ifndef WITHOUT_IFADDRS if (device) { struct ifaddrs *ifa0, *ifa; if (getifaddrs(&ifa0)) { perror("getifaddrs"); exit(2); } for (ifa = ifa0; ifa; ifa = ifa->ifa_next) { if (!ifa->ifa_addr || ifa->ifa_addr->sa_family != AF_INET6) continue; if (!strncmp(ifa->ifa_name, device, sizeof(device) - 1) && IN6_ARE_ADDR_EQUAL(&((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_addr, &source.sin6_addr)) break; } if (!ifa) fprintf(stderr, "ping6: Warning: source address might be selected on device other than %s.\n", device); freeifaddrs(ifa0); } #endif } #ifdef HAVE_SIN6_SCOPEID else if (device && (IN6_IS_ADDR_LINKLOCAL(&source.sin6_addr) || IN6_IS_ADDR_MC_LINKLOCAL(&source.sin6_addr))) source.sin6_scope_id = if_name2index(device); #endif if (icmp_sock < 0) { errno = socket_errno; perror("ping: icmp open socket"); exit(2); } if (device) { struct cmsghdr *cmsg; struct in6_pktinfo *ipi; cmsg = (struct cmsghdr*)(cmsgbuf+cmsglen); cmsglen += CMSG_SPACE(sizeof(*ipi)); cmsg->cmsg_len = CMSG_LEN(sizeof(*ipi)); cmsg->cmsg_level = SOL_IPV6; cmsg->cmsg_type = IPV6_PKTINFO; ipi = (struct in6_pktinfo*)CMSG_DATA(cmsg); memset(ipi, 0, sizeof(*ipi)); ipi->ipi6_ifindex = if_name2index(device); } if ((whereto.sin6_addr.s6_addr16[0]&htons(0xff00)) == htons (0xff00)) { if (uid) { if (interval < 1000) { fprintf(stderr, "ping: multicast ping with too short interval.\n"); exit(2); } if (pmtudisc >= 0 && pmtudisc != IPV6_PMTUDISC_DO) { fprintf(stderr, "ping: multicast ping does not fragment.\n"); exit(2); } } if (pmtudisc < 0) pmtudisc = IPV6_PMTUDISC_DO; } if (pmtudisc >= 0) { if (setsockopt(icmp_sock, SOL_IPV6, IPV6_MTU_DISCOVER, &pmtudisc, sizeof(pmtudisc)) == -1) { perror("ping: IPV6_MTU_DISCOVER"); exit(2); } } if ((options&F_STRICTSOURCE) && bind(icmp_sock, (struct sockaddr*)&source, sizeof(source)) == -1) { perror("ping: bind icmp socket"); exit(2); } if (datalen >= sizeof(struct timeval) && (ni_query < 0)) { /* can we time transfer */ timing = 1; } packlen = datalen + 8 + 4096 + 40 + 8; /* 4096 for rthdr */ if (!(packet = (u_char *)malloc((u_int)packlen))) { fprintf(stderr, "ping: out of memory.\n"); exit(2); } working_recverr = 1; hold = 1; if (setsockopt(icmp_sock, SOL_IPV6, IPV6_RECVERR, (char *)&hold, sizeof(hold))) { fprintf(stderr, "WARNING: your kernel is veeery old. No problems.\n"); working_recverr = 0; } /* Estimate memory eaten by single packet. It is rough estimate. * Actually, for small datalen's it depends on kernel side a lot. */ hold = datalen+8; hold += ((hold+511)/512)*(40+16+64+160); sock_setbufs(icmp_sock, hold); if (!using_ping_socket) { #ifdef __linux__ csum_offset = 2; sz_opt = sizeof(int); err = setsockopt(icmp_sock, SOL_RAW, IPV6_CHECKSUM, &csum_offset, sz_opt); if (err < 0) { /* checksum should be enabled by default and setting * this option might fail anyway. */ fprintf(stderr, "setsockopt(RAW_CHECKSUM) failed" " - try to continue."); } #endif /* * select icmp echo reply as icmp type to receive */ ICMP6_FILTER_SETBLOCKALL(&filter); if (!working_recverr) { ICMP6_FILTER_SETPASS(ICMP6_DST_UNREACH, &filter); ICMP6_FILTER_SETPASS(ICMP6_PACKET_TOO_BIG, &filter); ICMP6_FILTER_SETPASS(ICMP6_TIME_EXCEEDED, &filter); ICMP6_FILTER_SETPASS(ICMP6_PARAM_PROB, &filter); } if (niquery_is_enabled()) ICMP6_FILTER_SETPASS(ICMPV6_NI_REPLY, &filter); else ICMP6_FILTER_SETPASS(ICMP6_ECHO_REPLY, &filter); err = setsockopt(icmp_sock, IPPROTO_ICMPV6, ICMP6_FILTER, &filter, sizeof(struct icmp6_filter)); if (err < 0) { perror("setsockopt(ICMP6_FILTER)"); exit(2); } } if (options & F_NOLOOP) { int loop = 0; if (setsockopt(icmp_sock, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &loop, sizeof(loop)) == -1) { perror ("can't disable multicast loopback"); exit(2); } } if (options & F_TTL) { if (setsockopt(icmp_sock, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &ttl, sizeof(ttl)) == -1) { perror ("can't set multicast hop limit"); exit(2); } if (setsockopt(icmp_sock, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &ttl, sizeof(ttl)) == -1) { perror ("can't set unicast hop limit"); exit(2); } } if (1) { int on = 1; if ( #ifdef IPV6_RECVHOPLIMIT setsockopt(icmp_sock, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &on, sizeof(on)) == -1 && setsockopt(icmp_sock, IPPROTO_IPV6, IPV6_2292HOPLIMIT, &on, sizeof(on)) == -1 #else setsockopt(icmp_sock, IPPROTO_IPV6, IPV6_HOPLIMIT, &on, sizeof(on)) == -1 #endif ){ perror ("can't receive hop limit"); exit(2); } } if (options & F_TCLASS) { #ifdef IPV6_TCLASS if (setsockopt(icmp_sock, IPPROTO_IPV6, IPV6_TCLASS, &tclass, sizeof(tclass)) == -1) { perror ("setsockopt(IPV6_TCLASS)"); exit(2); } #else fprintf(stderr, "Traffic class is not supported.\n"); #endif } if (options&F_FLOWINFO) { #ifdef IPV6_FLOWINFO_SEND int on = 1; #endif #ifdef IPV6_FLOWLABEL_MGR char freq_buf[CMSG_ALIGN(sizeof(struct in6_flowlabel_req)) + cmsglen]; struct in6_flowlabel_req *freq = (struct in6_flowlabel_req *)freq_buf; int freq_len = sizeof(*freq); #ifdef ENABLE_PING6_RTHDR if (srcrt) freq_len = CMSG_ALIGN(sizeof(*freq)) + srcrt->cmsg_len; #endif memset(freq, 0, sizeof(*freq)); freq->flr_label = htonl(flowlabel & IPV6_FLOWINFO_FLOWLABEL); freq->flr_action = IPV6_FL_A_GET; freq->flr_flags = IPV6_FL_F_CREATE; freq->flr_share = IPV6_FL_S_EXCL; memcpy(&freq->flr_dst, &whereto.sin6_addr, 16); #ifdef ENABLE_PING6_RTHDR if (srcrt) memcpy(freq_buf + CMSG_ALIGN(sizeof(*freq)), srcrt, srcrt->cmsg_len); #endif if (setsockopt(icmp_sock, IPPROTO_IPV6, IPV6_FLOWLABEL_MGR, freq, freq_len) == -1) { perror ("can't set flowlabel"); exit(2); } flowlabel = freq->flr_label; #ifdef ENABLE_PING6_RTHDR if (srcrt) { cmsglen = (char*)srcrt - (char*)cmsgbuf; srcrt = NULL; } #endif #else fprintf(stderr, "Flow labels are not supported.\n"); exit(2); #endif #ifdef IPV6_FLOWINFO_SEND whereto.sin6_flowinfo = flowlabel; if (setsockopt(icmp_sock, IPPROTO_IPV6, IPV6_FLOWINFO_SEND, &on, sizeof(on)) == -1) { perror ("can't send flowinfo"); exit(2); } #else fprintf(stderr, "Flowinfo is not supported.\n"); exit(2); #endif } printf("PING %s(%s) ", hostname, pr_addr(&whereto.sin6_addr)); if (flowlabel) printf(", flow 0x%05x, ", (unsigned)ntohl(flowlabel)); if (device || (options&F_STRICTSOURCE)) { printf("from %s %s: ", pr_addr_n(&source.sin6_addr), device ? : ""); }
uword64 value_fpr (sim_cpu *cpu, address_word cia, int fpr, FP_formats fmt) { uword64 value = 0; int err = 0; /* Treat unused register values, as fixed-point 64bit values. */ if (fmt == fmt_unknown) { #if 1 /* If request to read data as "unknown", then use the current encoding: */ fmt = FPR_STATE[fpr]; #else fmt = fmt_long; #endif } /* For values not yet accessed, set to the desired format. */ if (fmt < fmt_uninterpreted) { if (FPR_STATE[fpr] == fmt_uninterpreted) { FPR_STATE[fpr] = fmt; #ifdef DEBUG printf ("DBG: Register %d was fmt_uninterpreted. Now %s\n", fpr, fpu_format_name (fmt)); #endif /* DEBUG */ } else if (fmt != FPR_STATE[fpr]) { sim_io_eprintf (SD, "FPR %d (format %s) being accessed with format %s - setting to unknown (PC = 0x%s)\n", fpr, fpu_format_name (FPR_STATE[fpr]), fpu_format_name (fmt), pr_addr (cia)); FPR_STATE[fpr] = fmt_unknown; } } if (FPR_STATE[fpr] == fmt_unknown) { /* Set QNaN value: */ switch (fmt) { case fmt_single: value = FPQNaN_SINGLE; break; case fmt_double: value = FPQNaN_DOUBLE; break; case fmt_word: value = FPQNaN_WORD; break; case fmt_long: value = FPQNaN_LONG; break; case fmt_ps: value = FPQNaN_PS; break; default: err = -1; break; } } else if (SizeFGR () == 64) { switch (fmt) { case fmt_uninterpreted_32: case fmt_single: case fmt_word: value = (FGR[fpr] & 0xFFFFFFFF); break; case fmt_uninterpreted_64: case fmt_uninterpreted: case fmt_double: case fmt_long: case fmt_ps: value = FGR[fpr]; break; default: err = -1; break; } } else { switch (fmt) { case fmt_uninterpreted_32: case fmt_single: case fmt_word: value = (FGR[fpr] & 0xFFFFFFFF); break; case fmt_uninterpreted_64: case fmt_uninterpreted: case fmt_double: case fmt_long: if ((fpr & 1) == 0) { /* Even register numbers only. */ #ifdef DEBUG printf ("DBG: ValueFPR: FGR[%d] = %s, FGR[%d] = %s\n", fpr + 1, pr_uword64 ((uword64) FGR[fpr+1]), fpr, pr_uword64 ((uword64) FGR[fpr])); #endif value = ((((uword64) FGR[fpr+1]) << 32) | (FGR[fpr] & 0xFFFFFFFF)); } else { SignalException (ReservedInstruction, 0); } break; case fmt_ps: SignalException (ReservedInstruction, 0); break; default: err = -1; break; } } if (err) SignalExceptionSimulatorFault ("Unrecognised FP format in ValueFPR ()"); #ifdef DEBUG printf ("DBG: ValueFPR: fpr = %d, fmt = %s, value = 0x%s : PC = 0x%s : SizeFGR () = %d\n", fpr, fpu_format_name (fmt), pr_uword64 (value), pr_addr (cia), SizeFGR ()); #endif /* DEBUG */ return (value); }