arp.c File Reference

#include <stdarg.h>
#include <windef.h>
#include <winbase.h>
#include <stdio.h>
#include <stdlib.h>
#include <tchar.h>
#include <winsock2.h>
#include <iphlpapi.h>
#include <arp_msg.h>

Include dependency graph for arp.c:

Go to the source code of this file.

Macros
#define	WIN32_NO_STATUS
#define	_INC_WINDOWS

Functions
DWORD	DoFormatMessage (VOID)
DWORD	PrintEntries (PMIB_IPNETROW pIpAddRow)
DWORD	DisplayArpEntries (PTCHAR pszInetAddr, PTCHAR pszIfAddr)
DWORD	Addhost (PTCHAR pszInetAddr, PTCHAR pszEthAddr, PTCHAR pszIfAddr)
DWORD	Deletehost (PTCHAR pszInetAddr, PTCHAR pszIfAddr)
VOID	Usage (VOID)
VOID	PrintMessage (DWORD dwMessage)
VOID	PrintMessageV (DWORD dwMessage,...)
INT	main (int argc, char *argv[])

Variables
const char	SEPARATOR = '-'
int	_CRT_glob = 0

Macro Definition Documentation

_INC_WINDOWS

#define _INC_WINDOWS

Definition at line 38 of file arp.c.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 31 of file arp.c.

Function Documentation

Addhost()

DWORD Addhost	(	PTCHAR	pszInetAddr,
		PTCHAR	pszEthAddr,
		PTCHAR	pszIfAddr
	)

Definition at line 349 of file arp.c.

{
    PMIB_IPNETROW pAddHost = NULL;
    PMIB_IPNETTABLE pIpNetTable = NULL;
    DWORD dwIpAddr = 0;
    ULONG Size = 0;
    INT i, val, c;
    DWORD dwError = NO_ERROR;
 
    /* error checking */
 
    /* check IP address */
    if (pszInetAddr == NULL)
    {
        Usage();
        return ERROR_INVALID_PARAMETER;
    }
 
    dwIpAddr = inet_addr(pszInetAddr);
    if (dwIpAddr == INADDR_NONE)
    {
        PrintMessageV(MSG_ARP_BAD_IP_ADDRESS, pszInetAddr);
        return ERROR_INVALID_PARAMETER;
    }
 
    /* check MAC address */
    if (strlen(pszEthAddr) != 17)
    {
        PrintMessageV(MSG_ARP_BAD_ARGUMENT, pszEthAddr);
        return ERROR_INVALID_PARAMETER;
    }
 
    for (i = 0; i < 17; i++)
    {
        if (pszEthAddr[i] == SEPARATOR)
            continue;
 
        if (!isxdigit(pszEthAddr[i]))
        {
            PrintMessageV(MSG_ARP_BAD_ARGUMENT, pszEthAddr);
            return ERROR_INVALID_PARAMETER;
        }
    }
 
    /* We need the IpNetTable to get the adapter index */
    /* Return required buffer size */
    GetIpNetTable(pIpNetTable, &Size, 0);
 
    /* allocate memory for ARP address table */
    pIpNetTable = (PMIB_IPNETTABLE)HeapAlloc(GetProcessHeap(), 0, Size);
    if (pIpNetTable == NULL)
    {
        PrintMessage(MSG_ARP_NO_MEMORY);
        dwError = ERROR_NOT_ENOUGH_MEMORY;
        goto cleanup;
    }
 
    ZeroMemory(pIpNetTable, sizeof(*pIpNetTable));
 
    dwError = GetIpNetTable(pIpNetTable, &Size, TRUE);
    if (dwError != NO_ERROR)
    {
        _tprintf(_T("GetIpNetTable failed: %lu\n"), dwError);
        DoFormatMessage();
        goto cleanup;
    }
 
    /* reserve memory on heap and zero */
    pAddHost = (PMIB_IPNETROW)HeapAlloc(GetProcessHeap(), 0, sizeof(MIB_IPNETROW));
    if (pAddHost == NULL)
    {
        PrintMessage(MSG_ARP_NO_MEMORY);
        dwError = ERROR_NOT_ENOUGH_MEMORY;
        goto cleanup;
    }
 
    ZeroMemory(pAddHost, sizeof(MIB_IPNETROW));
 
    /* set dwIndex field to the index of a local IP address to
     * indicate the network on which the ARP entry applies */
    if (pszIfAddr)
    {
        if (sscanf(pszIfAddr, "%lx", &pAddHost->dwIndex) == EOF)
        {
            goto cleanup;
        }
    }
    else
    {
        //printf("debug print: pIpNetTable->table[0].dwIndex = %lx\n", pIpNetTable->table[0].dwIndex);
        /* needs testing. I get the correct index on my machine, but need others
         * to test their card index.  Any problems and we can use GetAdaptersInfo instead */
        pAddHost->dwIndex = pIpNetTable->table[0].dwIndex;
    }
 
    /* Set MAC address to 6 bytes (typical) */
    pAddHost->dwPhysAddrLen = 6;
 
 
    /* Encode bPhysAddr into correct byte array */
    for (i = 0; i < 6; i++)
    {
        val = 0;
        c = toupper(pszEthAddr[i * 3]);
        c = c - (isdigit(c) ? '0' : ('A' - 10));
        val += c;
        val = (val << 4);
        c = toupper(pszEthAddr[i * 3 + 1]);
        c = c - (isdigit(c) ? '0' : ('A' - 10));
        val += c;
        pAddHost->bPhysAddr[i] = (BYTE)val;
    }
 
    /* copy converted IP address */
    pAddHost->dwAddr = dwIpAddr;
 
 
    /* set type to static */
    pAddHost->dwType = MIB_IPNET_TYPE_STATIC;
 
 
    /* Add the ARP entry */
    dwError = SetIpNetEntry(pAddHost);
    if (dwError != NO_ERROR)
    {
        DoFormatMessage();
        goto cleanup;
    }
 
cleanup:
    if (pIpNetTable != NULL)
        HeapFree(GetProcessHeap(), 0, pIpNetTable);
    if (pAddHost != NULL)
        HeapFree(GetProcessHeap(), 0, pAddHost);
 
    return dwError;
}

