Beispiel #1
0
const void* longest_match_reducer(const void *lhs, const void *rhs) {
  struct ifi_info *ifi = (struct ifi_info*)rhs;
  struct ifi_info *this_ifi = (struct ifi_info*)lhs;

  // Now check if (server's IP addr & server network mask) is the
  // same as (client's IP addr & client network mask). If yes,
  // store it. (Only if the prefix match is longer than any
  // previous prefix match found, thus far).

  char serv_snaddr_str[40], cli_snaddr_str[40];

  struct sockaddr *serv_snaddr = get_subnet_addr(this_ifi->ifi_addr,
                                                 ifi->ifi_ntmaddr);
  struct sockaddr *cli_snaddr  = get_subnet_addr(ifi->ifi_addr,
                                                 ifi->ifi_ntmaddr);

  strcpy(serv_snaddr_str, Sock_ntop_host(serv_snaddr, sizeof(SA)));
  strcpy(cli_snaddr_str,  Sock_ntop_host(cli_snaddr,  sizeof(SA)));

  free(cli_snaddr);
  free(serv_snaddr);

  // this_ifi->ifi_myflags stores the length of the longet prefix, and
  // this_ifi->ifi_brdaddr stores the actual entry that is the longest.

  UINT ntm_len = get_ntm_len(ifi->ifi_ntmaddr);

  printf("[2] Comparing Server '%s' and Client '%s' IP. len(netmask): %d\n", serv_snaddr_str, cli_snaddr_str, ntm_len);
  if (!strcmp(serv_snaddr_str, cli_snaddr_str) && ntm_len > this_ifi->ifi_myflags) {
    printf("Server IP '%s' matches client IP '%s' with length '%d'\n", serv_snaddr_str, cli_snaddr_str, ntm_len);
    this_ifi->ifi_myflags = ntm_len;
    this_ifi->ifi_brdaddr = ifi->ifi_addr;
  }
  return lhs;
}
void print_report ()
{
  int stat;
  /* Removed to compile cleanly with -Wall */
  //double rtt, krtt;
  char str[NI_MAXHOST];
      
  stat = sock_cmp_addr (sarecv, salast, salen);

  /* if this reply comes from source different from the previous
     one, print the full host information */

  if (stat != 0) {
    stat = getnameinfo (sarecv, salen, str, sizeof(str), NULL, 0, 0);
    if (stat == 0) {
      printf (" %s (%s)", str, Sock_ntop_host (sarecv, salen));
    } else {
      printf (" %s", Sock_ntop_host (sarecv, salen));
    }
    memcpy (salast, sarecv, salen);
  }

  /* calculate and print the round trip time using user-level timestamps */

  sub_tv (recvtv, sendtv, difftv);
  /* Removed to compile cleanly with -Wall */
  //rtt = time_to_double (difftv);

  printf ("  %.3f", time_to_double (difftv));
}
Beispiel #3
0
int main (int argc, char **argv)
{
	struct ifi_info	*ifi, *ifihead;
	struct sockaddr	*sa;
	u_char	*ptr;
	int i, family, doaliases;

	if (argc != 2)
	{
		printf ("usage: ictl  <doaliases>\n");
		exit(1);
	}
   printf("\n");
	family = AF_INET;
	doaliases = atoi(argv[1]);

	for (ifihead = ifi = Get_ifi_info(family, doaliases); ifi != NULL; ifi = ifi->ifi_next)
	{
		printf("%s: < ", ifi->ifi_name);

		if (ifi->ifi_flags & IFF_UP)
                          		printf("UP ");
		if (ifi->ifi_flags & IFF_BROADCAST)
			printf("BCAST ");
		if (ifi->ifi_flags & IFF_MULTICAST)
			printf("MCAST ");
		if (ifi->ifi_flags & IFF_LOOPBACK)
			printf("LOOP ");
		if (ifi->ifi_flags & IFF_POINTOPOINT)
			printf("P2P ");
		printf(">\n");

		ifi->ifi_hlen = 6;
		if ( (i = ifi->ifi_hlen) > 0)
		{
			printf("  MAC Address: ");
			ptr = (u_char *)ifi->ifi_hwaddr;
			//printf ("%x:%x:%x:%x:%x:%x\n", *(ptr +2), *(ptr +3), *(ptr +4),
         //	*(ptr +5), *(ptr + 6), *(ptr + 7));
			ptr++;
			do
			{
				printf("%s%x", (i == ifi->ifi_hlen) ? "  " : ":", *++ptr);
			}
			while (--i > 0);
				printf("\n");
		}
      if ( (sa = ifi->ifi_addr) != NULL)
			printf("  IP Address: %s\n", Sock_ntop_host(sa, sizeof(*sa)));
		if ( (sa = ifi->ifi_brdaddr) != NULL)
			printf("  Broadcast Address: %s\n", Sock_ntop_host(sa, sizeof(*sa)));
		if ( (sa = ifi->ifi_dstaddr) != NULL)
			printf("  Point-to-Point Address: %s\n", Sock_ntop_host(sa, sizeof(*sa)));
		printf("\n");
	}
	free_ifi_info(ifihead);
	exit(0);
}
Beispiel #4
0
int
main(int argc, char **argv)
{
    int					sockfd;
    char				*buf;
    pid_t				pid;
    ssize_t				n;
    struct rt_msghdr	*rtm;
    struct sockaddr		*sa, *rti_info[RTAX_MAX];
    struct sockaddr_in	*sin;

    if (argc != 2)
        err_quit("usage: getrt <IPaddress>");

    sockfd = Socket(AF_ROUTE, SOCK_RAW, 0);	/* need superuser privileges */

    buf = Calloc(1, BUFLEN);	/* and initialized to 0 */

    rtm = (struct rt_msghdr *) buf;
    rtm->rtm_msglen = sizeof(struct rt_msghdr) + sizeof(struct sockaddr_in);
    rtm->rtm_version = RTM_VERSION;
    rtm->rtm_type = RTM_GET;
    rtm->rtm_addrs = RTA_DST;
    rtm->rtm_pid = pid = getpid();
    rtm->rtm_seq = SEQ;

    sin = (struct sockaddr_in *) (rtm + 1);
    sin->sin_len = sizeof(struct sockaddr_in);
    sin->sin_family = AF_INET;
    Inet_pton(AF_INET, argv[1], &sin->sin_addr);

    Write(sockfd, rtm, rtm->rtm_msglen);

    do {
        n = Read(sockfd, rtm, BUFLEN);
    } while (rtm->rtm_type != RTM_GET || rtm->rtm_seq != SEQ ||
             rtm->rtm_pid != pid);
    /* end getrt1 */

    /* include getrt2 */
    rtm = (struct rt_msghdr *) buf;
    sa = (struct sockaddr *) (rtm + 1);
    get_rtaddrs(rtm->rtm_addrs, sa, rti_info);
    if ( (sa = rti_info[RTAX_DST]) != NULL)
        printf("dest: %s\n", Sock_ntop_host(sa, sa->sa_len));

    if ( (sa = rti_info[RTAX_GATEWAY]) != NULL)
        printf("gateway: %s\n", Sock_ntop_host(sa, sa->sa_len));

    if ( (sa = rti_info[RTAX_NETMASK]) != NULL)
        printf("netmask: %s\n", Sock_masktop(sa, sa->sa_len));

    if ( (sa = rti_info[RTAX_GENMASK]) != NULL)
        printf("genmask: %s\n", Sock_masktop(sa, sa->sa_len));

    exit(0);
}
Beispiel #5
0
int
main(int argc, char **argv)
{
	int		sockfd, n, nq;
	char	recvline[MAXLINE + 1];
	socklen_t	len;
	struct sockaddr_storage	ss;

	if (argc != 3)
		err_quit("usage: a.out <hostname or IPaddress> <service or port#>");

	sockfd = Udp_connect(argv[1], argv[2]);

	len = sizeof(ss);
	Getpeername(sockfd, (SA *)&ss, &len);
	printf("connected to %s\n", Sock_ntop_host((SA *)&ss, len));

	Write(sockfd, "", 2);	/* send 1-byte datagram */

	n = Recv(sockfd, recvline, MAXLINE, MSG_PEEK);

	Ioctl(sockfd, FIONREAD, &nq);	/* check FIONREAD support */
	printf("%d bytes from PEEK, %d bytes pending\n", n, nq);

	n = Read(sockfd, recvline, MAXLINE);
	recvline[n] = 0;	/* null terminate */
	Fputs(recvline, stdout);

	exit(0);
}
Beispiel #6
0
void dg_cli(FILE *fp, int sockfd, const SA *pservaddr, socklen_t servlen)
{
	int n;
	const int on = 1;
	char sendline[MAXLINE], recvline[MAXLINE + 1];
	socklen_t len;
	struct sockaddr *preply_addr;

	preply_addr = (struct sockaddr *)Malloc(servlen);

	Setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on));

	Signal(SIGALRM, recvfrom_alarm);

	while (Fgets(sendline, MAXLINE, fp) != NULL)
	{
		Sendto(sockfd, sendline, strlen(sendline), 0, pservaddr, servlen);
		alarm(5);
		for ( ; ; )
		{
			if (sigsetjmp(jmpbuf, 1) != 0)
				break;
			len = servlen;
			n = Recvfrom(sockfd, recvline, MAXLINE, 0, preply_addr, &len);
			recvline[n] = 0;
			printf("from %s: %s", (char *)Sock_ntop_host(preply_addr, len), recvline);
		}
	}
	free(preply_addr);
}
Beispiel #7
0
void
bind_mcast(const char *ifname, SA *mcastsa, socklen_t salen, int alias)
{
#ifdef	MCAST
	int				fd;
	struct sockaddr	*msa;

	if (alias)
		return;		/* only one mcast join per interface */

	printf("joining %s on %s\n", Sock_ntop_host(mcastsa, salen), ifname);

	fd = Socket(mcastsa->sa_family, SOCK_DGRAM, 0);

	Setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
	Bind(fd, mcastsa, salen);

	Mcast_join(fd, mcastsa, salen, ifname, 0);

	addrs[naddrs].addr_sa = mcastsa;
	addrs[naddrs].addr_salen = salen;
	addrs[naddrs].addr_ifname = ifname;	/* save pointer, not string copy */
	addrs[naddrs].addr_fd = fd;
	addrs[naddrs].addr_flags = ADDR_MCAST;
	naddrs++;
#endif
}
int
main(int argc, char **argv)
{
	int		sockfd, n, npend;
	char	recvline[MAXLINE + 1];
	socklen_t	len;
	struct sockaddr_storage	ss;

	if (argc != 3)
		err_quit("usage: a.out <hostname or IPaddress> <service or port#>");

	sockfd = Tcp_connect(argv[1], argv[2]);

	len = sizeof(ss);
	Getpeername(sockfd, (SA *)&ss, &len);
	printf("connected to %s\n", Sock_ntop_host((SA *)&ss, len));

	for ( ; ; ) {
		if ( (n = Recv(sockfd, recvline, MAXLINE, MSG_PEEK)) == 0)
			break;		/* server closed connection */

		Ioctl(sockfd, FIONREAD, &npend);	/* check FIONREAD support */
		printf("%d bytes from PEEK, %d bytes pending\n", n, npend);

		n = Read(sockfd, recvline, MAXLINE);
		recvline[n] = 0;	/* null terminate */
		Fputs(recvline, stdout);
	}
	exit(0);
}
Beispiel #9
0
void dg_cli(FILE *fp, int sockfd, const SA *pservaddr, socklen_t servlen)
{
	int				n;
	const int		on = 1;
	char			sendline[MAXLINE], recvline[MAXLINE + 1];
	socklen_t		len;
	struct sockaddr	*preply_addr;
	preply_addr = Malloc(servlen);
	Setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on)); //告诉内核广播
	Signal(SIGALRM, recvfrom_alarm);
	while (Fgets(sendline, MAXLINE, fp) != NULL) {
		Sendto(sockfd, sendline, strlen(sendline), 0, pservaddr, servlen);
		alarm(5);
		for ( ; ; ) {
			len = servlen;
			n = recvfrom(sockfd, recvline, MAXLINE, 0, preply_addr, &len);
			if (n < 0) {
				if (errno == EINTR)
					break;		/* waited long enough for replies */
				else
					err_sys("recvfrom error");
			} else {
				recvline[n] = 0;	/* null terminate */
				printf("from %s: %s",
						Sock_ntop_host(preply_addr, len), recvline);
			}
		}
	}
	free(preply_addr);
}
int 
main(int argc, char **argv) 
{ 
	int sockfd, n; 
	char recvline[MAXLINE + 1]; 
	socklen_t len; 
	struct sockaddr_storage ss; 
 
	if (argc != 3) 
		err_quit("usage: daytimetcpcli <hostname/IPaddress> <service/port#>"); 
 
	sockfd = Tcp_connect(argv[1], argv[2]); 
 
	len = sizeof(ss); 
	Getpeername(sockfd, (SA *)&ss, &len); 
	printf("connected to %s\n", Sock_ntop_host((SA *)&ss, len)); 
	sleep(5);
	
	while ( (n = Read(sockfd, recvline, MAXLINE)) > 0) { 
		recvline[n] = 0; /* null terminate */ 
		fprintf(stderr, "nbytes read: %d\n", n);
		Fputs(recvline, stdout); 
	} 
	exit(0); 
} 
Beispiel #11
0
const void* is_local_interface_reducer(const void *lhs, const void *rhs) {
  struct ifi_info *serv_ifi = (struct ifi_info*)lhs;
  struct ifi_info *cli_ifi = (struct ifi_info*)rhs;

  char serv_addr[40], cli_addr[40];
  strcpy(cli_addr,  Sock_ntop_host(cli_ifi->ifi_addr,  sizeof(SA)));
  strcpy(serv_addr, Sock_ntop_host(serv_ifi->ifi_addr, sizeof(SA)));

  printf("[1] Comparing Client '%s' and server '%s' IP.\n", cli_addr, serv_addr);
  if (!strcmp(cli_addr, serv_addr)) {
    // They are the same.
    printf("Server and client are on the same machine.\n");
    serv_ifi->ifi_myflags = 1;
  }
  return lhs;
}
Beispiel #12
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);
}
void proc(char *ptr, ssize_t len, struct msghdr *msg, struct timeval *tvrecv){
	int     hlenl, icmplen;
	double  rtt;
	struct ip *ip;
	struct icmp *icmp;
	struct timeval *tvsend;

	ip = (struct ip *) ptr;      /* start of IP header */
	hlenl = ip->ip_hl << 2;      /* length of IP header */
	if (ip->ip_p != IPPROTO_ICMP)
		return;                  /* not ICMP */

	icmp = (struct icmp *) (ptr + hlenl);   /* start of ICMP header */
	if ( (icmplen = len - hlenl) < 8)
		return;                  /* malformed packet */

	if (icmp->icmp_type == ICMP_ECHOREPLY) {
		if (icmp->icmp_id != pid)
			return;                /* not a response to our ECHO_REQUEST */
		if (icmplen < 16)
			return;                /* not enough data to use */

		tvsend = (struct  timeval  *) icmp->icmp_data;
		tv_sub (tvrecv, tvsend);
		rtt = tvrecv->tv_sec * 1000.0 + tvrecv->tv_usec / 1000.0;

		printf ("%d bytes from %s: seq=%u, ttl=%d, rtt=%.3f ms\n",
	                 icmplen, Sock_ntop_host (pr->sarecv, pr->salen),
	                icmp->icmp_seq, ip->ip_ttl, rtt);

	}
}
Beispiel #14
0
int
main(int argc, char **argv)
{
  int       c;
  struct addrinfo *ai;
  char *h;

  opterr = 0;   /* don't want getopt() writing to stderr */
  while ( (c = getopt(argc, argv, "m:v")) != -1) {
    switch (c) {
    case 'm':
      if ( (max_ttl = atoi(optarg)) <= 1)
        err_quit("invalid -m value");
      break;

    case 'v':
      verbose++;
      break;

    case '?':
      err_quit("unrecognized option: %c", c);
    }
  }

  if (optind != argc-1)
    err_quit("usage: traceroute [ -m <maxttl> -v ] <hostname>");
  host = argv[optind];

  pid = getpid();
  Signal(SIGALRM, sig_alrm);

  ai = Host_serv(host, NULL, 0, 0);

  h = Sock_ntop_host(ai->ai_addr, ai->ai_addrlen);
  printf("traceroute to %s (%s): %d hops max, %d data bytes\n",
       ai->ai_canonname ? ai->ai_canonname : h,
       h, max_ttl, datalen);

    /* initialize according to protocol */
  if (ai->ai_family == AF_INET) {
    pr = &proto_v4;
#ifdef  IPV6
  } else if (ai->ai_family == AF_INET6) {
    pr = &proto_v6;
    if (IN6_IS_ADDR_V4MAPPED(&(((struct sockaddr_in6 *)ai->ai_addr)->sin6_addr)))
      err_quit("cannot traceroute IPv4-mapped IPv6 address");
#endif
  } else
    err_quit("unknown address family %d", ai->ai_family);

  pr->sasend = ai->ai_addr;   /* contains destination address */
  pr->sarecv = Calloc(1, ai->ai_addrlen);
  pr->salast = Calloc(1, ai->ai_addrlen);
  pr->sabind = Calloc(1, ai->ai_addrlen);
  pr->salen = ai->ai_addrlen;

  traceloop();

  exit(0);
}
Beispiel #15
0
int
main(int argc, char **argv)
{
    int				sockfd, n;
    char			recvline[MAXLINE + 1];
    socklen_t		len;
    struct sockaddr	*sa;

    if (argc != 3)
        err_quit("usage: daytimetcpcli <hostname/IPaddress> <service/port#>");

    sockfd = Tcp_connect(argv[1], argv[2]);

    sa = Malloc(sizeof(struct sockaddr_storage));
    len = sizeof(struct sockaddr_storage);
    Getpeername(sockfd, sa, &len);
    printf("connected to %s\n", Sock_ntop_host(sa, len));
    sleep(5);

    while ( (n = Read(sockfd, recvline, MAXLINE)) > 0)
    {
        recvline[n] = 0;	/* null terminate */
        printf("%d bytes: %s", n, recvline);
    }
    exit(0);
}
Beispiel #16
0
void dg_cli(FILE* fp, int sockfd, const SA* pservaddr, socklen_t servlen)
{
    int n;
    char sendline[MAXLINE], recvline[MAXLINE + 1];
    socklen_t len;
    struct sockaddr* preply_addr;

    preply_addr = Malloc(servlen);

    Signal(SIGALRM, recvfrom_alarm);

    while (Fgets(sendline, MAXLINE, fp) != NULL) {
        Sendto(sockfd, sendline, strlen(sendline), 0, pservaddr, servlen);

        alarm(5);
        for (;;) {
            if (sigsetjmp(jmpbuf, 1) != 0) break;
            len = servlen;
            n = Recvfrom(sockfd, recvline, MAXLINE, 0, preply_addr, &len);
            recvline[n] = 0; /* null terminate */
            printf("from %s: %s", Sock_ntop_host(preply_addr, servlen),
                   recvline);
        }
    }
}
Beispiel #17
0
/* 显示发送和接收数据报的个数,并计算丢包率 */
void statistics(int signo)
{
    printf("\n----------- %s ping statistics -----------\n", Sock_ntop_host(pr->sarecv, pr->salen));
    int lost = 100*(nsent-nrecv)/nsent;
    printf("%d packets transmitted, %d received, %d packet lost\n", nsent, nrecv, lost);
    close(sockfd);
    exit(1);
}
void prifinfo_plus(struct ifi_info *ifi)
{
	struct sockaddr	*sa;
	u_char		*ptr;
	int		i;

	for (;ifi != NULL; ifi = ifi->ifi_next)
	{
		printf("%s: ", ifi->ifi_name);
		if (ifi->ifi_index != 0)
			printf("(%d) ", ifi->ifi_index);
		printf("<");

		if ( (i = ifi->ifi_hlen) > 0) {
			ptr = ifi->ifi_haddr;
			do {
				printf("%s%x", (i == ifi->ifi_hlen) ? "  " : ":", *ptr++);
			} while (--i > 0);
			printf("\n");
		}
		if (ifi->ifi_mtu != 0)
			printf("  MTU: %d\n", ifi->ifi_mtu);

		if ( (sa = ifi->ifi_addr) != NULL)
			printf("  IP addr: %s\n",
						Sock_ntop_host(sa, sizeof(*sa)));

		//Assignment 2 modifications

		if ( (sa = ifi->ifi_ntmaddr) != NULL)
			printf("  network mask: %s\n",
						Sock_ntop_host(sa, sizeof(*sa)));



		if ( (sa = ifi->ifi_brdaddr) != NULL)
			printf("  broadcast addr: %s\n",
						Sock_ntop_host(sa, sizeof(*sa)));
		if ( (sa = ifi->ifi_dstaddr) != NULL)
			printf("  destination addr: %s\n",
						Sock_ntop_host(sa, sizeof(*sa)));
	}

}
Beispiel #19
0
int send_to_next_node(struct tour_packet *packet,int nodes) {

	struct ip *ip_hdr ;
	ip_hdr = (struct ip *)&(packet->ip_header); 
	struct sockaddr_in *destnode = (struct sockaddr_in *)malloc(sizeof(struct sockaddr_in));
        uint32_t src_addr = host_ip_struct.s_addr;		
	destnode->sin_family = AF_INET;
	packet->index++;
	struct in_addr addr_test;
	addr_test.s_addr = packet->vm_list[packet->index].s_addr;
	
         while  (getVMbyIPaddr(addr_test) == NULL) {
		printf("\n Next address not retreivable from Tour \n");
                if (packet->index == packet->end_index) {
			printf("\n Since address not accessible from packet, Ending Tour \n");
                        tour_ended = 1;
                        return 1;
                }
		packet->index++;
	}
	
	destnode->sin_addr.s_addr = packet->vm_list[packet->index].s_addr; 
	int size = sizeof(struct tour_packet);
	//calculate check sum
        uint16_t ck_sum = in_cksum((uint16_t *)packet,size);	
	ip_hdr->ip_hl  = sizeof(struct ip) >> 2;
	ip_hdr->ip_v = IPVERSION;
	ip_hdr->ip_tos = 0;

	ip_hdr->ip_len = htons(size);
	ip_hdr->ip_id  = htons(ID);
	ip_hdr->ip_off = 0;
	ip_hdr->ip_ttl = TTL_VAL;
	ip_hdr->ip_p   = PROTO_ID;
	ip_hdr->ip_src.s_addr = src_addr;
	ip_hdr->ip_dst.s_addr = packet->vm_list[packet->index].s_addr; 
	ip_hdr->ip_sum = ck_sum;
	int len = sizeof(struct tour_packet);

	int s =  sendto(rt_fd,packet,size,0,(struct sockaddr *)destnode,sizeof(struct sockaddr));
	//printf("send outputs %d \n",s);
	if (s<=0){
		perror("send error");
	}

	char *ipaddr = Sock_ntop_host((struct sockaddr *)destnode, sizeof(struct sockaddr));
	char vmip[INET_ADDRSTRLEN];
	char src_ip[INET_ADDRSTRLEN];
	struct in_addr des;
	des.s_addr = ip_hdr->ip_dst.s_addr;
	inet_ntop(AF_INET,&des,vmip,INET_ADDRSTRLEN);
	printf("\n Sending Tour socket %s dest %s src address is %s \n",ipaddr,vmip,inet_ntop(AF_INET,&ip_hdr->ip_src,src_ip,INET_ADDRSTRLEN));
	return size;

}
Beispiel #20
0
void
proc_v6(char *ptr, ssize_t len, struct timeval* tvrecv)
{
#ifdef	IPV6
	int					hlen1, icmp6len;
	double				rtt;
	struct ip6_hdr		*ip6;
	struct icmp6_hdr	*icmp6;
	struct timeval		*tvsend;

	ip6 = (struct ip6_hdr *) ptr;		/* start of IPv6 header */
	hlen1 = sizeof(struct ip6_hdr);
	if (ip6->ip6_nxt != IPPROTO_ICMPV6)
		err_quit("next header not IPPROTO_ICMPV6");

	icmp6 = (struct icmp6_hdr *) (ptr + hlen1);
	if ( (icmp6len = len - hlen1) < 8)
		err_quit("icmp6len (%d) < 8", icmp6len);

	if (icmp6->icmp6_type == ICMP6_ECHO_REPLY) {
		if (icmp6->icmp6_id != pid)
			return;			/* not a response to our ECHO_REQUEST */
		if (icmp6len < 16)
			err_quit("icmp6len (%d) < 16", icmp6len);

		tvsend = (struct timeval *) (icmp6 + 1);
		tv_sub(tvrecv, tvsend);
		rtt = tvrecv->tv_sec * 1000.0 + tvrecv->tv_usec / 1000.0;

		printf("%d bytes from %s: seq=%u, hlim=%d, rtt=%.3f ms\n",
				icmp6len, Sock_ntop_host(pr->sarecv, pr->salen),
				icmp6->icmp6_seq, ip6->ip6_hlim, rtt);

	} else if (verbose) {
		printf("  %d bytes from %s: type = %d, code = %d\n",
				icmp6len, Sock_ntop_host(pr->sarecv, pr->salen),
				icmp6->icmp6_type, icmp6->icmp6_code);
	}
#endif	/* IPV6 */
}
Beispiel #21
0
void getNodeName(){
	struct hwa_info	*hwa, *hwahead;
	struct sockaddr	*sa;
	struct hostent *hptr;
	for (hwahead = hwa = get_hw_addrs(); hwa != NULL; hwa = hwa->hwa_next) {

		if(strcmp(hwa->if_name, "eth0") == 0 || strcmp(hwa->if_name, "wlan0") == 0 ){
			if ( (sa = hwa->ip_addr) != NULL)
				myNodeIP = Sock_ntop_host(sa, sizeof(*sa));
		}
	}
	myNodeIP = Sock_ntop_host(sa, sizeof(*sa));
	if(inet_aton(myNodeIP, &ip_list[0]) != 0){
			if((hptr = gethostbyaddr(&ip_list[0], sizeof(struct in_addr), AF_INET)) == NULL){
                    err_quit ( "gethostbyaddress error for IP address: %s: %s" , myNodeIP, hstrerror(h_errno));
            		debug("errno: %s", strerror(errno));
            }
            printf("The server host name is %s.\n", hptr->h_name);
            myNodeName =(char*) malloc(strlen(hptr->h_name));
            strcpy(myNodeName,hptr->h_name);
    }    
}
Beispiel #22
0
void dg_cli(FILE *fp, int sockfd, const SA *pservaddr, socklen_t servlen)
{
    int n, maxfdp1;
	const int on = 1;
	char sendline[MAXLINE], recvline[MAXLINE+1];
	fd_set rset;
	socklen_t len;
	struct sockaddr *preply_addr;

	preply_addr = (struct sockaddr *)Malloc(servlen);

	Setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on));

	Pipe(pipefd);
	maxfdp1 = max(sockfd, pipefd[0]) + 1;
	FD_ZERO(&rset);

	Signal(SIGALRM, recvfrom_alarm);

	while (Fgets(sendline, MAXLINE, fp) != NULL)
	{
		Sendto(sockfd, sendline, strlen(sendline), 0, pservaddr, servlen);
		
		alarm(5);
		for ( ; ; )
		{
			FD_SET(sockfd, &rset);
			FD_SET(pipefd[0], &rset);
			if ((n = select(maxfdp1, &rset, NULL, NULL, NULL)) < 0)
			{
				if (errno = EINTR)
					continue;
				else
					err_sys("select error");
			}
			if (FD_ISSET(sockfd, &rset))
			{
				len = servlen;
				n = Recvfrom(sockfd, recvline, MAXLINE, 0, preply_addr, &len);
				recvline[n] = 0;
				printf("from %s: %s", (char *)Sock_ntop_host(preply_addr, len), recvline);
			}
			if (FD_ISSET(pipefd[0], &rset))
			{
				Read(pipefd[0], &n, 1); /* time out */
				break;
			}
		}
	}
	free(preply_addr);
}
Beispiel #23
0
int main(int argc, char** argv)
{
    int c;
    struct addrinfo* ai;
    char* h;

    opterr = 0; /* don't want getopt() writing to stderr */
    while ((c = getopt(argc, argv, "v")) != -1) {
        switch (c) {
        case 'v':
            verbose++;
            break;

        case '?':
            err_quit("unrecognized option: %c", c);
        }
    }

    if (optind != argc - 1) err_quit("usage: ping [ -v ] <hostname>");
    host = argv[optind];

    pid = getpid() & 0xffff; /* ICMP ID field is 16 bits */
    Signal(SIGALRM, sig_alrm);

    ai = Host_serv(host, NULL, 0, 0);

    h = Sock_ntop_host(ai->ai_addr, ai->ai_addrlen);
    printf("PING %s (%s): %d data bytes\n",
           ai->ai_canonname ? ai->ai_canonname : h, h, datalen);

    /* 4initialize according to protocol */
    if (ai->ai_family == AF_INET) {
        pr = &proto_v4;
#ifdef IPV6
    } else if (ai->ai_family == AF_INET6) {
        pr = &proto_v6;
        if (IN6_IS_ADDR_V4MAPPED(
                &(((struct sockaddr_in6*)ai->ai_addr)->sin6_addr)))
            err_quit("cannot ping IPv4-mapped IPv6 address");
#endif
    } else
        err_quit("unknown address family %d", ai->ai_family);

    pr->sasend = ai->ai_addr;
    pr->sarecv = Calloc(1, ai->ai_addrlen);
    pr->salen = ai->ai_addrlen;

    readloop();

    exit(0);
}
Beispiel #24
0
void dg_cli(FILE *fp, int sockfd, const SA *pservaddr, socklen_t servlen)
{
	int n;
	const int on = 1;
	char sendline[MAXLINE], recvline[MAXLINE + 1];
	fd_set rset;
	sigset_t sigset_alrm, sigset_empty;
	socklen_t len;
	struct sockaddr *preply_addr;

	preply_addr = (struct sockaddr *)Malloc(servlen);

	Setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on));

	FD_ZERO(&rset);

	Sigemptyset(&sigset_empty);
	sigemptyset(&sigset_alrm);
	Sigaddset(&sigset_alrm, SIGALRM);

	Signal(SIGALRM, recvfrom_alarm);

	while (Fgets(sendline, MAXLINE, fp) != NULL)
	{
		Sendto(sockfd, sendline, strlen(sendline), 0, pservaddr, servlen);

		Sigprocmask(SIG_BLOCK, &sigset_alrm, NULL);
		alarm(5);
		for ( ; ; )
		{
			FD_SET(sockfd, &rset);
			n = pselect(sockfd+1, &rset, NULL, NULL, NULL, &sigset_empty);
			if (n < 0)
			{
				if (errno = EINTR)
					break;
				else
					err_sys("pselect error");
			}
			else if (n != 1)
				err_sys("pselect error: returned %d", n);

			len = servlen;
			n = Recvfrom(sockfd, recvline, MAXLINE, 0, preply_addr, &len);
			recvline[n] = 0; //null terminate
			printf("from %s: %s", (char *)Sock_ntop_host(preply_addr, len), recvline);
		}
	}
	free(preply_addr);
}
Beispiel #25
0
int main(int argc,char *argv[]){
	int fd,i,n;
	pid_t pid;
	struct sockaddr *sa,*rt_info[MAX_RT_INFO];
	struct rt_msghdr *rtm;
	char *buf;
	fd = Socket(AF_ROUTE,SOCK_RAW,0);
	buf = Malloc(BUFLEN);
	rtm = (struct rt_msghdr *)buf;
	sa = (struct sockaddr_in *)(rtm+1);
	rtm->rtm_msglen = sizeof(struct rt_msghdr) + sizeof(struct sockaddr);
	rtm->rtm_version = RTM_VERSION;
	rtm->rtm_type = RTM_GET;
	rtm->rtm_addrs = RTA_DST;
	rtm->rtm_pid = pid = getpid();
	rtm->rtm_seq = SEQ;
	sa->sin_family = AF_INET;
	inet_pton(AF_INET,argv[1],&sin->sin_addr);

	Write(fd,rtm,rtm->rtm_msglen);
	do{
		n = Read(fd,rtm,BUFLEN);
	}while(rtm->rtm_seq != SEQ || rtm->rtm_pid != pid || rtm->rtm_type != RTM_GET);
	rtm = (struct rt_msghdr*)buf;
	sa = (struct sockaddr*)(buf+1);
	get_rtaddr(rtm->rtm_addrs,sa,rt_info);
	if(sa = rt_info[RTAX_DST] != NULL)
		printf("dst:%s\n",Sock_ntop_host(sa,sa->sa_len);
	if(sa = rt_info[RTAX_GATEWAY] != NULL)
		printf("gateway:%s\n",Sock_ntop_host(sa,sa->sa_len);
	if(sa = rt_info[RTAX_NETMASK] != NULL)
		printf("netmask:%s\n",Sock_netmask(sa,sa->sa_len);
	if(sa = rt_info[RTAX_GENMASK] != NULL)
		printf("genmask:%s\n",Sock_netmask(sa,sa->sa_len);
	return (0);
}
Beispiel #26
0
void server_setup(void) {
  struct hwa_info *h;
  struct hwa_info *h_head;
  struct sockaddr *sa;

  h_head = Get_hw_addrs();
  for (h = h_head; h != NULL; h = h->hwa_next) {
    if (!strcmp(h->if_name, "eth0") && h->ip_addr != NULL) {
      sa = h->ip_addr;
      strcpy(my_ipaddr, (char *)Sock_ntop_host(sa, sizeof(*sa)));
      my_hostname[0] = '\0';
      ip_address_to_hostname(my_ipaddr, my_hostname);
      INFO("My IP Address: %s & hostname: %s\n", my_ipaddr, my_hostname);
      break;
    }
  }
}
Beispiel #27
0
void createIfList()
{
	struct hwa_info	*hwa, *hwahead;
	struct sockaddr	*sa;
	char   *ptr, ipaddr[16],hwaddr[18],tmp[4];
	int    i, prflag, ifindex;

	for (hwahead = hwa = Get_hw_addrs(); hwa != NULL; hwa = hwa->hwa_next) 
    {
        if(strcmp(hwa->if_name,"eth0") != 0)
            continue;
		
		if ( (sa = hwa->ip_addr) != NULL)
            strcpy(ipaddr,(char *)Sock_ntop_host(sa, sizeof(*sa)));
				
		prflag = 0;
		i = 0;
		do {
			if (hwa->if_haddr[i] != '\0') {
				prflag = 1;
				break;
			}
		} while (++i < IF_HADDR);

        strcpy(hwaddr,"");
		if (prflag) {
			ptr = hwa->if_haddr;
			i = IF_HADDR;
			do {
                int j;
				sprintf(tmp,"%.2x%s", *ptr++ & 0xff, (i == 1) ? "" : ":");
                if(i == 1)
                    strncat(hwaddr,tmp,2);
                else
                    strncat(hwaddr,tmp,3);
			} while (--i > 0);
		}

        hwaddr[18] = 0;
		ifindex = hwa->if_index;
		addToIfList(ipaddr, ifindex, hwaddr);
	}

	free_hwa_info(hwahead);
    return;
}
Beispiel #28
0
void get_conn(client_conn *conn) {
  const char *server_ip = (const char*)cargs->ip_addr;
  int server_port = cargs->serv_portno;
  struct sockaddr *serv_sa = inet_pton_sa(server_ip, server_port);

  vector *ifaces = get_all_interfaces();
  struct ifi_info serv_ifi;

  memset(&serv_ifi, 0, sizeof(serv_ifi));
  serv_ifi.ifi_addr = serv_sa;
  conn->is_local = FALSE;

  // Check if the server is on the same machine as the client.
  algorithm_reduce(ifaces, is_local_interface_reducer, &serv_ifi);

  // serv_ifi.ifi_myflags is == 1 if the client & server share an IP
  // address.
  if (serv_ifi.ifi_myflags) {
    // Client & server are on the same machine.
    conn->is_local = TRUE;
    conn->cli_sa  = inet_pton_sa("127.0.0.1", 0);
    conn->serv_sa = inet_pton_sa("127.0.0.1", server_port);
    return;
  }

  serv_ifi.ifi_myflags = 0; // The length of the longest match.
  algorithm_reduce(ifaces, longest_match_reducer, &serv_ifi);

  if (serv_ifi.ifi_brdaddr) {
    conn->is_local = TRUE;
    conn->serv_sa  = serv_sa;
    char client_ip[40];
    strcpy(client_ip, Sock_ntop_host(serv_ifi.ifi_brdaddr, sizeof(SA)));

    // Client bind(2)s to port 0 (locally).
    conn->cli_sa = inet_pton_sa(client_ip, 0);
    return;
  }

  // We could not find any local interfaces that match. Let the kernel
  // choose the outgoing interface for us.
  VERBOSE("serv_sa: %s\n", Sock_ntop(serv_sa, sizeof(*serv_sa)));
  conn->cli_sa  = inet_pton_sa("0.0.0.0", 0);
  conn->serv_sa = serv_sa;
}
Beispiel #29
0
void processPgResponse(void *ptr, ssize_t len, SockAddrIn senderAddr, int addrlen) {
	int icmplen;
	struct ip *ip = (struct ip *) ptr;		/* start of IP header */	
	
	if (ip->ip_p != IPPROTO_ICMP)
		return;				/* not ICMP */
	int ipheaderlen = ip->ip_hl << 2;		/* length of IP header */	
	struct icmp	*icmp = (struct icmp *) (ptr + ipheaderlen);	/* start of ICMP header */
	if ( (icmplen = len - ipheaderlen) < 8)
		return;				/* malformed packet */

	if (icmp->icmp_type != 0) {
		return;
	}
	if (ntohs(icmp->icmp_id) != PING_ICMPID) {
		return;
	}
	
	if (endOfTour == 1) {
		lastPings++;
		if (lastPings == 5) {
			char finalMsg[MAXLINE];
			int i = 0;
			for (i = 0; i < numPinging;++i) {
				pthread_cancel(ping_thread_ids[i]);	
			}

			sprintf(finalMsg, "<<<<< This is node %s . Tour has ended. Group members please identify yourselves. >>>>>", myNodeName);
			printf("Node %s. Sending: %s\n", myNodeName, finalMsg);
			sendto(mcastSendSd, finalMsg, MAXLINE, 0, sasend, salen);
		}
	}

	struct timeval	*tvsend;
	struct timeval tvrecv;
	Gettimeofday(&tvrecv, NULL);
	
	tvsend = (struct timeval *) icmp->icmp_data;
	tv_sub(&tvrecv, tvsend);
	double rtt = tvrecv.tv_sec * 1000.0 + tvrecv.tv_usec / 1000.0;

	printf("%d bytes from %s: seq=%u, ttl=%d, rtt=%.3f ms\n",
			icmplen, Sock_ntop_host((SA *)&senderAddr, addrlen),
			icmp->icmp_seq, ip->ip_ttl, rtt);
}
Beispiel #30
0
int main (int argc, char **argv)
{
  int c;
  struct addrinfo *ai;
  char *host;
  int loop_ttl ();

  opterr = 0;
  while ( (c = getopt (argc, argv, "m:")) != -1) {
    switch (c) {
    case 'm':
      if ( (max_ttl = atoi(optarg)) <= 1) {
	err_quit ("invalid -m value");
      }
      break;
    default:
      err_quit ("unrecognizd option: %c", c);
    }
  }

  if (optind != argc - 1) {
    err_quit ("usage: trout [ -m <maxttl>] <hostname>");
  }
  host = argv[optind];
  ai = Host_serv (host, NULL, 0, 0);

  printf ("trout to %s (%s): %d hops max, %d data bytes\n",
	  ai->ai_canonname,
	  Sock_ntop_host (ai->ai_addr, ai->ai_addrlen),
	  max_ttl, datalen);

  if (ai->ai_family != AF_INET) {
    err_quit ("unknown address family %d", ai->ai_family);
  }

  sasend = ai->ai_addr;
  salen = ai->ai_addrlen;
  sarecv = Calloc (1, salen);
  salast = Calloc (1, salen);
  sabind = Calloc (1, salen);

  exit (0);
}