void senderFunc() {
/*some other code */
if((s1 = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1)
    error_handler("\nERROR: in Socket\n");
    memset((char *) &me, 0, sizeof(me));
    me.sin_family = AF_INET;
    me.sin_port = PORT;
    if (inet_aton(G_IP, &me.sin_addr)==0)
    {
        fprintf(stderr, "inet_aton() failed\n");
        exit(1);
    }
    printf("\Tick - %d : %s",cntr++,str);
    sprintf(b1, "%s",str);  // Some Information in b1 buffer to transfer 
    if(sendto(s1, b1, sizeof(b1),0,(struct sockaddr *) &me,n)==-1)
    error_handler("\nERROR: in sendto()\n");
    close (s1);
    return;
    }
}

int receiverFunc () {
	struct sockaddr_in other, me;
	int s2, n, i = 1;
	char b2[BUFLEN];//, b2[BUFLEN];
	s2 = socket(AF_INET, SOCK_DGRAM,0);
	me.sin_family = AF_INET;
	me.sin_port = PORT;
	me.sin_addr.s_addr = htonl(INADDR_ANY);
	bind(s2,(struct sockaddr *)&me, sizeof(me));
	n=sizeof(other);
	int incr = 0;
	while (i){
		recvfrom (s2,b2,BUFLEN,0,(struct sockaddr *) &other, &n);
		printf ("\nSubnet 2: Tick - %d : %s",incr++, b2);
	}
	return 0;
}

ping -c 10 -s 100 -q 192.168.2.1
....
....
10 packets transmitted, 10 received, 0% packet loss, time 8999ms

/*
# Copyright (C) 2003-2011 David M. Whitney (aka "dwhitney67")
#
# This program is free software: you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free Software
# Foundation, either version 3 of the License, or (at your option) any later
# version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with
# this program. If not, see <http://www.gnu.org/licenses/>.
*/

#include <TCPClientSocket.h>
#include <SocketUtility.h>

#include <sys/time.h>

#include <string>
#include <iostream>
#include <iomanip>
#include <unistd.h>
#include <csignal>
#include <cstring>
#include <cassert>


bool done = false;

double ComputeMsDelay(const timeval& tbegin, const timeval& tend);
void   sigHandler(int signo);


int main(int argc, char** argv)
{
  const std::string remoteAddr = (argc > 1 ? argv[1] : "127.0.0.1");

  signal(SIGINT, sigHandler);

  try
  {
    // Create the raw socket (root-permissions required!)
    socketpp::TCPClientSocket sock(AF_INET, SOCK_RAW, IPPROTO_ICMP);

    setuid(getuid());

    // Build the IP and ICMP headers
    static const size_t IP_LEN = sizeof(ip) + sizeof(icmphdr) + sizeof(timeval);

    unsigned char datagram[IP_LEN] = {0};
    ip*           iph    = reinterpret_cast<ip*>(datagram);
    icmphdr*      icmph  = reinterpret_cast<icmphdr*>(datagram + sizeof(ip));
    timeval*      tbegin = reinterpret_cast<timeval*>(datagram + sizeof(ip) + sizeof(icmphdr));

    iph->ip_hl  = sizeof(ip) >> 2;
    iph->ip_v   = 4;
    iph->ip_tos = IPTOS_PREC_ROUTINE;
    iph->ip_len = htons(IP_LEN);
    iph->ip_id  = htons(54321);
    iph->ip_off = 0;
    iph->ip_ttl = IPDEFTTL;
    iph->ip_p   = IPPROTO_ICMP;

    in_addr_t src = inet_addr("10.0.0.2");
    in_addr_t dst = inet_addr(remoteAddr.c_str());

    memcpy(&iph->ip_src, &src, sizeof(iph->ip_src));
    memcpy(&iph->ip_dst, &dst, sizeof(iph->ip_dst));

    iph->ip_sum = socketpp::headerChecksum(reinterpret_cast<const uint16_t*>(iph), iph->ip_hl << 2);

    double totalDelay = 0;
    int    seq        = 1;

    // Send ICMP datagram
    sockaddr_in dst_sin;
    sock.fillAddress(reinterpret_cast<sockaddr*>(&dst_sin), sizeof(dst_sin), 0, remoteAddr.c_str());

    for (int id = 1; !done; ++id, ++seq)
    {
      memset((char*) icmph, 0, sizeof(icmphdr));
      gettimeofday(tbegin, 0);

      icmph->type             = ICMP_ECHO;
      icmph->code             = 0;
      icmph->un.echo.id       = htons(id);
      icmph->un.echo.sequence = htons(seq);
      icmph->checksum         = socketpp::headerChecksum(reinterpret_cast<const uint16_t*>(icmph),
                                                         sizeof(icmphdr) + sizeof(timeval));

      sock.send(std::basic_string<unsigned char>(datagram, datagram + IP_LEN), dst_sin);

      // Check if a reply is forthcoming...
      timeval timeout = {5, 0};

      if (sock.activityDetected(&timeout))
      {
        // Receive reply
        std::basic_string<unsigned char> response;
        sock >> response;

        // get the time value from the response packet
        const timeval* begin = reinterpret_cast<const timeval*>(response.data() + (IP_LEN - sizeof(timeval)));

        // Compute and display time delay
        timeval end;
        gettimeofday(&end, 0);

        const double delay = ComputeMsDelay(*begin, end);
        totalDelay += delay;

        std::cout << "time: " << delay << " ms" << std::endl;

        usleep(500000);   // delay half second before sending next ICMP packet
      }
      else
      {
        std::cout << "no response from remote host." << std::endl;
        done = true;
      }
    }

    std::cout << "\navg time: " << totalDelay / seq << " ms" << std::endl;
  }
  catch (socketpp::SocketException& e)
  {
    std::cerr << e.what() << std::endl;
    return 1;
  }
}


double ComputeMsDelay(const timeval& tbegin, const timeval& tend)
{
  time_t      secs  = tend.tv_sec  - tbegin.tv_sec;
  suseconds_t usecs = tend.tv_usec - tbegin.tv_usec;

  if (usecs < 0)
  {
    --secs;
    usecs += 1000000;
  }

  return ((double) secs + (double) usecs / 1000000) * 1000;
}


void sigHandler(int signo)
{
  done = true;
}