Referenced by main().

Deletehost()

DWORD Deletehost	(	PTCHAR	pszInetAddr,
		PTCHAR	pszIfAddr
	)

Definition at line 495 of file arp.c.

{
    PMIB_IPNETROW pDelHost = NULL;
    PMIB_IPNETTABLE pIpNetTable = NULL;
    ULONG Size = 0;
    DWORD dwIpAddr = 0;
    BOOL bFlushTable = FALSE;
    DWORD dwError = NO_ERROR;
 
    /* error checking */
 
    /* check IP address */
    if (pszInetAddr == NULL)
    {
        Usage();
        return ERROR_INVALID_PARAMETER;
    }
 
    /* if wildcard is given, set flag to delete all hosts */
    if (strncmp(pszInetAddr, "*", 1) == 0)
    {
        bFlushTable = TRUE;
    }
    else
    {
        dwIpAddr = inet_addr(pszInetAddr);
        if (dwIpAddr == INADDR_NONE)
        {
            PrintMessageV(MSG_ARP_BAD_IP_ADDRESS, pszInetAddr);
            return ERROR_INVALID_PARAMETER;
        }
    }
 
    /* We need the IpNetTable to get the adapter index */
    /* Return required buffer size */
    GetIpNetTable(NULL, &Size, 0);
 
    /* allocate memory for ARP address table */
    pIpNetTable = (PMIB_IPNETTABLE) HeapAlloc(GetProcessHeap(), 0, Size);
    if (pIpNetTable == NULL)
    {
        PrintMessage(MSG_ARP_NO_MEMORY);
        dwError = ERROR_NOT_ENOUGH_MEMORY;
        goto cleanup;
    }
 
    ZeroMemory(pIpNetTable, sizeof(*pIpNetTable));
 
    dwError = GetIpNetTable(pIpNetTable, &Size, TRUE);
    if (dwError != NO_ERROR)
    {
        _tprintf(_T("GetIpNetTable failed: %lu\n"), dwError);
        DoFormatMessage();
        goto cleanup;
    }
 
    /* reserve memory on heap and zero */
    pDelHost = (MIB_IPNETROW *)HeapAlloc(GetProcessHeap(), 0, sizeof(MIB_IPNETROW));
    if (pDelHost == NULL)
    {
        PrintMessage(MSG_ARP_NO_MEMORY);
        dwError = ERROR_NOT_ENOUGH_MEMORY;
        goto cleanup;
    }
 
    ZeroMemory(pDelHost, sizeof(MIB_IPNETROW));
 
    /* set dwIndex field to the index of a local IP address to
     * indicate the network on which the ARP entry applies */
    if (pszIfAddr)
    {
        if (sscanf(pszIfAddr, "%lx", &pDelHost->dwIndex) == EOF)
        {
            goto cleanup;
        }
    }
    else
    {
        /* needs testing. I get the correct index on my machine, but need others
         * to test their card index. Any problems and we can use GetAdaptersInfo instead */
        pDelHost->dwIndex = pIpNetTable->table[0].dwIndex;
    }
 
    if (bFlushTable != FALSE)
    {
        /* delete arp cache */
        dwError = FlushIpNetTable(pDelHost->dwIndex);
        if (dwError != NO_ERROR)
        {
            DoFormatMessage();
            goto cleanup;
        }
    }
    else
    {
        /* copy converted IP address */
        pDelHost->dwAddr = dwIpAddr;
 
        /* Delete the ARP entry */
        dwError = DeleteIpNetEntry(pDelHost);
        if (dwError != NO_ERROR)
        {
            DoFormatMessage();
            goto cleanup;
        }
    }
 
cleanup:
    if (pIpNetTable != NULL)
        HeapFree(GetProcessHeap(), 0, pIpNetTable);
    if (pDelHost != NULL)
        HeapFree(GetProcessHeap(), 0, pDelHost);
 
    return dwError;
}

