int main(int argc, char *argv[]) {
#ifdef TCP
int s = net_connect_tcp(NULL,"2334",0);
#else
int s = net_connect_udp("2334",0);
#endif
if (s < 0) {
printf("Failed to connect (%d)\n",s);
return 0;
}
printf("Connected to %d\nSending: %s\n",s,"Hello World");
int r;
char *msg = "Hello World";
if (r = net_send(s,msg,strlen(msg)+1) < 0) {
printf("Send error (%d, %d)\n",r,errno);
return 0;
}
char *str;
if ((str = net_receive(s)) == NULL)
printf("Receive error (%d)\n",errno);
else
printf("Received: %s\n",str);
closesocket(s);
printf("Session terminated\n");
}
int main(int argc, char *argv[]) {
#ifdef TCP
int s = net_connect_tcp("0","2334",1);
#else
int s = net_connect_udp("2334",1);
#endif
if (s < 0) {
printf("Failed to serve (%d)\n",s);
return 0;
}
printf("%d serving...\n",s);
#ifdef TCP
int c = net_accept(s);
if (c < 0) {
printf("Client not found (%d)\n",c);
return 0;
}
printf("Connected %d\n",c);
char *str = net_receive(c);
if (str == NULL)
printf("Receive error (%d)\n",errno);
else
printf("Received: %s\nSending: %s\n",str,"Goodbye Cruel World");
char *msg = "Goodbye Cruel World";
if (net_send(c,msg,strlen(msg)+1) < 0)
printf("Send error (%d)\n",errno);
closesocket(c);
#else
net_bounce(s);
#endif
closesocket(s);
printf("Session terminated\n");
}
void thread_loop(void *userdata) {
struct state *state = userdata;
struct mmsghdr *messages = calloc(state->packets_in_buf, sizeof(struct mmsghdr));
struct iovec *iovecs = calloc(state->packets_in_buf, sizeof(struct iovec));
int fd = net_connect_udp(state->target_addr, state->src_port);
int i;
for (i = 0; i < state->packets_in_buf; i++) {
struct iovec *iovec = &iovecs[i];
struct mmsghdr *msg = &messages[i];
msg->msg_hdr.msg_iov = iovec;
msg->msg_hdr.msg_iovlen = 1;
iovec->iov_base = (void*)state->payload;
iovec->iov_len = state->payload_sz;
}
while (1) {
int r = sendmmsg(fd, messages, state->packets_in_buf, 0);
if (r <= 0) {
if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR) {
continue;
}
if (errno == ECONNREFUSED) {
continue;
}
PFATAL("sendmmsg()");
}
int i, bytes = 0;
for (i = 0; i < r; i++) {
struct mmsghdr *msg = &messages[i];
/* char *buf = msg->msg_hdr.msg_iov->iov_base; */
int len = msg->msg_len;
msg->msg_hdr.msg_flags = 0;
msg->msg_len = 0;
bytes += len;
}
}
}
void thread_loop(void *userdata)
{
struct state *state = userdata;
pthread_spin_init(&state->lock, PTHREAD_PROCESS_PRIVATE);
char send_buf[PKT_SIZE], recv_buf[PKT_SIZE];
struct msghdr *msg = calloc(2, sizeof(struct msghdr));
struct iovec *iovec = calloc(2, sizeof(struct iovec));
int i;
for (i = 0; i < 2; i++) {
msg[i].msg_iov = &iovec[i];
msg[i].msg_iovlen = 1;
iovec[i].iov_len = sizeof(send_buf);
}
iovec[0].iov_base = send_buf;
iovec[1].iov_base = recv_buf;
char pktinfo[4096];
msg[1].msg_control = pktinfo;
msg[1].msg_controllen = sizeof(pktinfo);
uint64_t packet_no = 0;
while (1) {
int fd = net_connect_udp(state->target_addr, state->src_port,
state->busy_poll);
struct timeval tv = {1, 0}; // 1 second
int r = setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv,
sizeof(tv));
if (r < 0) {
PFATAL("setsockopt(SO_RCVTIMEO)");
}
for (;; packet_no++) {
memset(send_buf, 0, sizeof(send_buf));
snprintf(send_buf, sizeof(send_buf), "%i-%li-%lu",
getpid(), gettid(), packet_no);
uint64_t t0 = realtime_now(), t1 = 0, tp = 0;
int r = sendmsg(fd, &msg[0], 0);
if (r <= 0) {
if (errno == EAGAIN || errno == EWOULDBLOCK ||
errno == ECONNREFUSED) {
break;
}
if (errno == EINTR) {
continue;
}
PFATAL("sendmmsg()");
}
msg[1].msg_controllen = sizeof(pktinfo);
while (1) {
int flags = state->polling ? MSG_DONTWAIT : 0;
r = recvmsg(fd, &msg[1], flags);
t1 = realtime_now();
if (t1 - t0 >= 1000000000) {
/* No msg for 1s */
errno = ECONNREFUSED;
break;
}
if (r <= 0 &&
(errno == EINTR || errno == EAGAIN ||
errno == EWOULDBLOCK)) {
continue;
}
if (r == 0 && state->polling) {
continue;
}
break;
}
if (r <= 0 && errno == ECONNREFUSED) {
sleep(1);
break;
}
if (r <= 0) {
PFATAL("recvmmsg()");
}
if (memcmp(send_buf, recv_buf, sizeof(recv_buf)) != 0) {
fprintf(stderr, "[!] bad message\n");
sleep(1);
break;
}
struct cmsghdr *cmsg;
for (cmsg = CMSG_FIRSTHDR(&msg[1]); cmsg;
cmsg = CMSG_NXTHDR(&msg[1], cmsg)) {
switch (cmsg->cmsg_level) {
case SOL_SOCKET:
switch (cmsg->cmsg_type) {
case SO_TIMESTAMPNS: {
struct timespec *ts =
(struct timespec *)
CMSG_DATA(cmsg);
tp = TIMESPEC_NSEC(ts);
break;
}
}
break;
}
}
pthread_spin_lock(&state->lock);
stddev_add(&state->stddev, t1 - t0);
if (tp != 0) {
stddev_add(&state->stddev_packet, t1 - tp);
}
pthread_spin_unlock(&state->lock);
}
close(fd);
}
}
void handle_read(int fd) {
char bufx[16];
int r = recv(fd, bufx, sizeof(bufx), MSG_DONTWAIT);
printf("recv=%d\n",r);
uint8_t buf[2048];
struct iovec iovec = {
.iov_base = buf, .iov_len = sizeof(buf),
};
uint8_t control[2048];
struct sockaddr_in remote;
memset(&remote, 0, sizeof(remote));
struct msghdr msg = {
.msg_name = &remote,
.msg_namelen = sizeof(remote),
.msg_iov = &iovec,
.msg_iovlen = 1,
.msg_control = &control,
.msg_controllen = sizeof(control),
.msg_flags = 0,
};
r = recvmsg(fd, &msg, MSG_ERRQUEUE | MSG_DONTWAIT);
if (r < 0) {
perror("recvmsg(MSG_ERRQUEUE)");
} else {
if (r == 0) {
fprintf(stderr, "no MSG_ERRQUEUE data\n");
} else {
printf("MSG_ERRQUEUE something %d!\n", r);
}
if (msg.msg_flags & MSG_ERRQUEUE) {
struct cmsghdr *c;
for (c = CMSG_FIRSTHDR(&msg); c; c = CMSG_NXTHDR(&msg, c)) {
if (c->cmsg_level == IPPROTO_IP && c->cmsg_type == IP_RECVERR) {
struct sock_extended_err *ee = (struct sock_extended_err *)CMSG_DATA(c);
//struct sockaddr_in *from = (struct sockaddr_in *)SO_EE_OFFENDER(ee);
if (ee->ee_origin == SO_EE_ORIGIN_ICMP) {
printf("ICMP type=%u code=%u\n",
ee->ee_type, ee->ee_code);
} else {
printf("not icmp\n");
}
} else {
printf("not error?\n");
}
}
} else {
printf("not MSG_ERRQUEUE msg\n");
}
}
}
int main(int argc, char **argv)
{
if (argc != 2){
fprintf(stderr, "%s target_ip:port\n", argv[0]);
return -1;
}
char buf[600-44+48];
memset(buf, 'B', sizeof(buf));
struct net_addr *target = net_parse_addr(argv[1]);
int fd = net_connect_udp(target);
int r;
int on = 1;
/* on = 1; */
/* r = setsockopt(fd, IPPROTO_IP, IP_RECVERR, &on, sizeof(on)); */
/* if (r != 0) { */
/* perror("setsockopt(SOL_IP, IP_RECVERR)"); */
/* } */
on = IP_PMTUDISC_DONT;
r = setsockopt(fd, IPPROTO_IP, IP_MTU_DISCOVER, &on, sizeof(on));
if (r != 0) {
perror("setsockopt(SOL_IP, IP_MTU_DISCOVER");
}
while (1) {
int v = 0;
unsigned vl = sizeof(v);
int r = getsockopt(fd, SOL_IP, IP_MTU, &v, &vl);
if (r != 0) {
perror("getsockopt(MTU)");
}
printf("MTU: %d\n", v);
/* r = sendto(fd, buf, sizeof(buf), MSG_DONTWAIT, target->sockaddr, target->sockaddr_len); */
r = send(fd, buf, sizeof(buf), 0);
if (r < 0) {
perror("send()");
}
fd_set efds;
FD_ZERO(&efds);
//FD_SET(fd, &efds);
struct timeval timeout = NSEC_TIMEVAL(MSEC_NSEC(1000));
while (1) {
r = select(fd+1, &efds, NULL, NULL, &timeout);
char bb[16];
recv(fd, &bb, sizeof(bb), MSG_DONTWAIT);
if (r < 0) {
perror("select()");
} else if (r == 0) {
break;
// pass
} else {
handle_read(fd);
}
}
}
return 0;
}
