/////////////////////////////////////////////////////////////////////////////
// Creation 11/12/2003                                               
// 
// 
//                           GETLOCALIP.C
//                           ------------
// 
// 
// Sylvain MARECHAL - sylvain.marechal1@libertysurf.fr
/////////////////////////////////////////////////////////////////////////////
// 
//  Retrieve first IP, and print changes (When connection to Internet for example)
//  Work only on Win32 platforms
// 
/////////////////////////////////////////////////////////////////////////////
#include <winsock2.h>
#include <ras.h>
#include <stdio.h>


/////////////////////////////////////////////////////////////////////////////
//
//        TCPUDPFORMATADRESS
/////////////////////////////////////////////////////////////////////////////
//
//  DESCRIPTION
//       --TcpUdpFormatAdress--
//  ARGUMENTS
//        Argument1:  char * host
//        Argument2: u_short port
//  RETOUR/RESULTAT
//        struct sockaddr 
//  REMARQUE
//  Rev 11/12/2003 
//////////////////////////////////////////////////////////////////////////////
struct sockaddr TcpUdpFormatAdress( char * host, u_short port )
{
    struct sockaddr_in addr;
    struct sockaddr addrRet;
    struct hostent FAR *lphost ;
    u_long IP;
    
    
    memset((char*)&addr, 0, sizeof(addr));
    /*	Soit on fournit une adresse IP, soit on fournit un nom	*/
    if ((IP = inet_addr(host)) == (u_long)INADDR_NONE)
    {
	if ((lphost  = gethostbyname(host))==NULL)
	{
            memset( (char * )&addrRet, 0, sizeof(addrRet) );
	    return  addrRet;
	}
	addr.sin_family = lphost->h_addrtype;
#ifdef _WIN16 /* A définir dans le projet WIN16	*/
	_fmemcpy (&addr.sin_addr, lphost->h_addr, lphost->h_length);
#else /*	WIN32, UNIX*/
	memcpy (&addr.sin_addr, lphost->h_addr_list[0], lphost->h_length);
#endif
    }
    else
    {
        addr.sin_family = AF_INET;
        addr.sin_addr.s_addr = IP;
    }
    
    /*  Port destination    */    
    addr.sin_port = htons((u_short)port );    
    
    memcpy( (char *)&addrRet, (char *)&addr, sizeof(addrRet) );
    return addrRet;
}


/////////////////////////////////////////////////////////////////////////////
//
//        GETLOCALIPADDRESS
/////////////////////////////////////////////////////////////////////////////
//
//  DESCRIPTION
//       --GetLocalIPAddress--
//  ARGUMENTS
//  RETOUR/RESULTAT
//        u_long 
//  REMARQUE
//  Rev 11/12/2003 
//////////////////////////////////////////////////////////////////////////////
u_long GetLocalIPAddress()
{
    struct sockaddr_in addr_in;
    struct sockaddr addr;
    char szHost[256];
    
    if( gethostname( szHost, sizeof(szHost) ) == SOCKET_ERROR )
    {
	return inet_addr("127.0.0.1");
    }
    addr = TcpUdpFormatAdress( szHost, 0 );
    memcpy( (char *)&addr_in, (char *)&addr, sizeof(addr_in) );
    return addr_in.sin_addr.s_addr;
}



/////////////////////////////////////////////////////////////////////////////
//
//        GETLOCALIP
/////////////////////////////////////////////////////////////////////////////
//
//  DESCRIPTION
//       --GetLocalIP--
//  ARGUMENTS
//  RETOUR/RESULTAT
//        char * 
//  REMARQUE
//  Rev 11/12/2003 
//////////////////////////////////////////////////////////////////////////////
char * GetLocalIP()
{
    u_long ul_addr;
    struct in_addr * pin_addr;
    ul_addr = GetLocalIPAddress();
    pin_addr = (struct in_addr *)&ul_addr;
    return inet_ntoa( *pin_addr );
}


/////////////////////////////////////////////////////////////////////////////
//
//        PRINTIP
/////////////////////////////////////////////////////////////////////////////
//
//  DESCRIPTION
//       --PrintIP--
//  ARGUMENTS
//  RETOUR/RESULTAT
//        void 
//  REMARQUE
//  Rev 11/12/2003 
//////////////////////////////////////////////////////////////////////////////
void PrintIP()
{
    printf( "your IP address is '%s'\n", GetLocalIP() ) ;
}