Referenced by main().

DisplayArpEntries()

DWORD DisplayArpEntries	(	PTCHAR	pszInetAddr,
		PTCHAR	pszIfAddr
	)

Definition at line 202 of file arp.c.

{
    DWORD i, k, dwCount;
    PMIB_IPNETTABLE pIpNetTable = NULL;
    PMIB_IPADDRTABLE pIpAddrTable = NULL;
    ULONG Size = 0;
    struct in_addr inaddr, inaddr2;
    PTCHAR pszIpAddr;
    TCHAR szIntIpAddr[20];
    DWORD dwError = NO_ERROR;
 
    /* retrieve the IP-to-physical address mapping table */
 
    /* get table size */
    GetIpNetTable(pIpNetTable, &Size, 0);
 
    /* allocate memory for ARP address table */
    pIpNetTable = (PMIB_IPNETTABLE)HeapAlloc(GetProcessHeap(), 0, Size);
    if (pIpNetTable == NULL)
    {
        PrintMessage(MSG_ARP_NO_MEMORY);
        dwError = ERROR_NOT_ENOUGH_MEMORY;
        goto cleanup;
    }
 
    ZeroMemory(pIpNetTable, sizeof(*pIpNetTable));
 
    dwError = GetIpNetTable(pIpNetTable, &Size, TRUE);
    if (dwError != NO_ERROR)
    {
        _tprintf(_T("GetIpNetTable failed: %lu\n"), dwError);
        DoFormatMessage();
        goto cleanup;
    }
 
    /* check there are entries in the table */
    if (pIpNetTable->dwNumEntries == 0)
    {
        PrintMessage(MSG_ARP_NO_ENTRIES);
        goto cleanup;
    }
 
    /* Retrieve the interface-to-ip address mapping
     * table to get the IP address for adapter */
 
    /* get table size */
    Size = 0;
    GetIpAddrTable(pIpAddrTable, &Size, 0);
 
    pIpAddrTable = (PMIB_IPADDRTABLE)HeapAlloc(GetProcessHeap(), 0, Size);
    if (pIpAddrTable == NULL)
    {
        PrintMessage(MSG_ARP_NO_MEMORY);
        dwError = ERROR_NOT_ENOUGH_MEMORY;
        goto cleanup;
    }
 
    ZeroMemory(pIpAddrTable, sizeof(*pIpAddrTable));
 
    dwError = GetIpAddrTable(pIpAddrTable, &Size, TRUE);
    if (dwError != NO_ERROR)
    {
        _tprintf(_T("GetIpAddrTable failed: %lu\n"), dwError);
        DoFormatMessage();
        goto cleanup;
    }
 
    for (k = 0; k < pIpAddrTable->dwNumEntries; k++)
    {
        if (pIpNetTable->table[0].dwIndex == pIpAddrTable->table[k].dwIndex)
        {
            //printf("debug print: pIpAddrTable->table[?].dwIndex = %lx\n", pIpNetTable->table[k].dwIndex);
            inaddr2.s_addr = pIpAddrTable->table[k].dwAddr;
            pszIpAddr = inet_ntoa(inaddr2);
            strcpy(szIntIpAddr, pszIpAddr);
        }
    }
 
    /* Count relevant ARP entries */
    dwCount = 0;
    for (i = 0; i < pIpNetTable->dwNumEntries; i++)
    {
        /* if the user has supplied their own internet address *
         * only count the arp entry which matches that */
        if (pszInetAddr)
        {
            inaddr.S_un.S_addr = pIpNetTable->table[i].dwAddr;
            pszIpAddr = inet_ntoa(inaddr);
 
            /* check if it matches, count it */
            if (strcmp(pszIpAddr, pszInetAddr) == 0)
                dwCount++;
        }
        else
        {
            /* if an address is not supplied, count all entries */
            dwCount++;
        }
    }
 
    /* Print message and leave if there are no relevant ARP entries */
    if (dwCount == 0)
    {
        PrintMessage(MSG_ARP_NO_ENTRIES);
        goto cleanup;
    }
 
    /* print header, including interface IP address and index number */
    PrintMessageV(MSG_ARP_INTERFACE, szIntIpAddr, pIpNetTable->table[0].dwIndex);
 
    /* go through all ARP entries */
    for (i = 0; i < pIpNetTable->dwNumEntries; i++)
    {
 
        /* if the user has supplied their own internet address *
         * only print the arp entry which matches that */
        if (pszInetAddr)
        {
            inaddr.S_un.S_addr = pIpNetTable->table[i].dwAddr;
            pszIpAddr = inet_ntoa(inaddr);
 
            /* check if it matches, print it */
            if (strcmp(pszIpAddr, pszInetAddr) == 0)
                PrintEntries(&pIpNetTable->table[i]);
        }
        else
            /* if an address is not supplied, print all entries */
            PrintEntries(&pIpNetTable->table[i]);
    }
 
cleanup:
    if (pIpNetTable != NULL)
        HeapFree(GetProcessHeap(), 0, pIpNetTable);
    if (pIpAddrTable != NULL)
        HeapFree(GetProcessHeap(), 0, pIpAddrTable);
 
    return dwError;
}

