static uint8_t *hash_file(const char *filename /*, hash_algo_t hash_algo*/) { int src_fd, hash_len, count; union _ctx_ { sha512_ctx_t sha512; sha256_ctx_t sha256; sha1_ctx_t sha1; md5_ctx_t md5; } context; uint8_t *hash_value = NULL; RESERVE_CONFIG_UBUFFER(in_buf, 4096); void FAST_FUNC (*update)(const void*, size_t, void*); void FAST_FUNC (*final)(void*, void*); hash_algo_t hash_algo = applet_name[3]; src_fd = open_or_warn_stdin(filename); if (src_fd < 0) { return NULL; } /* figure specific hash algorithims */ if (ENABLE_MD5SUM && hash_algo == HASH_MD5) { md5_begin(&context.md5); update = (void*)md5_hash; final = (void*)md5_end;
extern int tr_main(int argc, char **argv) { register unsigned char *ptr; int output_length=0, input_length; int idx = 1; int i; RESERVE_CONFIG_BUFFER(output, BUFSIZ); RESERVE_CONFIG_BUFFER(input, BUFSIZ); RESERVE_CONFIG_UBUFFER(vector, ASCII+1); RESERVE_CONFIG_BUFFER(invec, ASCII+1); RESERVE_CONFIG_BUFFER(outvec, ASCII+1); /* ... but make them available globally */ poutput = output; pinput = input; pvector = vector; pinvec = invec; poutvec = outvec; if (argc > 1 && argv[idx][0] == '-') { for (ptr = (unsigned char *) &argv[idx][1]; *ptr; ptr++) { switch (*ptr) { case 'c': com_fl = TRUE; break; case 'd': del_fl = TRUE; break; case 's': sq_fl = TRUE; break; default: bb_show_usage(); } } idx++; } for (i = 0; i <= ASCII; i++) { vector[i] = i; invec[i] = outvec[i] = FALSE; } if (argv[idx] != NULL) { input_length = expand(argv[idx++], input); if (com_fl) input_length = complement(input, input_length); if (argv[idx] != NULL) { if (*argv[idx] == '\0') bb_error_msg_and_die("STRING2 cannot be empty"); output_length = expand(argv[idx], output); map(input, input_length, output, output_length); } for (i = 0; i < input_length; i++) invec[(unsigned char)input[i]] = TRUE; for (i = 0; i < output_length; i++) outvec[(unsigned char)output[i]] = TRUE; } convert(); return (0); }
int tr_main(int argc, char **argv) { unsigned char *ptr; int output_length = 0, input_length; int idx = 1; int i; smalluint flags = 0; RESERVE_CONFIG_UBUFFER(output, BUFSIZ); RESERVE_CONFIG_BUFFER(vector, ASCII+1); RESERVE_CONFIG_BUFFER(invec, ASCII+1); RESERVE_CONFIG_BUFFER(outvec, ASCII+1); /* ... but make them available globally */ poutput = output; pvector = vector; pinvec = invec; poutvec = outvec; if (argc > 1 && argv[idx][0] == '-') { for (ptr = (unsigned char *) &argv[idx][1]; *ptr; ptr++) { if (*ptr == 'c') flags |= TR_OPT_complement; else if (*ptr == 'd') flags |= TR_OPT_delete; else if (*ptr == 's') flags |= TR_OPT_squeeze_reps; else bb_show_usage(); } idx++; } for (i = 0; i <= ASCII; i++) { vector[i] = i; invec[i] = outvec[i] = FALSE; } if (argv[idx] != NULL) { input_length = expand(argv[idx++], bb_common_bufsiz1); if (flags & TR_OPT_complement) input_length = complement(bb_common_bufsiz1, input_length); if (argv[idx] != NULL) { if (*argv[idx] == '\0') bb_error_msg_and_die("STRING2 cannot be empty"); output_length = expand(argv[idx], output); map(bb_common_bufsiz1, input_length, output, output_length); } for (i = 0; i < input_length; i++) invec[(unsigned char)bb_common_bufsiz1[i]] = TRUE; for (i = 0; i < output_length; i++) outvec[output[i]] = TRUE; } convert(flags); return EXIT_SUCCESS; }
static uint8_t *hash_file(const char *filename, uint8_t hash_algo) { int src_fd = strcmp(filename, "-") == 0 ? STDIN_FILENO : open(filename, O_RDONLY); if (src_fd == -1) { bb_perror_msg("%s", filename); return NULL; } else { uint8_t *hash_value; RESERVE_CONFIG_UBUFFER(hash_value_bin, 20); hash_value = hash_fd(src_fd, -1, hash_algo, hash_value_bin) != -2 ? hash_bin_to_hex(hash_value_bin, hash_algo == HASH_MD5 ? 16 : 20) : NULL; RELEASE_CONFIG_BUFFER(hash_value_bin); close(src_fd); return hash_value; } }
static int send_pack(int sock, struct in_addr *src_addr, struct in_addr *dst_addr, struct sockaddr_ll *ME, struct sockaddr_ll *HE) { int err; struct timeval now; RESERVE_CONFIG_UBUFFER(buf, 256); struct arphdr *ah = (struct arphdr *) buf; unsigned char *p = (unsigned char *) (ah + 1); ah->ar_hrd = htons(ME->sll_hatype); ah->ar_hrd = htons(ARPHRD_ETHER); ah->ar_pro = htons(ETH_P_IP); ah->ar_hln = ME->sll_halen; ah->ar_pln = 4; ah->ar_op = cfg & advert ? htons(ARPOP_REPLY) : htons(ARPOP_REQUEST); memcpy(p, &ME->sll_addr, ah->ar_hln); p += ME->sll_halen; memcpy(p, src_addr, 4); p += 4; if (cfg & advert) memcpy(p, &ME->sll_addr, ah->ar_hln); else memcpy(p, &HE->sll_addr, ah->ar_hln); p += ah->ar_hln; memcpy(p, dst_addr, 4); p += 4; gettimeofday(&now, NULL); err = sendto(sock, buf, p - buf, 0, (struct sockaddr *) HE, sizeof(*HE)); if (err == p - buf) { last = now; sent++; if (!(cfg & unicasting)) brd_sent++; } RELEASE_CONFIG_BUFFER(buf); return err; }
static uint8_t *hash_file(const char *filename, hash_algo_t hash_algo) { int src_fd, hash_len, count; union _ctx_ { sha1_ctx_t sha1; md5_ctx_t md5; } context; uint8_t *hash_value = NULL; RESERVE_CONFIG_UBUFFER(in_buf, 4096); void (*update)(const void*, size_t, void*); void (*final)(void*, void*); if (strcmp(filename, "-") == 0) { src_fd = STDIN_FILENO; } else if(0 > (src_fd = open(filename, O_RDONLY))) { bb_perror_msg("%s", filename); return NULL; } /* figure specific hash algorithims */ if (ENABLE_MD5SUM && hash_algo==HASH_MD5) { md5_begin(&context.md5); update = (void (*)(const void*, size_t, void*))md5_hash; final = (void (*)(void*, void*))md5_end;
int flashcp_main(int argc UNUSED_PARAM, char **argv) { int fd_f, fd_d; /* input file and mtd device file descriptors */ int i; uoff_t erase_count; struct mtd_info_user mtd; struct erase_info_user e; struct stat statb; // const char *filename, *devicename; RESERVE_CONFIG_UBUFFER(buf, BUFSIZE); RESERVE_CONFIG_UBUFFER(buf2, BUFSIZE); opt_complementary = "=2"; /* exactly 2 non-option args: file, dev */ /*opts =*/ getopt32(argv, "v"); argv += optind; // filename = *argv++; // devicename = *argv; #define filename argv[0] #define devicename argv[1] /* open input file and mtd device and do sanity checks */ fd_f = xopen(filename, O_RDONLY); fstat(fd_f, &statb); fd_d = xopen(devicename, O_SYNC | O_RDWR); #if !MTD_DEBUG if (ioctl(fd_d, MEMGETINFO, &mtd) < 0) { bb_error_msg_and_die("%s is not a MTD flash device", devicename); } if (statb.st_size > mtd.size) { bb_error_msg_and_die("%s bigger than %s", filename, devicename); } #else mtd.erasesize = 64 * 1024; #endif /* always erase a complete block */ erase_count = (uoff_t)(statb.st_size + mtd.erasesize - 1) / mtd.erasesize; /* erase 1 block at a time to be able to give verbose output */ e.length = mtd.erasesize; #if 0 /* (1) bloat * (2) will it work for multi-gigabyte devices? * (3) worse wrt error detection granularity */ /* optimization: if not verbose, erase in one go */ if (!opts) { // if (!(opts & OPT_v)) e.length = mtd.erasesize * erase_count; erase_count = 1; } #endif e.start = 0; for (i = 1; i <= erase_count; i++) { progress(-1, i, erase_count); #if !MTD_DEBUG if (ioctl(fd_d, MEMERASE, &e) < 0) { bb_perror_msg_and_die("erase error at 0x%llx on %s", (long long)e.start, devicename); } #else usleep(100*1000); #endif e.start += mtd.erasesize; } progress_newline(); /* doing this outer loop gives significantly smaller code * than doing two separate loops for writing and verifying */ for (i = 0; i <= 1; i++) { uoff_t done; unsigned count; xlseek(fd_f, 0, SEEK_SET); xlseek(fd_d, 0, SEEK_SET); done = 0; count = BUFSIZE; while (1) { uoff_t rem; progress(i, done / 1024, (uoff_t)statb.st_size / 1024); rem = statb.st_size - done; if (rem == 0) break; if (rem < BUFSIZE) count = rem; xread(fd_f, buf, count); if (i == 0) { int ret; if (count < BUFSIZE) memset((char*)buf + count, 0, BUFSIZE - count); errno = 0; ret = full_write(fd_d, buf, BUFSIZE); if (ret != BUFSIZE) { bb_perror_msg_and_die("write error at 0x%"OFF_FMT"x on %s, " "write returned %d", done, devicename, ret); } } else { /* i == 1 */ xread(fd_d, buf2, count); if (memcmp(buf, buf2, count) != 0) { bb_error_msg_and_die("verification mismatch at 0x%"OFF_FMT"x", done); } } done += count; } progress_newline(); } /* we won't come here if there was an error */ return EXIT_SUCCESS; }
int arping_main(int argc, char **argv) { const char *device = "eth0"; int ifindex; char *source = NULL; char *target; s = xsocket(PF_PACKET, SOCK_DGRAM, 0); // Drop suid root privileges xsetuid(getuid()); { unsigned opt; char *_count, *_timeout; /* Dad also sets quit_on_reply. * Advert also sets unsolicited. */ opt_complementary = "Df:AU"; opt = getopt32(argc, argv, "DUAqfbc:w:i:s:", &_count, &_timeout, &device, &source); cfg |= opt & 0x3f; /* set respective flags */ if (opt & 0x40) /* -c: count */ count = xatou(_count); if (opt & 0x80) /* -w: timeout */ timeout = xatoul_range(_timeout, 0, INT_MAX/2000); //if (opt & 0x100) /* -i: interface */ if (strlen(device) > IF_NAMESIZE) { bb_error_msg_and_die("interface name '%s' is too long", device); } //if (opt & 0x200) /* -s: source */ } argc -= optind; argv += optind; if (argc != 1) bb_show_usage(); target = *argv; xfunc_error_retval = 2; { struct ifreq ifr; memset(&ifr, 0, sizeof(ifr)); strncpy(ifr.ifr_name, device, IFNAMSIZ - 1); if (ioctl(s, SIOCGIFINDEX, &ifr) < 0) { bb_error_msg_and_die("interface %s not found", device); } ifindex = ifr.ifr_ifindex; if (ioctl(s, SIOCGIFFLAGS, (char *) &ifr)) { bb_error_msg_and_die("SIOCGIFFLAGS"); } if (!(ifr.ifr_flags & IFF_UP)) { bb_error_msg_and_die("interface %s is down", device); } if (ifr.ifr_flags & (IFF_NOARP | IFF_LOOPBACK)) { bb_error_msg("interface %s is not ARPable", device); return (cfg & dad ? 0 : 2); } } if (!inet_aton(target, &dst)) { len_and_sockaddr *lsa; lsa = xhost_and_af2sockaddr(target, 0, AF_INET); memcpy(&dst, &lsa->sin.sin_addr.s_addr, 4); if (ENABLE_FEATURE_CLEAN_UP) free(lsa); } if (source && !inet_aton(source, &src)) { bb_error_msg_and_die("invalid source address %s", source); } if (!(cfg & dad) && (cfg & unsolicited) && src.s_addr == 0) src = dst; if (!(cfg & dad) || src.s_addr) { struct sockaddr_in saddr; int probe_fd = xsocket(AF_INET, SOCK_DGRAM, 0); if (device) { if (setsockopt(probe_fd, SOL_SOCKET, SO_BINDTODEVICE, device, strlen(device) + 1) == -1) bb_error_msg("warning: interface %s is ignored", device); } memset(&saddr, 0, sizeof(saddr)); saddr.sin_family = AF_INET; if (src.s_addr) { saddr.sin_addr = src; xbind(probe_fd, (struct sockaddr *) &saddr, sizeof(saddr)); } else if (!(cfg & dad)) { socklen_t alen = sizeof(saddr); saddr.sin_port = htons(1025); saddr.sin_addr = dst; if (setsockopt(probe_fd, SOL_SOCKET, SO_DONTROUTE, &const_int_1, sizeof(const_int_1)) == -1) bb_perror_msg("warning: setsockopt(SO_DONTROUTE)"); xconnect(probe_fd, (struct sockaddr *) &saddr, sizeof(saddr)); if (getsockname(probe_fd, (struct sockaddr *) &saddr, &alen) == -1) { bb_error_msg_and_die("getsockname"); } src = saddr.sin_addr; } close(probe_fd); } me.sll_family = AF_PACKET; me.sll_ifindex = ifindex; me.sll_protocol = htons(ETH_P_ARP); xbind(s, (struct sockaddr *) &me, sizeof(me)); { socklen_t alen = sizeof(me); if (getsockname(s, (struct sockaddr *) &me, &alen) == -1) { bb_error_msg_and_die("getsockname"); } } if (me.sll_halen == 0) { bb_error_msg("interface \"%s\" is not ARPable (no ll address)", device); return (cfg & dad ? 0 : 2); } he = me; memset(he.sll_addr, -1, he.sll_halen); if (!(cfg & quiet)) { printf("ARPING to %s from %s via %s\n", inet_ntoa(dst), inet_ntoa(src), device ? device : "unknown"); } if (!src.s_addr && !(cfg & dad)) { bb_error_msg_and_die("no src address in the non-DAD mode"); } { struct sigaction sa; memset(&sa, 0, sizeof(sa)); sa.sa_flags = SA_RESTART; sa.sa_handler = (void (*)(int)) finish; sigaction(SIGINT, &sa, NULL); sa.sa_handler = (void (*)(int)) catcher; sigaction(SIGALRM, &sa, NULL); } catcher(); while (1) { sigset_t sset, osset; RESERVE_CONFIG_UBUFFER(packet, 4096); struct sockaddr_ll from; socklen_t alen = sizeof(from); int cc; cc = recvfrom(s, packet, 4096, 0, (struct sockaddr *) &from, &alen); if (cc < 0) { bb_perror_msg("recvfrom"); continue; } sigemptyset(&sset); sigaddset(&sset, SIGALRM); sigaddset(&sset, SIGINT); sigprocmask(SIG_BLOCK, &sset, &osset); recv_pack(packet, cc, &from); sigprocmask(SIG_SETMASK, &osset, NULL); RELEASE_CONFIG_BUFFER(packet); } }
int arping_main(int argc, char **argv) { char *device = "eth0"; int ifindex; char *source = NULL; char *target; s = socket(PF_PACKET, SOCK_DGRAM, 0); ifindex = errno; // Drop suid root privileges xsetuid(getuid()); { unsigned long opt; char *_count, *_timeout, *_device; /* Dad also sets quit_on_reply. * Advert also sets unsolicited. */ bb_opt_complementally = "Df:AU"; opt = bb_getopt_ulflags(argc, argv, "DUAqfbc:w:i:s:", &_count, &_timeout, &_device); cfg |= opt & 63; /* set respective flags */ if (opt & 64) /* count */ count = atoi(_count); if (opt & 128) /* timeout */ timeout = atoi(_timeout); if (opt & 256) { /* interface */ if (strlen(_device) > IF_NAMESIZE) { bb_error_msg_and_die("Interface name `%s' must be less than %d", _device, IF_NAMESIZE); } device = _device; } if (opt & 512) /* source */ source = optarg; } argc -= optind; argv += optind; if (argc != 1) bb_show_usage(); target = *argv; if (s < 0) { bb_default_error_retval = ifindex; bb_perror_msg_and_die("socket"); } bb_default_error_retval = 2; { struct ifreq ifr; memset(&ifr, 0, sizeof(ifr)); strncpy(ifr.ifr_name, device, IFNAMSIZ - 1); if (ioctl(s, SIOCGIFINDEX, &ifr) < 0) { bb_error_msg_and_die("Interface %s not found", device); } ifindex = ifr.ifr_ifindex; if (ioctl(s, SIOCGIFFLAGS, (char *) &ifr)) { bb_error_msg_and_die("SIOCGIFFLAGS"); } if (!(ifr.ifr_flags & IFF_UP)) { bb_error_msg_and_die("Interface %s is down", device); } if (ifr.ifr_flags & (IFF_NOARP | IFF_LOOPBACK)) { bb_error_msg("Interface %s is not ARPable", device); exit(cfg&dad ? 0 : 2); } } if (!inet_aton(target, &dst)) { struct hostent *hp; hp = gethostbyname2(target, AF_INET); if (!hp) { bb_error_msg_and_die("invalid or unknown target %s", target); } memcpy(&dst, hp->h_addr, 4); } if (source && !inet_aton(source, &src)) { bb_error_msg_and_die("invalid source address %s", source); } if (!(cfg&dad) && cfg&unsolicited && src.s_addr == 0) src = dst; if (!(cfg&dad) || src.s_addr) { struct sockaddr_in saddr; int probe_fd = socket(AF_INET, SOCK_DGRAM, 0); /* maybe use bb_xsocket? */ if (probe_fd < 0) { bb_error_msg_and_die("socket"); } if (device) { if (setsockopt (probe_fd, SOL_SOCKET, SO_BINDTODEVICE, device, strlen(device) + 1) == -1) bb_error_msg("WARNING: interface %s is ignored", device); } memset(&saddr, 0, sizeof(saddr)); saddr.sin_family = AF_INET; if (src.s_addr) { saddr.sin_addr = src; if (bind(probe_fd, (struct sockaddr *) &saddr, sizeof(saddr)) == -1) { bb_error_msg_and_die("bind"); } } else if (!(cfg&dad)) { int on = 1; socklen_t alen = sizeof(saddr); saddr.sin_port = htons(1025); saddr.sin_addr = dst; if (setsockopt (probe_fd, SOL_SOCKET, SO_DONTROUTE, (char *) &on, sizeof(on)) == -1) bb_perror_msg("WARNING: setsockopt(SO_DONTROUTE)"); if (connect(probe_fd, (struct sockaddr *) &saddr, sizeof(saddr)) == -1) { bb_error_msg_and_die("connect"); } if (getsockname(probe_fd, (struct sockaddr *) &saddr, &alen) == -1) { bb_error_msg_and_die("getsockname"); } src = saddr.sin_addr; } close(probe_fd); }; me.sll_family = AF_PACKET; me.sll_ifindex = ifindex; me.sll_protocol = htons(ETH_P_ARP); if (bind(s, (struct sockaddr *) &me, sizeof(me)) == -1) { bb_error_msg_and_die("bind"); } { socklen_t alen = sizeof(me); if (getsockname(s, (struct sockaddr *) &me, &alen) == -1) { bb_error_msg_and_die("getsockname"); } } if (me.sll_halen == 0) { bb_error_msg("Interface \"%s\" is not ARPable (no ll address)", device); exit(cfg&dad ? 0 : 2); } he = me; memset(he.sll_addr, -1, he.sll_halen); if (!(cfg&quiet)) { printf("ARPING to %s from %s via %s\n", inet_ntoa(dst), inet_ntoa(src), device ? device : "unknown"); } if (!src.s_addr && !(cfg&dad)) { bb_error_msg_and_die("no src address in the non-DAD mode"); } { struct sigaction sa; memset(&sa, 0, sizeof(sa)); sa.sa_flags = SA_RESTART; sa.sa_handler = (void (*)(int)) finish; sigaction(SIGINT, &sa, NULL); sa.sa_handler = (void (*)(int)) catcher; sigaction(SIGALRM, &sa, NULL); } catcher(); while (1) { sigset_t sset, osset; RESERVE_CONFIG_UBUFFER(packet, 4096); struct sockaddr_ll from; socklen_t alen = sizeof(from); int cc; if ((cc = recvfrom(s, packet, 4096, 0, (struct sockaddr *) &from, &alen)) < 0) { bb_perror_msg("recvfrom"); continue; } sigemptyset(&sset); sigaddset(&sset, SIGALRM); sigaddset(&sset, SIGINT); sigprocmask(SIG_BLOCK, &sset, &osset); recv_pack(packet, cc, &from); sigprocmask(SIG_SETMASK, &osset, NULL); RELEASE_CONFIG_BUFFER(packet); } }