Get IP address

Here is an example PING.C & PING.H, I'm letting you see it as an example of how to do this...

There are calls to other classes/functions but you don't need them!

THIS IS THE PING.C

#include "Ping.h"

// Specifies packing alignment for structure and union members.
#pragma pack(4)

#define WIN32_LEAN_AND_MEAN
#include <winsock2.h>
#include <stdio.h>
#include <stdlib.h>

#define ICMP_ECHO 8
#define ICMP_ECHOREPLY 0

#define ICMP_MIN 8 // minimum 8 byte icmp packet (just header)

/* The IP header */
typedef struct iphdr {
unsigned int h_len:4; // length of the header
unsigned int version:4; // Version of IP
unsigned char tos; // Type of service
unsigned short total_len; // total length of the packet
unsigned short ident; // unique identifier
unsigned short frag_and_flags; // flags
unsigned char ttl;
unsigned char proto; // protocol (TCP, UDP etc)
unsigned short checksum; // IP checksum

unsigned int sourceIP;
unsigned int destIP;

}IpHeader;

//
// ICMP header
//
typedef struct _ihdr {
BYTE i_type;
BYTE i_code; /* type sub code */
USHORT i_cksum;
USHORT i_id;
USHORT i_seq;
/* This is not the std header, but we reserve space for time */
ULONG timestamp;
}IcmpHeader;

#define xmalloc(s) HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,(s))
#define xfree(p) HeapFree (GetProcessHeap(),0,(p))

void fill_icmp_data(char *, int);
USHORT checksum(USHORT *, int);
void decode_resp(char *buf, int bytes,struct sockaddr_in *from,
int* elapsedTime, int* dataSize, int* icmp_seq);

//-----------------------------------------------------------------------------
int Ping( const CString& hostToPing,
CString& HostToPingIP,
int* elapsedTime /*=NULL*/,
int* dataSize /*=NULL*/,
int* icmp_seq /*=NULL*/)
//-----------------------------------------------------------------------------
{

WSADATA wsaData;
SOCKET sockRaw;
struct sockaddr_in dest,from;
struct hostent * hp;
int bread, datasize=DEF_PACKET_SIZE;;
int fromlen = sizeof(from);
int timeout = 1000;
char *dest_ip;
char *icmp_data;
char *recvbuf;
unsigned int addr=0;
USHORT seq_no = 0;

if (WSAStartup(MAKEWORD(2,1),&wsaData) != 0){
CErrorMgt::RaiseError("WSAStartup failed: %d\n",GetLastError());
return (STATUS_FAILED);
}

sockRaw = WSASocket (AF_INET,
SOCK_RAW,
IPPROTO_ICMP,
NULL, 0,0);

if (sockRaw == INVALID_SOCKET) {
CErrorMgt::RaiseError("WSASocket() failed: %d\n",WSAGetLastError());
return (STATUS_FAILED);
}
bread = setsockopt(sockRaw,SOL_SOCKET,SO_RCVTIMEO,(char*)&timeout,
sizeof(timeout));
if(bread == SOCKET_ERROR) {
CErrorMgt::RaiseError("failed to set recv timeout: %d\n",WSAGetLastError());
return (STATUS_FAILED);
}
timeout = 1000;
bread = setsockopt(sockRaw,SOL_SOCKET,SO_SNDTIMEO,(char*)&timeout,
sizeof(timeout));
if(bread == SOCKET_ERROR) {
CErrorMgt::RaiseError("failed to set send timeout: %d\n",WSAGetLastError());
return (STATUS_FAILED);
}
memset(&dest,0,sizeof(dest));

hp = gethostbyname(hostToPing);

if (!hp){
addr = inet_addr(hostToPing);
}
if ((!hp) && (addr == INADDR_NONE) ) {
CErrorMgt::RaiseError("Unable to resolve %s\n",hostToPing);
return (STATUS_FAILED);
}

if (hp != NULL)
memcpy(&(dest.sin_addr),hp->h_addr,hp->h_length);
else
dest.sin_addr.s_addr = addr;

if (hp)
dest.sin_family = hp->h_addrtype;
else
dest.sin_family = AF_INET;

// NOTE:
//
// this is where you convert it from IN_ADDR
// to an ascii value e.g.: 255.255.255.255
//
dest_ip = inet_ntoa(dest.sin_addr);
&HostToPingIP(dest_ip);

//if (argc >2) {
// datasize = atoi(argv[2]);
//if (datasize == 0)
// datasize = DEF_PACKET_SIZE;
//}
if(dataSize!=NULL && *dataSize!=0)
datasize=*dataSize;

datasize += sizeof(IcmpHeader);

icmp_data = (char*)xmalloc(MAX_PACKET);
recvbuf = (char*)xmalloc(MAX_PACKET);

if (!icmp_data) {
CErrorMgt::RaiseError("HeapAlloc failed %d\n",GetLastError());
return (STATUS_FAILED);
}

memset(icmp_data,0,MAX_PACKET);
fill_icmp_data(icmp_data,datasize);

while(1) {
int bwrote;

((IcmpHeader*)icmp_data)->i_cksum = 0;
((IcmpHeader*)icmp_data)->timestamp = GetTickCount();

((IcmpHeader*)icmp_data)->i_seq = seq_no++;
((IcmpHeader*)icmp_data)->i_cksum = checksum((USHORT*)icmp_data,
datasize);

bwrote = sendto(sockRaw,icmp_data,datasize,0,(struct sockaddr*)&dest,
sizeof(dest));
if (bwrote == SOCKET_ERROR){
if (WSAGetLastError() == WSAETIMEDOUT) {
CErrorMgt::RaiseError("timed out in sendding\n");
return (STATUS_FAILED);//continue;
}
CErrorMgt::RaiseError("sendto failed: %d\n",WSAGetLastError());
return (STATUS_FAILED);
}
if (bwrote < datasize ) {
//fprintf(stdout,"Wrote %d bytes\n",bwrote);
}else
break;
}
bread = recvfrom(sockRaw,recvbuf,MAX_PACKET,0,(struct sockaddr*)&from,
&fromlen);
if (bread == SOCKET_ERROR){
if (WSAGetLastError() == WSAETIMEDOUT) {
CErrorMgt::RaiseError("timed out in reception\n");
return (STATUS_FAILED);//continue;
}
CErrorMgt::RaiseError("recvfrom failed: %d\n",WSAGetLastError());
return (STATUS_FAILED);
}
decode_resp(recvbuf,bread,&from,elapsedTime, dataSize, icmp_seq);
Sleep(1000);

return 0;

} // Ping

