/*
 * Toimii vain Windowissa.
 * Laita käännökseen mukaan ws2_32.lib
 * sekä iphlpapi.lib, niin onnistuu.
 */

#include <windows.h>
#include <iostream>
#include <iphlpapi.h>

#define LOCALHOST 0x0100007f

using namespace std;

static PCHAR TranslateTcpState(PCHAR szBuffer, DWORD dwState);

int main(int argc, char* argv[])
{
        int n, i, x;

        DWORD   dwAddrTable                        =       0;
        DWORD   dwForwardTable          =    0;
        DWORD   dwNetTable   =        0;
        DWORD   dwTcpTable   =        0;
        DWORD   dwUdpTable   =        0;

        DWORD   ipAddrTableLen          =    0;
        DWORD   ipForwardTableLen  = 0;
        DWORD   ipNetTableLen            =     0;
        DWORD   ipTcpTableLen                  =     0;
        DWORD   ipUdpTableLen                  =     0;

        PCHAR   ipAddrTable                        =       NULL;
        PCHAR   ipForwardTable          =    NULL;
        PCHAR   ipNetTable   =        NULL;
        PCHAR   ipTcpTable   =        NULL;
        PCHAR   ipUdpTable   =        NULL;

        PMIB_IPADDRTABLE addrTable                  =     NULL;
        PMIB_IPFORWARDTABLE forwardTable        =       NULL;
        PMIB_IPNETTABLE netTable   =        NULL;
        PMIB_TCPTABLE tcpTable        = NULL;
        PMIB_UDPTABLE udpTable        = NULL;

        // Get sizes of tables
        GetIpAddrTable(NULL, &ipAddrTableLen, FALSE);
        GetIpForwardTable(NULL, &ipForwardTableLen, FALSE);
        GetIpNetTable(NULL, &ipNetTableLen, FALSE);
        GetTcpTable(NULL, &ipTcpTableLen, FALSE);
        GetUdpTable(NULL, &ipUdpTableLen, FALSE);

        // Allocate space for tables and assign pointers
        ipAddrTable = new char[ipAddrTableLen];
        ipForwardTable = new char[ipForwardTableLen];
        ipNetTable = new char[ipNetTableLen];
        ipTcpTable = new char[ipTcpTableLen];
        ipUdpTable = new char[ipUdpTableLen];

        addrTable = (PMIB_IPADDRTABLE)ipAddrTable;
        forwardTable = (PMIB_IPFORWARDTABLE)ipForwardTable;
        netTable = (PMIB_IPNETTABLE)ipNetTable;
        tcpTable = (PMIB_TCPTABLE)ipTcpTable;
        udpTable = (PMIB_UDPTABLE)ipUdpTable;

        // Get actual tables
        dwAddrTable = GetIpAddrTable(addrTable, &ipAddrTableLen, FALSE);
        dwForwardTable = GetIpForwardTable(forwardTable, &ipForwardTableLen, FALSE);
        dwNetTable = GetIpNetTable(netTable, &ipNetTableLen, FALSE);
        dwTcpTable = GetTcpTable(tcpTable, &ipTcpTableLen, FALSE);
        dwUdpTable = GetUdpTable(udpTable, &ipUdpTableLen, FALSE);

        if (!(dwAddrTable == NO_ERROR))
                goto end;

        // Display tables
        for (n = 0 ; n < addrTable->dwNumEntries ; n++) {
                struct in_addr addr, addr2;
                DWORD dwIndex = addrTable->table[n].dwIndex;

                addr.S_un.S_addr = addrTable->table[n].dwAddr;
                cout << "IP address " << inet_ntoa(addr) << " ";

                addr.S_un.S_addr = addrTable->table[n].dwMask;
                cout << "Subnet mask " << inet_ntoa(addr) << " ";

                if (dwForwardTable == NO_ERROR) {

                        // Find from forward table
                        for (i = 0 ; i < forwardTable->dwNumEntries ; i++) {
                                if (dwIndex == forwardTable->table[n].dwForwardIfIndex) {
                                        addr.S_un.S_addr = forwardTable->table[n].dwForwardDest;
                                        cout << "Route " << inet_ntoa(addr) << " ";
                                }
                        }
                }

                if (dwNetTable == NO_ERROR) {

                        // Find MAC address from net table
                        for (i = 0 ; i < netTable->dwNumEntries ; i++) {
                                if (addrTable->table[n].dwAddr ==
                                        netTable->table[i].dwAddr) {
                                        CHAR szNetBuffer[20] = { 0 };
                                        memcpy (szNetBuffer, netTable->table[n].bPhysAddr,
                                              netTable[n].table->dwPhysAddrLen);
                                        cout << "MAC " << szNetBuffer;
                                }
                        }
                }

                cout << endl << endl;
                x = 0;

                if (dwTcpTable == NO_ERROR) {

                        cout << "Tcp ports used:" << endl;

                        // Find used TCP ports
                        for (i = 0 ; i < tcpTable->dwNumEntries ; i++) {
                                if ((tcpTable->table[i].dwLocalAddr == addrTable->table[n].dwAddr)
                                        || (tcpTable->table[i].dwLocalAddr ==
                                        0x00000000 && addrTable->table[n].dwAddr == LOCALHOST)) {
                                        CHAR szTcpBuffer[30] = { 0 };
                                        addr.S_un.S_addr = tcpTable->table[i].dwLocalAddr;
                                        addr2.S_un.S_addr = tcpTable->table[i].dwRemoteAddr;
                                        cout << "- " << inet_ntoa(addr) << " : " <<
                                                ntohs(tcpTable->table[i].dwLocalPort) << " -> "
                                                << inet_ntoa(addr2) << " : " <<
                                                ntohs(tcpTable->table[i].dwRemotePort) << " ";
                                        cout << TranslateTcpState(szTcpBuffer,
                                        tcpTable->table[i].dwState);
                                        cout << endl;
                                        x = 1;
                                }
                        }
                        if (!x) cout << "- none";
                }

                cout << endl;
                x = 0;

                if (dwUdpTable == NO_ERROR) {

                        cout << "Udp ports used:" << endl;

                        // Find used UDP ports
                        for (i = 0 ; i < udpTable->dwNumEntries ; i++) {
                                if ((udpTable->table[i].dwLocalAddr == addrTable->table[n].dwAddr)
                                        || (udpTable->table[i].dwLocalAddr == 0x00000000
                                        && addrTable->table[n].dwAddr == LOCALHOST)) {
                                        addr.S_un.S_addr = udpTable->table[i].dwLocalAddr;
                                        cout << "- " << inet_ntoa(addr) << " : " <<
                                                ntohs(udpTable->table[i].dwLocalPort);
                                        cout << endl;
                                        x = 1;
                                }
                        }
                        if (!x) cout << "- none";
                }

                cout << endl;
        }

end:

        // Clean up
        delete [] ipAddrTable;
        delete [] ipForwardTable;
        delete [] ipNetTable;
        delete [] ipTcpTable;
        delete [] ipUdpTable;

        return 0;
}

