// one sender thread int send_run(sock_t st, shard_t *s) { log_trace("send", "send thread started"); pthread_mutex_lock(&send_mutex); // Allocate a buffer to hold the outgoing packet char buf[MAX_PACKET_SIZE]; memset(buf, 0, MAX_PACKET_SIZE); // OS specific per-thread init if (send_run_init(st)) { return -1; } // MAC address length in characters char mac_buf[(ETHER_ADDR_LEN * 2) + (ETHER_ADDR_LEN - 1) + 1]; char *p = mac_buf; for(int i=0; i < ETHER_ADDR_LEN; i++) { if (i == ETHER_ADDR_LEN-1) { snprintf(p, 3, "%.2x", zconf.hw_mac[i]); p += 2; } else { snprintf(p, 4, "%.2x:", zconf.hw_mac[i]); p += 3; } } log_debug("send", "source MAC address %s", mac_buf); void *probe_data; if (zconf.probe_module->thread_initialize) { zconf.probe_module->thread_initialize(buf, zconf.hw_mac, zconf.gw_mac, zconf.target_port, &probe_data); } pthread_mutex_unlock(&send_mutex); // adaptive timing to hit target rate uint32_t count = 0; uint32_t last_count = count; double last_time = now(); uint32_t delay = 0; int interval = 0; uint32_t max_targets = s->state.max_targets; volatile int vi; if (zconf.rate > 0) { // estimate initial rate delay = 10000; for (vi = delay; vi--; ) ; delay *= 1 / (now() - last_time) / (zconf.rate / zconf.senders); interval = (zconf.rate / zconf.senders) / 20; last_time = now(); } uint32_t curr = shard_get_cur_ip(s); int attempts = zconf.num_retries + 1; uint32_t idx = 0; while (1) { // adaptive timing delay if (delay > 0) { count++; for (vi = delay; vi--; ) ; if (!interval || (count % interval == 0)) { double t = now(); delay *= (double)(count - last_count) / (t - last_time) / (zconf.rate / zconf.senders); if (delay < 1) delay = 1; last_count = count; last_time = t; } } if (zrecv.complete) { s->cb(s->id, s->arg); break; } if (s->state.sent >= max_targets) { s->cb(s->id, s->arg); break; } if (zconf.max_runtime && zconf.max_runtime <= now() - zsend.start) { s->cb(s->id, s->arg); break; } if (curr == 0) { s->cb(s->id, s->arg); break; } s->state.sent++; for (int i=0; i < zconf.packet_streams; i++) { uint32_t src_ip = get_src_ip(curr, i); uint32_t validation[VALIDATE_BYTES/sizeof(uint32_t)]; validate_gen(src_ip, curr, (uint8_t *)validation); zconf.probe_module->make_packet(buf, src_ip, curr, validation, i, probe_data); if (zconf.dryrun) { lock_file(stdout); zconf.probe_module->print_packet(stdout, buf); unlock_file(stdout); } else { int length = zconf.probe_module->packet_length; void *contents = buf + zconf.send_ip_pkts*sizeof(struct ether_header); for (int i = 0; i < attempts; ++i) { int rc = send_packet(st, contents, length, idx); if (rc < 0) { struct in_addr addr; addr.s_addr = curr; log_debug("send", "send_packet failed for %s. %s", inet_ntoa(addr), strerror(errno)); s->state.failures++; } else { break; } } idx++; idx &= 0xFF; } } curr = shard_get_next_ip(s); } if (zconf.dryrun) { pthread_mutex_lock(&send_mutex); fflush(stdout); pthread_mutex_unlock(&send_mutex); } log_debug("send", "thread %hu finished", s->id); return EXIT_SUCCESS; }
// one sender thread int send_run(int sock) { log_trace("send", "send thread started"); pthread_mutex_lock(&send_mutex); // Allocate a buffer to hold the outgoing packet char buf[MAX_PACKET_SIZE]; memset(buf, 0, MAX_PACKET_SIZE); // OS specific per-thread init if (send_run_init(sock)) { return -1; } // Get the source hardware address, and give it to the probe // module if (get_iface_hw_addr(zconf.iface, zconf.hw_mac)) { log_fatal("send", "could not retrieve hardware address for" "interface: %s", zconf.iface); return -1; } char mac_buf[(ETHER_ADDR_LEN * 2) + (ETHER_ADDR_LEN - 1) + 1]; char *p = mac_buf; for(int i=0; i < ETHER_ADDR_LEN; i++) { if (i == ETHER_ADDR_LEN-1) { snprintf(p, 3, "%.2x", zconf.hw_mac[i]); p += 2; } else { snprintf(p, 4, "%.2x:", zconf.hw_mac[i]); p += 3; } } log_debug("send", "source MAC address %s", mac_buf); zconf.probe_module->thread_initialize(buf, zconf.hw_mac, zconf.gw_mac, zconf.target_port); pthread_mutex_unlock(&send_mutex); // adaptive timing to hit target rate uint32_t count = 0; uint32_t last_count = count; double last_time = now(); uint32_t delay = 0; int interval = 0; volatile int vi; if (zconf.rate > 0) { // estimate initial rate delay = 10000; for (vi = delay; vi--; ) ; delay *= 1 / (now() - last_time) / (zconf.rate / zconf.senders); interval = (zconf.rate / zconf.senders) / 20; last_time = now(); } while (1) { // adaptive timing delay if (delay > 0) { count++; for (vi = delay; vi--; ) ; if (!interval || (count % interval == 0)) { double t = now(); delay *= (double)(count - last_count) / (t - last_time) / (zconf.rate / zconf.senders); if (delay < 1) delay = 1; last_count = count; last_time = t; } } // generate next ip from cyclic group and update global state // (everything locked happens here) pthread_mutex_lock(&send_mutex); if (zsend.complete) { pthread_mutex_unlock(&send_mutex); break; } if (zsend.sent >= zconf.max_targets) { zsend.complete = 1; zsend.finish = now(); pthread_mutex_unlock(&send_mutex); break; } if (zconf.max_runtime && zconf.max_runtime <= now() - zsend.start) { zsend.complete = 1; zsend.finish = now(); pthread_mutex_unlock(&send_mutex); break; } uint32_t curr = cyclic_get_next_ip(c); if (curr == zsend.first_scanned) { zsend.complete = 1; zsend.finish = now(); } zsend.sent++; pthread_mutex_unlock(&send_mutex); for (int i=0; i < zconf.packet_streams; i++) { uint32_t src_ip = get_src_ip(curr, i); uint32_t validation[VALIDATE_BYTES/sizeof(uint32_t)]; validate_gen(src_ip, curr, (uint8_t *)validation); zconf.probe_module->make_packet(buf, src_ip, curr, validation, i); if (zconf.dryrun) { zconf.probe_module->print_packet(stdout, buf); } else { int length = zconf.probe_module->packet_length; void *contents = buf + zconf.send_ip_pkts*sizeof(struct ether_header); int rc = send_packet(sock, contents, length); if (rc < 0) { struct in_addr addr; addr.s_addr = curr; log_debug("send", "send_packet failed for %s. %s", inet_ntoa(addr), strerror(errno)); pthread_mutex_lock(&send_mutex); zsend.sendto_failures++; pthread_mutex_unlock(&send_mutex); } } } } cyclic_free(c); log_debug("send", "thread finished"); return EXIT_SUCCESS; }