//
// The response is an IP packet. We must decode the IP header to locate
// the ICMP data
//
//-----------------------------------------------------------------------------
void decode_resp(char *buf, int bytes,struct sockaddr_in *from,
int* elapsedTime, int* dataSize, int* icmp_seq)
//-----------------------------------------------------------------------------
{
IpHeader *iphdr;
IcmpHeader *icmphdr;
unsigned short iphdrlen;

iphdr = (IpHeader *)buf;

iphdrlen = iphdr->h_len * 4 ; // number of 32-bit words *4 = bytes

if (bytes < iphdrlen + ICMP_MIN) {
printf("Too few bytes from %s\n",inet_ntoa(from->sin_addr));
}

icmphdr = (IcmpHeader*)(buf + iphdrlen);

if (icmphdr->i_type != ICMP_ECHOREPLY) {
CErrorMgt::RaiseError("non-echo type %d recvd\n",icmphdr->i_type);
return;
}
if (icmphdr->i_id != (USHORT)GetCurrentProcessId()) {
CErrorMgt::RaiseError("someone else's packet!\n");
return ;
}
//printf("%d bytes from %s:",bytes, inet_ntoa(from->sin_addr));
//printf(" icmp_seq = %d. ",icmphdr->i_seq);
//printf(" time: %d ms ",GetTickCount()-icmphdr->timestamp);
//printf("\n");
if(elapsedTime!=NULL)
*elapsedTime = GetTickCount()-icmphdr->timestamp; // in msec
if(icmp_seq!=NULL)
*icmp_seq = icmphdr->i_seq;
if(dataSize!=NULL)
*dataSize = bytes;
}

//-----------------------------------------------------------------------------
USHORT checksum(USHORT *buffer, int size)
//-----------------------------------------------------------------------------
{
unsigned long cksum=0;

while(size >1) {
cksum+=*buffer++;
size -=sizeof(USHORT);
}

if(size ) {
cksum += *(UCHAR*)buffer;
}

cksum = (cksum >> 16) + (cksum & 0xffff);
cksum += (cksum >>16);
return (USHORT)(~cksum);
}

//
// Helper function to fill in various stuff in our ICMP request.
//
//-----------------------------------------------------------------------------
void fill_icmp_data(char * icmp_data, int datasize)
//-----------------------------------------------------------------------------
{
IcmpHeader *icmp_hdr;
char *datapart;

icmp_hdr = (IcmpHeader*)icmp_data;

icmp_hdr->i_type = ICMP_ECHO;
icmp_hdr->i_code = 0;
icmp_hdr->i_id = (USHORT)GetCurrentProcessId();
icmp_hdr->i_cksum = 0;
icmp_hdr->i_seq = 0;

datapart = icmp_data + sizeof(IcmpHeader);
//
// Place some junk in the buffer.
//
memset(datapart,'E', datasize - sizeof(IcmpHeader));

}

/*

//-----------------------------------------------------------------------------
int Ping( const CString & NodeName,
CString & ElTime, CString & ErrorMessage )
//-----------------------------------------------------------------------------
{
ElTime = "0";

// Build the command line string
char CommandLine[256];
sprintf( CommandLine, "PING %s -n 1 -w 3000 > %s\\RASProbe.tmp", NodeName, Dir );

// Run the command
int Res = system( CommandLine );

// Open output file
FILE * stream = NULL;
stream = fopen( Dir+"\\RASProbe.tmp", "r" );
if ( stream == NULL )
return -1;

char s[100];
char * fRes = NULL;
CString Str;

// Seek to last line
while( (fRes = fgets(s, 100, stream)) != NULL )
Str = s;
fclose( stream );

if ( ! FileReportFlag ) printf( "%s\n", Str );

// According last line value set success or failure
int Index0 = Str.Find( "Reply" );
int Index = Str.Find( "time" );
if ( (Index0 != -1) && (Index != -1) ) {
Str = Str.Right( Str.GetLength() - Index );
Index = Str.Find( "ms" );
Str = Str.Left( Index );
// Get the time spent by ping
ElTime = Str.Right( Str.GetLength() - 5 ); // "time=%dms"
ErrorMessage = "";
return 0;
}
else {
ErrorMessage = Str;
return -1;
}

} // Ping
*/

THIS IS THE PING.H

//LIBS = kernel32.lib oldnames.lib libcmt.lib
// Don't forget to link with: ws2_32.lib

#define STATUS_FAILED 0xFFFF
#define DEF_PACKET_SIZE 32
#define MAX_PACKET 1024

int Ping( const CString& hostToPing, int* elapsedTime = NULL, int* dataSize = NULL, int* icmp_seq = NULL);

Hope this helps!

Thanks in advance,

Dan