static int tcp_bind(int fd, const char *ip, unsigned short port)
{
struct sockaddr_in addr;
if (inet_pton(AF_INET, ip, &addr.sin_addr) <= 0) {
perror("inet_pton");
return -1;
}
if (set_socket_reuse(fd) != 0) {
perror("setsockopt");
return -1;
}
if (port == 0) {
static unsigned short lport = 1025;
if (lport < 1025) {
lport = 1025;
}
port = lport ++;
}
memset(&addr, '\0', sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
if (bind(fd, (struct sockaddr *) &addr, sizeof(addr)) == -1) {
return -1;
}
return 0;
}
int create_udp_service(sa_in_t* addr)
{
if ( addr == NULL ) return -1 ;
int sockfd = socket(AF_INET,SOCK_DGRAM,0) ;
if ( sockfd < 0 ) return -1 ;
set_nonblock(sockfd) ;
set_socket_reuse(sockfd) ;
if( bind(sockfd,(sa_t*)addr,sizeof(sa_in_t)) !=0 )
{
close(sockfd) ;
return -2 ;
}
return sockfd ;
}
int init_kernel(const char* ipaddr_,const unsigned short port_,const int udp_packet_filter_thread_num_)
{
#ifdef WIN32
if(InitWinsock2()==-1)
{
print_error("WSAStartup failed to Init Winsock2.");
return -1;
}
#endif
/* Initialize socket address structure for Interner Protocols */
_numberOfWorkerThreads = udp_packet_filter_thread_num_;
_udp_port = port_;
memset(&_internetAddr, 0,sizeof(_internetAddr)); // empty data structure
_internetAddr.sin_family = AF_INET;
if(ipaddr_==NULL)
_internetAddr.sin_addr.s_addr = htonl(INADDR_ANY);
else
_internetAddr.sin_addr.s_addr=inet_addr(ipaddr_);
_internetAddr.sin_port = htons(port_);
_hSocket = socket(AF_INET, SOCK_DGRAM, 0);
if( bind(_hSocket, ( struct sockaddr * )&_internetAddr, sizeof(_internetAddr ) ) == -1 )
{
print_error("WSAStartup failed to bind sock.");
close_socket(_hSocket);
clean_up();
return -1;
}
set_socket_recv_buf(_hSocket,16*1024);//HDS_UDP_SOCKET_RECV_BUF_SIZE);
set_socket_send_buf(_hSocket,HDS_UDP_SOCKET_SEND_BUF_SIZE);
if(set_socket_reuse(_hSocket) == -1)
{
print_error("WSAStartup failed to reuse sock.");
close_socket(_hSocket);
clean_up();
return -1;
}
if(HDS_Thread_Create(UDPServerRecvThread,NULL,&_recvThreadData)==-1)
{
print_error("A recv thread was not able to be created");
close_socket(_hSocket);
clean_up();
return -1;
}
_workerThreadDataArray = (HDS_Thread_Data*)malloc(_numberOfWorkerThreads*sizeof(HDS_Thread_Data));
memset(_workerThreadDataArray, 0, sizeof(HDS_Thread_Data) * _numberOfWorkerThreads);
for(int i= 0; i < _numberOfWorkerThreads; ++i)
{
// We only create in the suspended state so our workerThreadHandles object
// is updated before the thread runs.
if(HDS_Thread_Create(UDPServerWorkerThread,NULL,&_workerThreadDataArray[i])==-1)
{
print_error("A worker thread was not able to be created");
close_socket(_hSocket);
free(_workerThreadDataArray);
clean_up();
return -1;
}
}
return 0;
}
int main(int argc, char *argv[]) {
struct configuration config;
parse_options(argc, argv, &config);
int sock;
/* Create the UDP socket */
if ((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
Die("Failed to create socket");
}
set_socket_reuse(sock);
int on = 1;
setsockopt(sock, SOL_IP, IP_PKTINFO, &on, sizeof(on));
do_ts_sockopt(sock);
struct sockaddr_in server_addr;
make_address(config.server_ip, config.server_port, &server_addr);
struct sockaddr_in client_addr;
make_address(config.host_ip, config.host_port, &client_addr);
if(bind(sock, (struct sockaddr*)&client_addr, sizeof(client_addr)) < 0){
Die("bind");
}
struct sockaddr_in recv_addr;
make_address(0, 0, &recv_addr);
char buffer[config.msg_size];
unsigned int clientlen;
clientlen = sizeof(client_addr);
struct msghdr msg;
struct iovec iov;
char control[1024];
int got;
iov.iov_base = buffer;
iov.iov_len = config.msg_size;
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_namelen = sizeof(struct sockaddr_in);
msg.msg_control = control;
msg.msg_controllen = 1024;
msg.msg_name = &recv_addr;
char pay_load[config.msg_size];
const int timestamp_per_sample = 1;
size_t result_len = sizeof(struct timespec)*timestamp_per_sample*config.max_packets;
struct timespec (*result)[timestamp_per_sample] = (struct timespec ((*)[timestamp_per_sample]))malloc(result_len);
memset(result[0], 0, result_len);
int i;
runoncpu(3);
for(i = 0; i < config.max_packets; i++){
do {
got = recvmsg(sock, &msg, MSG_ERRQUEUE);
} while (got < 0 && errno == EAGAIN);
if(got >= 0){
keep_time(&msg, result[i]+1);
}else{
DEBUG("Unable to get TX_TIMESTAMPING\n");
}
}
FILE* outfile;
outfile = fopen("result_send_nic.txt", "w");
for(i = 0; i < config.max_packets; i++){
int j;
for (j = 0; j < timestamp_per_sample; j++){
if (j < timestamp_per_sample-1){
fprintf(outfile, "%ld,%9ld,", result[i][j].tv_sec, result[i][j].tv_nsec);
}else{
fprintf(outfile, "%ld,%9ld\n", result[i][j].tv_sec, result[i][j].tv_nsec);
}
}
}
close(outfile);
close(sock);
exit(0);
}
void client(int argc, char** argv)
{
struct addrinfo hints, *p, *servinfo;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_flags = AI_PASSIVE;
int rv = 0;
if ( (rv=getaddrinfo(NULL, PORT, &hints, &servinfo)) != 0)
{
fprintf(stderr, "client: getaddrinfo: %s\n", gai_strerror(rv));
exit(1);
}
int sockfd;
for (p = servinfo; p != NULL; p = p->ai_next)
{
if ( (sockfd=socket(p->ai_family, p->ai_socktype,
p->ai_protocol)) == -1)
{
perror("client: socket");
continue;
}
set_socket_reuse(sockfd);
if ( bind(sockfd, p->ai_addr, p->ai_addrlen) == -1)
{
perror("client: bind");
close(sockfd);
continue;
}
print_ip(p);
break;
}
if (p == NULL)
{
fprintf(stderr, "client: failed to bind\n");
exit(1);
}
freeaddrinfo(servinfo);
servinfo = NULL;
printf("client: binded\n");
struct sockaddr_in sa;
memset(&sa, 0, sizeof(sa));
socklen_t addrlen = sizeof(sa);
char buf[20];
if ( recvfrom(sockfd, buf, sizeof(buf), 0,
(struct sockaddr*)&sa, &addrlen) == -1)
{
perror("client: recvfrom");
exit(1);
}
printf("client: received '%s'\n", buf);
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;
char* ipstr = inet_ntoa(sa.sin_addr);
printf("client: getting addrinfo of %s\n", ipstr);
if ( (rv=getaddrinfo(ipstr, PORT, &hints, &servinfo)) != 0)
{
fprintf(stderr, "client: getaddrinfo: %s\n", gai_strerror(rv));
exit(1);
}
for (p = servinfo; p != NULL; p = p->ai_next)
{
if ( (sockfd = socket(p->ai_family, p->ai_socktype,
p->ai_protocol)) == -1)
{
perror("client: socket");
continue;
}
set_socket_reuse(sockfd);
set_socket_keep_alive(sockfd);
if ( (connect(sockfd, p->ai_addr, p->ai_addrlen)) == -1)
{
perror("client: connect");
close(sockfd);
continue;
}
print_ip(p);
break;
}
if (p == NULL)
{
fprintf(stderr, "client: failed to connect\n");
exit(1);
}
freeaddrinfo(servinfo);
servinfo = NULL;
printf("client: connection completed\n");
struct Data job;
if ( (recv(sockfd, &job, sizeof(job), 0)) == -1)
{
perror("client: recv");
exit(1);
}
printf("client: Received (%lg, %lg, %li)!\n", job.left, job.right,
job.intervals);
unsigned long iters = job.intervals;
T const step = (job.right-job.left)/iters;
job.sum = 0;
for(unsigned long i = 0; i < iters; ++i)
{
job.sum += func(job.left+i*step);
}
job.sum *= step;
if ( (send(sockfd, &job, sizeof(job), 0)) == -1)
{
perror("client: send");
exit(1);
}
printf("client: Sended sum == %lg\n", job.sum);
close(sockfd);
}
void server(int argc, char** argv)
{
char* endptr;
unsigned long const max_slaves = strtoul(argv[2], &endptr, 10);
if ( *endptr != '\0')
{
perror("server: strtoul");
exit(1);
}
struct addrinfo hints, *servinfo_udp, *p_udp;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_DGRAM;
int rv;
if ( (rv = getaddrinfo("255.255.255.255", PORT, &hints,
&servinfo_udp)) != 0 )
{
fprintf(stderr, "server: getaddrinfo %s\n", gai_strerror(rv));
exit(1);
}
int sockfd_udp;
for (p_udp = servinfo_udp; p_udp != NULL; p_udp = p_udp->ai_next)
{
if ( (sockfd_udp = socket(p_udp->ai_family, p_udp->ai_socktype,
p_udp->ai_protocol)) == -1 )
{
perror("server: socket");
continue;
}
set_socket_reuse(sockfd_udp);
set_socket_broadcast(sockfd_udp);
print_ip(p_udp);
break;
}
if (p_udp == NULL)
{
fprintf(stderr, "server: failed to create socket\n");
exit(1);
}
struct addrinfo *p, *servinfo;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE;
if ( (rv = getaddrinfo(NULL, PORT, &hints, &servinfo)) == -1)
{
fprintf(stderr, "server: getaddrinfo: %s\n", gai_strerror(rv));
exit(1);
}
int sockfd;
for (p = servinfo; p != NULL; p = p->ai_next)
{
if ( (sockfd = socket(p->ai_family,
p->ai_socktype, p->ai_protocol)) == -1)
{
perror("server: socket");
continue;
}
set_socket_reuse(sockfd);
set_socket_keep_alive(sockfd);
if ( bind(sockfd, p->ai_addr, p->ai_addrlen) == -1)
{
perror("server: bind");
close(sockfd);
continue;
}
print_ip(p);
break;
}
if (p == NULL)
{
fprintf(stderr, "server: failed to bind\n");
exit(1);
}
freeaddrinfo(servinfo);
servinfo = NULL;
printf("server: bind completed\n");
if ( listen(sockfd, LISTEN_BACKLOG) == -1)
{
perror("server: listen");
exit(1);
}
printf("server: listen completed\n");
if ( sendto(sockfd_udp, MSG_BOSS, strlen(MSG_BOSS)+1, 0,
p_udp->ai_addr, p_udp->ai_addrlen) == -1)
{
perror("server: sendto");
exit(1);
}
freeaddrinfo(servinfo_udp);
servinfo_udp = NULL;
printf("server: sended broadcast '%s'\n", MSG_BOSS);
int* sockfds2 = calloc(max_slaves, sizeof(*sockfds2));
struct Data* jobs = calloc(max_slaves, sizeof(*jobs));
struct sockaddr_storage their_addr;
socklen_t their_size = 0;
for (unsigned long i = 0; i < max_slaves; ++i)
{
jobs[i].left = LEFT + i*(RIGHT-LEFT)/max_slaves;
jobs[i].right = LEFT + (i+1)*(RIGHT-LEFT)/max_slaves;
jobs[i].sum = 0;
jobs[i].intervals = NUM_OF_INTERVALS/max_slaves;
if ( (sockfds2[i] = accept(sockfd, (struct sockaddr*)&their_addr,
&their_size)) == -1)
{
perror("server: accept");
exit(1);
}
printf("server: accept completed\n");
if ( send(sockfds2[i], &jobs[i], sizeof(jobs[i]), 0) == -1)
{
perror("server: send");
exit(1);
}
printf ("server: Sended (%lg, %lg, %li)!\n", jobs[i].left,
jobs[i].right, jobs[i].intervals);
}
fd_set not_readen;
fd_set to_check;
FD_ZERO(¬_readen);
FD_ZERO(&to_check);
int max_fd = 0;
for (unsigned long i = 0; i < max_slaves; ++i)
{
FD_SET(sockfds2[i], ¬_readen);
FD_SET(sockfds2[i], &to_check);
if (sockfds2[i] > max_fd)
{
max_fd = sockfds2[i];
}
}
while ( !fd_empty(&to_check, max_fd) )
{
if ( select(max_fd+1, &to_check, NULL, NULL, NULL) == -1)
{
perror("server: select");
exit(1);
}
for (unsigned long i = 0; i < max_slaves; ++i)
{
receive_msg(i, sockfds2, &to_check, ¬_readen, jobs);
}
to_check = not_readen;
}
free(sockfds2);
free(jobs);
T sum = 0.0;
for (unsigned long i = 0; i < max_slaves; ++i)
{
sum += jobs[i].sum;
}
printf("server: Integral == %lg\n", sum);
}
