/*
 * MibTable.h 
 * Copyright (c) 2011 Antillia.com TOSHIYUKI ARAI. ALL RIGHTS RESERVED. 
 */


// SOL9
// 2009/08/24

#pragma once

#include <sol/Object.h>
#include <sol/Arg.h>
#include <sol/String.h>
#include <sol/StringT.h>

#include <sol/ArgList.h>
#include <sol/ArgT.h>
#include <sol/ArgListT.h>

#include <Mstcpip.h>
#include <time.h>

namespace SOL {

typedef LPTSTR (NTAPI *IPv6AddressToString)(const IN6_ADDR *Addr, char* stri);


class MibTable :public Object {

public:
    //Pure virtual fuction
    virtual bool getTable() = 0; 

public:
    virtual void display(HWND hwnd) {};

public:
    virtual void clear() {};

public:
    //Pure virtual function
    virtual void display() = 0;

private:
    // For Ntdll.dll module
    HMODULE             hNtdll;

private:
    //Utility function to convert IPV6 Address (IN6_ADDR structure) to a string
    IPv6AddressToString    ipv6ToString;

public:
    /**
     */
    MibTable()
        :hNtdll(NULL),
        ipv6ToString(NULL)
    {
        //2009/09/03
        //hNtdll = GetModuleHandle("Ntdll.dll");
        hNtdll = LoadLibrary(_T("Ntdll.dll"));

        if (hNtdll) {
            ipv6ToString = (IPv6AddressToString)GetProcAddress(hNtdll, "RtlIpv6AddressToStringA");
        } else {
            //printf("Failed to get ipV6ToString\n");
        }
    }

public:
    /**
     * Destructor
     */
    ~MibTable()
    {
        if (hNtdll) {
            FreeLibrary(hNtdll);
            hNtdll = NULL;
        }
    }