static PCHAR TranslateTcpState(PCHAR szBuffer, DWORD dwState)
{
        memset (szBuffer, 0, 30);
        switch (dwState) {
        case MIB_TCP_STATE_CLOSED:
                strcpy (szBuffer, "closed");
                break;
        case MIB_TCP_STATE_LISTEN:
                strcpy (szBuffer, "listen");
                break;
        case MIB_TCP_STATE_SYN_SENT:
                strcpy (szBuffer, "SYN sent");
                break;
        case MIB_TCP_STATE_SYN_RCVD:
                strcpy (szBuffer, "SYN received");
                break;
        case MIB_TCP_STATE_ESTAB:
                strcpy (szBuffer, "established");
                break;
        case MIB_TCP_STATE_FIN_WAIT1:
                strcpy (szBuffer, "wait 1");
                break;
        case MIB_TCP_STATE_FIN_WAIT2:
                strcpy (szBuffer, "wait 2");
                break;
        case MIB_TCP_STATE_CLOSE_WAIT:
                strcpy (szBuffer, "waiting closing");
                break;
        case MIB_TCP_STATE_CLOSING:
                strcpy (szBuffer, "closing");
                break;
        case MIB_TCP_STATE_LAST_ACK:
                strcpy (szBuffer, "ACK");
                break;
        case MIB_TCP_STATE_TIME_WAIT:
                strcpy (szBuffer, "wait");
                break;
        case MIB_TCP_STATE_DELETE_TCB:
                strcpy (szBuffer, "delete tcb");
                break;
        default:
                strcpy (szBuffer, "unknown");
        }
       
        return szBuffer;
}