/////////////////////////////////////////////////////////////////////////////
//
//        CONNECTIONNOTIFICATION
/////////////////////////////////////////////////////////////////////////////
//
//  DESCRIPTION
//       --ConnectionNotification--
//  ARGUMENTS
//        Argument1: LPVOID lpvThreadParam
//  RETOUR/RESULTAT
//        DWORD WINAPI 
//  REMARQUE
//  Rev 11/12/2003 
//////////////////////////////////////////////////////////////////////////////
DWORD WINAPI ConnectionNotification( LPVOID lpvThreadParam )
{     
    DWORD (WINAPI *pfNotifyAddrChange)(OUT PHANDLE, IN LPOVERLAPPED);
    HANDLE hIpHlpApi = LoadLibrary("iphlpapi.dll");
    
    pfNotifyAddrChange = NULL;
    if( hIpHlpApi )
    {
	pfNotifyAddrChange = (DWORD (WINAPI *)(OUT PHANDLE, IN LPOVERLAPPED))GetProcAddress ((HMODULE) hIpHlpApi, "NotifyAddrChange");
	if( pfNotifyAddrChange )
	{
	    while(1)
	    {
		if( (*pfNotifyAddrChange)(NULL,NULL) == NO_ERROR )
		{
		    PrintIP();
		}
		else
		{
		    printf( "NotifyAddrChange() error (%d)\n", GetLastError() );
		    break;
		}
	    }
	}
    }

    if( ! pfNotifyAddrChange )
    {
	HANDLE hActive = CreateEvent(NULL, FALSE, FALSE, NULL);
	DWORD (WINAPI *pfRasConnectionNotificationA)(HRASCONN, HANDLE, DWORD);
	HANDLE hRasApi = LoadLibrary("rasapi32.dll");
	DWORD ret = -1;
	char szLastIP[20];
    
	strcpy( szLastIP, GetLocalIP() ) ;
	
	pfRasConnectionNotificationA = (DWORD (WINAPI *)(HRASCONN, HANDLE, DWORD)) GetProcAddress ((HMODULE) hRasApi, "RasConnectionNotificationA");
	if( ! pfRasConnectionNotificationA )
	{
	    printf( "Can't find RasConnectionNotificationA() in rasapi32.dll\n" );
	}
	else
	{
	    ret = (*pfRasConnectionNotificationA)((HRASCONN)INVALID_HANDLE_VALUE, hActive, RASCN_Connection | RASCN_Disconnection);
	    if(ret != 0)
	    {
		printf( "RasConnectionNotificationA() error (%d)\n", GetLastError() );
	    }
	}
	while(1)
	{

	    
	    ret = WaitForSingleObject(hActive, 1000);
	    if( ret == WAIT_OBJECT_0 )
	    {
		PrintIP();
	    }
	    else if( ret == WAIT_TIMEOUT )
	    {
		char szIP[20];
    
		strcpy( szIP, GetLocalIP() ) ;
		if( strcmp(szIP, szLastIP) != 0 )
		{
		    strcpy( szLastIP, szIP ) ;
		    PrintIP();
		}
		else
		{
		    printf( "Timeout elapsed : no change in IP address\n" );
		}
	    }
	    else
	    {
		printf( "WaitForSingleObject() error (%d)\n", GetLastError() );
	    }
	}
    }
    printf( "ConnectionNotification() : Exiting thread\n" );
    return -1;    
}


/////////////////////////////////////////////////////////////////////////////
//
//        NOTIFYIPCHANGE
/////////////////////////////////////////////////////////////////////////////
//
//  DESCRIPTION
//       --NotifyIPChange--
//  ARGUMENTS
//  RETOUR/RESULTAT
//        int 
//  REMARQUE
//  Rev 11/12/2003 
//////////////////////////////////////////////////////////////////////////////
int NotifyIPChange() 
{
    HANDLE hThread; DWORD IDThread;
    hThread = CreateThread( NULL, 0, ConnectionNotification, (LPVOID)NULL, 0, &IDThread );
    return (hThread != NULL ? 0 : -1);
}




/////////////////////////////////////////////////////////////////////////////
//
//        MAIN
/////////////////////////////////////////////////////////////////////////////
//
//  DESCRIPTION
//       --main--
//  ARGUMENTS
//  RETOUR/RESULTAT
//        void 
//  REMARQUE
//  Rev 11/12/2003 
//////////////////////////////////////////////////////////////////////////////
void main()
{
#ifdef _WIN32
    WSADATA wsaData;
#endif

#ifdef _WIN32
    WSAStartup(0x202, &wsaData);
#endif
    PrintIP();
    NotifyIPChange();
    Sleep(INFINITE);
}


DWORD NotifyAddrChange(
  PHANDLE Handle,
  LPOVERLAPPED overlapped
);