    //
protected:
    unsigned short getPort(DWORD port)
    {
        return ntohs((unsigned short)port);
    }

protected:
    unsigned long getScopeId(DWORD scopeId)
    {
        return ntohl(scopeId);
    }


/*
struct sockaddr_in{
   short sin_family;
   unsigned short sin_port;
   struct in_addr sin_addr;
   char sin_zero[8];
};

typedef struct sockaddr_in6 {
  ADDRESS_FAMILY  sin6_family;
  USHORT  sin6_port;
  ULONG  sin6_flowinfo;
  IN6_ADDR  sin6_addr;
  union {
    ULONG  sin6_scope_id;
    SCOPE_ID  sin6_scope_struct;
   };
}
 SOCKADDR_IN6, *PSOCKADDR_IN6;
*/

/*
typedef union _SOCKADDR_INET {
  SOCKADDR_IN    Ipv4;
  SOCKADDR_IN6   Ipv6;
  ADDRESS_FAMILY si_family;
}SOCKADDR_INET, *PSOCKADDR_INET;
*/
protected:
    bool getPhysicalAddress(__in unsigned char* physAddr,
        __in size_t size,
        __out StringT<char>& string)
    {
        bool rc = false;
        if (physAddr && size == 6) {
            char buffer[128];
            sprintf(buffer, "%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x",
                physAddr[0],
                physAddr[1],
                physAddr[2],
                physAddr[3],
                physAddr[4],
                physAddr[5]);
            rc = true;
            string = buffer;
        }
        return rc;    
    }

public:
    bool getIPAddress(__in SOCKADDR_INET& inet,
         __out StringT<char>& family,
         __out StringT<char>& address,
         __out unsigned short& port)
    {
        bool rc = false;
        if (inet.si_family == AF_INET) {
            family = "IPv4";
            //
            getIPAddress(inet.Ipv4.sin_addr, address);
            port = getPort(inet.Ipv4.sin_port);
            rc = true;
        }
        if (inet.si_family == AF_INET6) {
            family = "IPv6";
            //IN6_ADDR
            getIPAddress(inet.Ipv6.sin6_addr, address);
            //call ntohs
            port = getPort(inet.Ipv6.sin6_port);
            rc = true;
        }

        return rc;
    }

public:
    bool getIPAddress(__in SOCKADDR_INET& inet,
         __out StringT<char>& address)
    {
        bool rc = false;
        if (inet.si_family == AF_INET) {
            //
            getIPAddress(inet.Ipv4.sin_addr, address);
            rc = true;
        }
        if (inet.si_family == AF_INET6) {
            //IN6_ADDR
            getIPAddress(inet.Ipv6.sin6_addr, address);
            rc = true;
        }
        return rc;
    }



protected:
    //IPv4
    bool getIPAddress(__in in_addr address, __out StringT<char>& string)
    {
        bool rc = false;
        char* addr = inet_ntoa(address);
        if (addr) {
            string = addr;
            rc = true;    
        }
        return rc;    
    }

protected:
    //IPv4
    bool getIPAddress(__in DWORD address, __out StringT<char>& string)
    {
        bool rc = false;
        //IPv4
           in_addr ipAddr;
        memset(&ipAddr, 0, sizeof(ipAddr));
        ipAddr.S_un.S_addr = address;

        char* addr = inet_ntoa(ipAddr);
        if (addr) {
            string = addr;
            rc = true;    
        }
        return rc;    
    }

protected:
    //IPv6
    bool getIPAddress(__in IN6_ADDR address, __out StringT<char>& string)
    {
        bool rc = false;
        char buffer[128];
        memset(buffer, 0, sizeof(buffer));

        if (ipv6ToString) {
            if ((*ipv6ToString)(&address, buffer)) {
                rc = true;
                string = buffer;
            }
        }
        return rc;    
    }

protected:
    //IPv6 
    bool getIPAddress(__in unsigned char* address, __out StringT<char>& string)
    {
        bool rc = false;
        char buffer[128];
        memset(buffer, 0, sizeof(buffer));

        if (ipv6ToString) {
            if ((*ipv6ToString)((IN6_ADDR*)address, buffer)) {
                rc = true;
                string = buffer;
            }
        }
        return rc;    
    }


public:
    // 2009/09/03 Moved here from IPInterfaceTable
    bool getLocalTime32(__in time_t t, __out StringT<char>& localTime)
    {
        bool rc = false;
        struct tm _tm;
        errno_t    error = _localtime32_s(&_tm, (__time32_t* )&t);
        
        if (error) {
            return rc;
        }

        char buffer[32];
        memset(buffer, 0, sizeof(buffer));
        error = asctime_s(buffer, sizeof(buffer), &_tm);        
        if (error) {
            return rc;
        }

        localTime = buffer;
        rc = true;
        return rc;
    }

public:
    bool getLocalTime(__in LARGE_INTEGER t, __out StringT<char>& localTime)
    {
        bool rc = false;
        struct tm _tm;

    //    errno_t error;
        if (_localtime64_s(&_tm, (const __time64_t *)&t) ) {
        //if (localtime_s(&_tm, (const time_t*) &t) ) {

            //printf("Error1\n");
            return rc;
        }

        char buffer[32];
        if (asctime_s(buffer, sizeof(buffer), &_tm)) {
            printf("Invalid Argument to asctime_s\n");
            return rc;
        }
        localTime = buffer;

        rc = true;

        return rc;
    }

public:
    const char* getBoolean(BOOL value)
    {
        static const ArgT<char> types[] = {
        {"No", FALSE},
        {"Yes", TRUE}
        };

        ArgListT<char> argList(types, XtNumber(types));

        return argList.getName((int)value);
    }

protected:
    const char* getState(DWORD state)
    {
        static const char* states[] = {
        "",
         "CLOSED",
        "LISTEN",
        "SYN_SENT", 
        "SYN_RCVD", 
        "ESTABLISHED", 
        "FIN_WAIT1",
        "FIN_WAIT2", 

        "CLOSE_WAIT", 
        "CLOSING", 
        "LAST_ACK", 
        "TIME_WAIT",
        "DELETE_TCB",
        };

        const char* name = "";
        int count = XtNumber(states);
        if (state >0 && state<count) {
            name = states[state];
        }
        return name;
    }
};

}