int
main(int argc, char **argv)
{
int sendfd, recvfd;
const int on = 1;
socklen_t salen;
struct sockaddr *sasend, *sarecv;
if (argc != 3)
err_quit("usage: sendrecv <IP-multicast-address> <port#>");
sendfd = Udp_client(argv[1], argv[2], (void **) &sasend, &salen);
recvfd = Socket(sasend->sa_family, SOCK_DGRAM, 0);
Setsockopt(recvfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
sarecv = Malloc(salen);
memcpy(sarecv, sasend, salen);
Bind(recvfd, sarecv, salen);
Mcast_join(recvfd, sasend, salen, NULL, 0);
Mcast_set_loop(sendfd, 0);
if (Fork() == 0)
recv_all(recvfd, salen); /* child -> receives */
send_all(sendfd, sasend, salen); /* parent -> sends */
}
int
main(int argc, char **argv)
{
int tfd, flags;
char recvline[MAXLINE + 1];
socklen_t addrlen;
struct t_unitdata *sndptr, *rcvptr;
if (argc != 3)
err_quit("usage: daytimeudpcli <hostname> <service>");
tfd = Udp_client(argv[1], argv[2], (void **) &sndptr, &addrlen);
rcvptr = T_alloc(tfd, T_UNITDATA, T_ADDR);
printf("sending to %s\n", Xti_ntop_host(&sndptr->addr));
sndptr->udata.maxlen = MAXLINE;
sndptr->udata.len = 1;
sndptr->udata.buf = recvline;
recvline[0] = 0; /* 1-byte datagram containing null byte */
T_sndudata(tfd, sndptr);
rcvptr->udata.maxlen = MAXLINE;
rcvptr->udata.buf = recvline;
T_rcvudata(tfd, rcvptr, &flags);
recvline[rcvptr->udata.len] = 0; /* null terminate */
printf("from %s: %s", Xti_ntop_host(&rcvptr->addr), recvline);
exit(0);
}
int
main(int argc, char **argv)
{
int sockfd, n, nq;
char recvline[MAXLINE + 1];
socklen_t salen;
struct sockaddr *sa;
if (argc != 3)
err_quit("usage: a.out <hostname or IPaddress> <service or port#>");
sockfd = Udp_client(argv[1], argv[2], (void **) &sa, &salen);
printf("sending to %s\n", Sock_ntop_host(sa, salen));
Sendto(sockfd, "", 1, 0, sa, salen); /* send 1-byte datagram */
n = Recvfrom(sockfd, recvline, MAXLINE, MSG_PEEK, NULL, NULL);
Ioctl(sockfd, FIONREAD, &nq); /* check FIONREAD support */
printf("%d bytes from PEEK, %d bytes pending\n", n, nq);
n = Recvfrom(sockfd, recvline, MAXLINE, 0, NULL, NULL);
recvline[n] = 0; /* null terminate */
Fputs(recvline, stdout);
exit(0);
}
int
main(int argc, char **argv)
{
int sockfd;
const int on = 1;
socklen_t salen;
struct sockaddr *sa;
if (argc == 1)
sockfd = Udp_client(SAP_NAME, SAP_PORT, (void **) &sa, &salen);
else if (argc == 4)
sockfd = Udp_client(argv[1], argv[2], (void **) &sa, &salen);
else
err_quit("usage: mysdr <mcast-addr> <port#> <interface-name>");
Setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
Bind(sockfd, sa, salen);
Mcast_join(sockfd, sa, salen, (argc == 4) ? argv[3] : NULL, 0);
loop(sockfd, salen); /* receive and print */
exit(0);
}
int
main(int argc, char **argv)
{
int sockfd;
socklen_t salen;
struct sockaddr *sa;
if (argc != 3)
err_quit("usage: udpcli01 <hostname> <service>");
sockfd = Udp_client(argv[1], argv[2], (void **) &sa, &salen);
dg_cli(stdin, sockfd, sa, salen);
exit(0);
}
int main(int argc,char *argv[])
{
int recvfd,sendfd,n;
const in on = 1;
socklen_t salen;
struct sockaddr *sarecv,*sasend;
if(argc != 3)
err_quit("usage: sendrecv <IP-multicast-addr> <port#>");
sendfd = Udp_client(argv[1],argv[2],&sasend,&salen);
sarecv = malloc(salen);
memcpy(sarecv,sasend,salen);
recvfd = Socket(sarecv->sa_family,SOCK_DGRAM,0);
bind(recvfd,sarecv,salen);
setscokopt(recvfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on));
if(fork() == 0)
recv_all(recvfd,salen);
send_all(sendfd,sasend,salen);
}
int
main(int argc, char **argv)
{
int sockfd;
char buf[MAXLINE];
ssize_t n;
socklen_t salen, len;
struct ifi_info *ifi;
struct sockaddr *mcastsa, *wild, *from;
struct timeval now;
if (argc != 2)
err_quit("usage: ssntp <IPaddress>");
sockfd = Udp_client(argv[1], "ntp", (void **) &mcastsa, &salen);
wild = Malloc(salen);
memcpy(wild, mcastsa, salen); /* copy family and port */
sock_set_wild(wild, salen);
Bind(sockfd, wild, salen); /* bind wildcard */
#ifdef MCAST
/* 4obtain interface list and process each one */
for (ifi = Get_ifi_info(mcastsa->sa_family, 1); ifi != NULL;
ifi = ifi->ifi_next) {
if (ifi->ifi_flags & IFF_MULTICAST) {
Mcast_join(sockfd, mcastsa, salen, ifi->ifi_name, 0);
printf("joined %s on %s\n",
Sock_ntop(mcastsa, salen), ifi->ifi_name);
}
}
#endif
from = Malloc(salen);
for ( ; ; ) {
len = salen;
n = Recvfrom(sockfd, buf, sizeof(buf), 0, from, &len);
Gettimeofday(&now, NULL);
sntp_proc(buf, n, &now);
}
}
int main(int argc, char **argv){
int sockfd, n;
char recvline[MAXLINE + 1];
socklen_t salen;
struct sockaddr *sa;
if(argc != 3){
err_quit("usage: daytimeudpcli1 <hostname/IPaddress> <service/port#>");
}
sockfd = Udp_client(argv[1], argv[2], (void **)&sa, &salen);
printf("sizeof sa:%d, salen:%d\n", sizeof(*sa), salen);
printf("sending to %s\n", Sock_ntop_host(sa, salen));
//Sendto(sockfd, "", 1, 0, sa, salen);/*send 1-byte datagram*/
Sendto(sockfd, "", 0, 0, sa, salen);
n = Recvfrom(sockfd, recvline, MAXLINE, 0, NULL, NULL);
recvline[n] = '\0';/*null terminate*/
Fputs(recvline, stdout);
return 0;
}
int
main(int argc, char **argv)
{
int sockfd;
socklen_t salen;
struct sockaddr *cli, *serv;
if (argc != 2)
err_quit("usage: udpcli06 <IPaddress>");
sockfd = Udp_client(argv[1], "daytime", (void **) &serv, &salen);
cli = Malloc(salen);
memcpy(cli, serv, salen); /* copy socket address struct */
sock_set_port(cli, salen, 0); /* and set port to 0 */
Bind(sockfd, cli, salen);
dg_cli(stdin, sockfd, serv, salen);
exit(0);
}
int main(int argc, char **argv) {
int sockfd;
int n;
char recvline[MAXLINE+1];
socklen_t salen;
struct sockaddr *sa;
if (argc != 3)
err_quit("usage: daytimeudpcli <hostname/IPaddress> <service/port#>");
sockfd = Udp_client(argv[1], argv[2], (void **)&sa, &salen);
printf("sending to %s\n", Sock_ntop_host(sa, salen));
Sendto(sockfd, "", 1, 0, sa, salen); /* send 1-byte datagram */
n = Recvfrom(sockfd, recvline, MAXLINE, 0, NULL, NULL);
recvline[n] = '\0';
Fputs(recvline, stdout);
exit(0);
}
int
main(int argc, char **argv)
{
int sockfd;
socklen_t salen;
struct addrinfo *res;
struct sockaddr *cli, *serv;
if (argc != 2)
err_quit("usage: test2 <IPaddress>");
#ifdef notdef
res = Host_serv(argv[1], "daytime", AF_UNSPEC, SOCK_DGRAM);
printf("res->ai_addrlen = %d\n", res->ai_addrlen);
printf("res->ai_addr = %p\n", res->ai_addr);
printf("res->ai_next = %p\n", res->ai_next);
printf("res->ai_addr->sa_family = %p\n", res->ai_addr->sa_family);
#endif
sockfd = Udp_client(argv[1], "13", (void **) &serv, &salen);
printf("sockfd = %d\n", sockfd);
exit(0);
}
int main(int argc, char** argv)
{
int sockfd, family, port;
const int on = 1;
pid_t pid;
socklen_t salen;
struct sockaddr *sa, *wild;
struct ifi_info *ifi, *ifihead;
if (argc == 2)
sockfd = Udp_client(NULL, argv[1], (void**)&sa, &salen);
else if (argc == 3)
sockfd = Udp_client(argv[1], argv[2], (void**)&sa, &salen);
else
err_quit("usage: udpserv04 [ <host> ] <service or port>");
family = sa->sa_family;
port = sock_get_port(sa, salen);
Close(sockfd); /* we just want family, port, salen */
for (ifihead = ifi = Get_ifi_info(family, 1); ifi != NULL;
ifi = ifi->ifi_next) {
/*4bind unicast address */
sockfd = Socket(family, SOCK_DGRAM, 0);
Setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
sock_set_port(ifi->ifi_addr, salen, port);
Bind(sockfd, ifi->ifi_addr, salen);
printf("bound %s\n", Sock_ntop(ifi->ifi_addr, salen));
if ((pid = Fork()) == 0) { /* child */
mydg_echo(sockfd, ifi->ifi_addr, salen);
exit(0); /* never executed */
}
if (ifi->ifi_flags & IFF_BROADCAST) {
/* 4try to bind broadcast address */
sockfd = Socket(family, SOCK_DGRAM, 0);
Setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
sock_set_port(ifi->ifi_brdaddr, salen, port);
if (bind(sockfd, ifi->ifi_brdaddr, salen) < 0) {
if (errno == EADDRINUSE) {
printf("EADDRINUSE: %s\n",
Sock_ntop(ifi->ifi_brdaddr, salen));
Close(sockfd);
continue;
} else
err_sys("bind error for %s",
Sock_ntop(ifi->ifi_brdaddr, salen));
}
printf("bound %s\n", Sock_ntop(ifi->ifi_brdaddr, salen));
if ((pid = Fork()) == 0) { /* child */
mydg_echo(sockfd, ifi->ifi_brdaddr, salen);
exit(0); /* never executed */
}
}
}
/* 4bind wildcard address */
sockfd = Socket(family, SOCK_DGRAM, 0);
Setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
wild = Malloc(salen);
memcpy(wild, sa, salen); /* copy family and port */
sock_set_wild(wild, salen);
Bind(sockfd, wild, salen);
printf("bound %s\n", Sock_ntop(wild, salen));
if ((pid = Fork()) == 0) { /* child */
mydg_echo(sockfd, wild, salen);
exit(0); /* never executed */
}
exit(0);
}
int
main(int argc, char **argv)
{
int n, i, size, prflag;
int pos = 3;
int maxfd;
int rt_sockfd,recv_ping_sockfd;
int send_mulcst_fd, recv_mulcst_fd;
const int on = 1;
char buff_recv[BUFFSIZE];
char tour_array[TOURNUM][IPLEN];
char *ptr;
fd_set rset;
struct timeval tval, tval1, tval2, tval3, tval4;
struct sockaddr_ll saddrll;
Signal(SIGALRM, sig_alrm);
//Signal(SIGCHLD, sig_chld);
uname(&myname);
if (argc == 1){
fputs("This is NOT source node\n", stdout);
//_is_src_node = 0;
source_flag = 0;
}else{
fputs("I'm source node, start to send tour infomation \n", stdout);
//_is_src_node = 1;
source_flag = 1;
}
//if (uname(&myname) < 0)
//err_sys("uname error");
for ( hwa = Get_hw_addrs(); hwa != NULL; hwa = hwa->hwa_next) {
if(strcmp(hwa->if_name,"eth0")==0){
/* in eth0 we create pfsocket and bind it to hw addr, this pf socket is for sned ping info */
//pf_sockfd = socket(PF_PACKET, SOCK_RAW,htons(ETH_P_IP));
send_ping_pf_sockfd = socket(PF_PACKET, SOCK_RAW,htons(ETH_P_IP));
//send_ping_pf_sockfd use to send ping to source node
saddrll.sll_family = PF_PACKET;
saddrll.sll_ifindex = hwa->if_index;
saddrll.sll_protocol = htons(ETH_P_IP);
bind(send_ping_pf_sockfd, (struct sockaddr *) &saddrll, sizeof(saddrll));
printf("%s :%s", hwa->if_name, ((hwa->ip_alias) == IP_ALIAS) ? " (alias)\n" : "\n");
if ( (sa = hwa->ip_addr) != NULL)
printf("IP addr = %s\n", Sock_ntop_host(sa, sizeof(*sa)));
prflag = 0;
i = 0;
do {
if (hwa->if_haddr[i] != '\0') {
prflag = 1;
break;
}
} while (++i < IF_HADDR);
if (prflag) {
printf(" HW addr = ");
ptr = hwa->if_haddr;
i = IF_HADDR;
do {
printf("%.2x%s", *ptr++ & 0xff, (i == 1) ? " " : ":");
} while (--i > 0);
}
printf("\n Interface Index = %d\n\n", hwa->if_index);
break;
}
}
/* creat two raw sockets for route travesal and receive ping*/
rt_sockfd = Socket(AF_INET, SOCK_RAW, 254);
setsockopt(rt_sockfd, IPPROTO_IP, IP_HDRINCL, &on, sizeof(on));
recv_ping_sockfd = Socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
setuid(getuid()); /* don't need special permissions any more */
size = 60 * 1024; /* OK if setsockopt fails */
setsockopt (recv_ping_sockfd, SOL_SOCKET, SO_RCVBUF, &size, sizeof (size));
if (source_flag == 1)
{//this node is source
struct icmp *icmp;
struct ip* ip;
int node_num;
node_num = argc + 3;
strcpy(tour_array[0], Sock_ntop_host(sa, sizeof(*sa)));//first one is source code
sprintf(tour_array[1],"%d",argc - 1);
sprintf(tour_array[2],"%d",node_num);
sprintf(tour_array[3],"%d",4);
for (i = 4; i < node_num; i++)
strcpy(tour_array[i], getipbyvm(argv[i-3]));
//////////////////////////before send we let the source node join the multicast
send_mulcst_fd = Udp_client(MC_ADDR_LIN, MC_PORT_LIN, (void **) &sasend, &salen);
recv_mulcst_fd = Socket(AF_INET, SOCK_DGRAM, 0);
Setsockopt(recv_mulcst_fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
sarecv = Malloc(salen);
memcpy(sarecv, sasend, salen);
Bind(recv_mulcst_fd, sarecv, salen);
Mcast_join(recv_mulcst_fd, sasend, salen, NULL, 0);
Mcast_set_loop(send_mulcst_fd, 0);
/////////////////////////////////////////////// this is the send tour part
rt_send(rt_sockfd, tour_array);
for(;;){
if(first_mulcst_flag == 1){
printf("wait for first multicast info\n");
recv_all(recv_mulcst_fd, salen);
first_mulcst_flag = 0;
char buf[MAXLINE];
//sleep(1);
snprintf(buf, sizeof(buf), "<<<<< Node: %s I am a member of the group.>>>>>\n", myname.nodename);
send_all(send_mulcst_fd, sasend, salen, buf);
}else{
for(;;){
recv_all(recv_mulcst_fd, salen);
printf("Waiting for 5 seconds and exit\n");
}
}
}
}else{//not source node
pthread_t tid, tid2;
char source_name[IPLEN];
for( ;; )
{
FD_ZERO(&rset);
FD_SET(rt_sockfd, &rset);
maxfd = rt_sockfd;
if(rt_recved_flag == 1){
FD_SET(recv_ping_sockfd, &rset);
maxfd = max(recv_ping_sockfd, maxfd);
}
if (ns_first_flag == 0)
{
FD_SET(recv_mulcst_fd,&rset);
//maxfd = (maxfd > recv_mulcst_fd) ? maxfd : recv_mulcst_fd;
maxfd = max(maxfd, recv_mulcst_fd);
}
//printf("before select\n");
select(maxfd + 1, &rset, NULL, NULL, NULL);
if (FD_ISSET(rt_sockfd, &rset))
{
printf("receive route travelsal paket\n");
n = rt_recv(rt_sockfd, tour_array);
memcpy(dest_ip_addr, tour_array[0], IPLEN);
if (n < 0) {
if (errno == EINTR)
continue;
else
err_sys("receive tour packet error");
}
get_vmname(tour_array[0], source_name);
if (ns_first_flag == 1)
{
ns_first_flag = 0;
rt_recved_flag = 1;
// join the multicast first
send_mulcst_fd = Udp_client(MC_ADDR_LIN, MC_PORT_LIN, (void **) &sasend, &salen);
recv_mulcst_fd = Socket(AF_INET, SOCK_DGRAM, 0);
Setsockopt(recv_mulcst_fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
sarecv = Malloc(salen);
memcpy(sarecv, sasend, salen);
Bind(recv_mulcst_fd, sarecv, salen);
Mcast_join(recv_mulcst_fd, sasend, salen, NULL, 0);
Mcast_set_loop(send_mulcst_fd, 0);
//create a thread for ping
Pthread_create(&tid, NULL, &ping, NULL);
}
if(last_node_flag == 0){
rt_send(rt_sockfd, tour_array);
}else{
//create a thread to handle last operations
Pthread_create(&tid2, NULL, &ls_send_mul, &send_mulcst_fd);
}
}
if (FD_ISSET(recv_mulcst_fd, &rset))
{//recv multicast info
if (first_mulcst_flag == 1 )
{
first_mulcst_flag = 0;
ping_over_flag = 1;//
//printf("ping_over_flag is %d\n", ping_over_flag);
recv_all(recv_mulcst_fd, salen);
char buf[MAXLINE];
snprintf(buf, sizeof(buf), "<<<<< Node: %s I am a member of the group.>>>>>\n", myname.nodename);
send_all(send_mulcst_fd, sasend, salen, buf);
//printf("gonna go to alarm with pof changed\n");
alarm(0);
}else{
for(;;){
recv_all(recv_mulcst_fd, salen);
}
printf("Waiting for 5 seconds and exit\n");
}
}
if (FD_ISSET(recv_ping_sockfd, &rset))
{//recv ping reply
//printf("received ping reply\n");
recvfrom(recv_ping_sockfd, buff_recv, MAXLINE, 0, NULL, NULL);
Gettimeofday (&tval, NULL);
proc_v4 (buff_recv, n, &tval);
if (ping_over_flag == 1)
alarm(0);
}
}
}
}