Referenced by main().

DoFormatMessage()

DWORD DoFormatMessage

(

VOID

)

Definition at line 63 of file arp.c.

{
    LPTSTR lpMsgBuf;
    DWORD RetVal;
 
    DWORD ErrorCode = GetLastError();
 
    if (ErrorCode != ERROR_SUCCESS)
    {
        RetVal = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
                               FORMAT_MESSAGE_FROM_SYSTEM |
                               FORMAT_MESSAGE_IGNORE_INSERTS,
                               NULL,
                               ErrorCode,
                               MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), /* Default language */
                               (LPTSTR) &lpMsgBuf,
                               0,
                               NULL );
 
        if (RetVal != 0)
        {
            _tprintf(_T("%s"), lpMsgBuf);
            LocalFree(lpMsgBuf);
            /* return number of TCHAR's stored in output buffer
             * excluding '\0' - as FormatMessage does*/
            return RetVal;
        }
    }
    return 0;
}

Referenced by Addhost(), Deletehost(), and DisplayArpEntries().

main()

INT main	(	int argc	,
		char *	argv[]
	)

Definition at line 627 of file arp.c.

{
    DWORD dwError = NO_ERROR;
 
    if ((argc < 2) || (argc > 5))
    {
       Usage();
       return EXIT_FAILURE;
    }
 
    if (argv[1][0] != '-')
    {
        Usage();
        return EXIT_SUCCESS;
    }
 
    switch (argv[1][1])
    {
        case 'a': /* fall through */
        case 'g':
            if (argc == 2)
                dwError = DisplayArpEntries(NULL, NULL);
            else if (argc == 3)
                dwError = DisplayArpEntries(argv[2], NULL);
            else if ((argc == 4) && ((strcmp(argv[2], "-N")) == 0))
                dwError = DisplayArpEntries(NULL, argv[3]);
            else if ((argc == 5) && ((strcmp(argv[3], "-N")) == 0))
                dwError = DisplayArpEntries(argv[2], argv[4]);
            else
            {
                Usage();
                dwError = ERROR_INVALID_PARAMETER;
            }
            break;
 
        case 'd':
            if (argc == 3)
                dwError = Deletehost(argv[2], NULL);
            else if (argc == 4)
                dwError = Deletehost(argv[2], argv[3]);
            else
            {
                Usage();
                dwError = ERROR_INVALID_PARAMETER;
            }
            break;
 
        case 's':
            if (argc == 4)
                dwError = Addhost(argv[2], argv[3], NULL);
            else if (argc == 5)
                dwError = Addhost(argv[2], argv[3], argv[4]);
            else
            {
                Usage();
                dwError = ERROR_INVALID_PARAMETER;
            }
            break;
 
        default:
            Usage();
            dwError = ERROR_INVALID_PARAMETER;
            break;
    }
 
    return (dwError == NO_ERROR) ? EXIT_SUCCESS : EXIT_FAILURE;
}

PrintEntries()

DWORD PrintEntries

(

PMIB_IPNETROW

pIpAddRow

)

Definition at line 150 of file arp.c.

{
    IN_ADDR inaddr;
    TCHAR cMacAddr[20];
 
    /* print IP addresses */
    inaddr.S_un.S_addr = pIpAddRow->dwAddr;
    _tprintf(_T("  %-22s"), inet_ntoa(inaddr));
 
    /* print MAC address */
    _stprintf(cMacAddr, _T("%02x-%02x-%02x-%02x-%02x-%02x"),
        pIpAddRow->bPhysAddr[0],
        pIpAddRow->bPhysAddr[1],
        pIpAddRow->bPhysAddr[2],
        pIpAddRow->bPhysAddr[3],
        pIpAddRow->bPhysAddr[4],
        pIpAddRow->bPhysAddr[5]);
    _tprintf(_T("%-22s"), cMacAddr);
 
    /* print cache type */
    switch (pIpAddRow->dwType)
    {
        case MIB_IPNET_TYPE_DYNAMIC:
            PrintMessage(MSG_ARP_DYNAMIC);
            break;
 
        case MIB_IPNET_TYPE_STATIC:
            PrintMessage(MSG_ARP_STATIC);
            break;
 
        case MIB_IPNET_TYPE_INVALID:
            PrintMessage(MSG_ARP_INVALID);
            break;
 
        case MIB_IPNET_TYPE_OTHER:
            PrintMessage(MSG_ARP_OTHER);
            break;
    }
    _putts(_T(""));
    return NO_ERROR;
}

Referenced by DisplayArpEntries().

PrintMessage()

VOID PrintMessage

(

DWORD

dwMessage

)

Definition at line 95 of file arp.c.

{
    LPTSTR lpMsgBuf;
    DWORD RetVal;
 
    RetVal = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
                           FORMAT_MESSAGE_FROM_HMODULE |
                           FORMAT_MESSAGE_IGNORE_INSERTS,
                           GetModuleHandleW(NULL),
                           dwMessage,
                           LANG_USER_DEFAULT,
                           (LPTSTR)&lpMsgBuf,
                           0,
                           NULL);
    if (RetVal != 0)
    {
        _tprintf(_T("%s"), lpMsgBuf);
        LocalFree(lpMsgBuf);
    }
}

Referenced by Addhost(), Deletehost(), DisplayArpEntries(), PrintEntries(), and Usage().

PrintMessageV()

VOID PrintMessageV	(	DWORD	dwMessage,
			...
	)

Definition at line 118 of file arp.c.

{
    LPTSTR lpMsgBuf;
    va_list args = NULL;
    DWORD RetVal;
 
    va_start(args, dwMessage);
 
    RetVal = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_HMODULE,
                           GetModuleHandleW(NULL),
                           dwMessage,
                           LANG_USER_DEFAULT,
                           (LPTSTR)&lpMsgBuf,
                           0,
                           &args);
    va_end(args);
 
    if (RetVal != 0)
    {
        _tprintf(_T("%s"), lpMsgBuf);
        LocalFree(lpMsgBuf);
    }
}

Referenced by Addhost(), Deletehost(), and DisplayArpEntries().

Usage()

VOID Usage

(

VOID

)

Definition at line 616 of file arp.c.

{
    PrintMessage(MSG_ARP_SYNTAX);
}

Variable Documentation

_CRT_glob

int _CRT_glob = 0

Definition at line 48 of file arp.c.

SEPARATOR

const char SEPARATOR = '-'

Definition at line 47 of file arp.c.

Referenced by Addhost().