1855 lines
44 KiB
C
1855 lines
44 KiB
C
/*++
|
|
|
|
Copyright (c) 1995 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
net\rtm\rtmdlg.c
|
|
|
|
Abstract:
|
|
Interactive test code for RTM dll
|
|
|
|
|
|
Author:
|
|
|
|
Vadim Eydelman
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
|
|
#ifndef NT_INCLUDED
|
|
#include <nt.h>
|
|
#endif
|
|
|
|
#ifndef _NTRTL_
|
|
#include <ntrtl.h>
|
|
#endif
|
|
|
|
#ifndef _NTURTL_
|
|
#include <nturtl.h>
|
|
#endif
|
|
|
|
#include <windows.h>
|
|
|
|
#ifndef _WINSOCKAPI_
|
|
#include <winsock.h>
|
|
#endif
|
|
|
|
#ifndef _WSIPX_
|
|
#include <wsipx.h>
|
|
#endif
|
|
|
|
#ifndef _WSNWLINK_
|
|
#include <wsnwlink.h>
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
#ifndef _ROUTING_RTM_
|
|
#include "RTM.h"
|
|
#endif
|
|
|
|
#ifndef _ROUTING_RMRTM_
|
|
#include "RMRTM.h"
|
|
#endif
|
|
|
|
|
|
#include "cldlg.h"
|
|
#include "enumdlg.h"
|
|
|
|
|
|
#if DBG
|
|
#define ASSERTERR(exp) \
|
|
if (!(exp)) { \
|
|
DbgPrint("Get last error= %d\n", GetLastError ()); \
|
|
RtlAssert( #exp, __FILE__, __LINE__, NULL ); \
|
|
}
|
|
|
|
#define ASSERTERRMSG(msg,exp) \
|
|
if (!(exp)) { \
|
|
DbgPrint("Get last error= %d\n", GetLastError ()); \
|
|
RtlAssert( #exp, __FILE__, __LINE__, msg ); \
|
|
}
|
|
#else
|
|
#define ASSERTERR(exp)
|
|
#define ASSERTERRMSG(msg,exp)
|
|
#endif
|
|
|
|
// Basic route info, present in routes of all types
|
|
typedef struct {
|
|
ROUTE_HEADER;
|
|
} RTM_XX_ROUTE, *PRTM_XX_ROUTE;
|
|
|
|
typedef union _RTM_ROUTE {
|
|
RTM_XX_ROUTE XX;
|
|
RTM_IP_ROUTE IP;
|
|
RTM_IPX_ROUTE IPX;
|
|
} RTM_ROUTE, *PRTM_ROUTE;
|
|
|
|
#define XX_INTERFACE XX.RR_InterfaceID
|
|
#define XX_PROTOCOL XX.RR_RoutingProtocol
|
|
#define XX_TIMESTAMP XX.RR_TimeStamp
|
|
|
|
#define IP_PROTOCOL IP.RR_RoutingProtocol
|
|
#define IP_INTERFACE IP.RR_InterfaceID
|
|
#define IP_METRIC IP.RR_FamilySpecificData.FSD_Metric1
|
|
#define IP_TIMESTAMP IP.RR_TimeStamp
|
|
#define IP_NET_NUM IP.RR_Network.N_NetNumber
|
|
#define IP_NET_MSK IP.RR_Network.N_NetMask
|
|
#define IP_NEXT_HOP_NUM IP.RR_NextHopAddress.N_NetNumber
|
|
#define IP_NEXT_HOP_MSK IP.RR_NextHopAddress.N_NetMask
|
|
#define IP_ADPTER_INDEX IP.RR_FamilySpecificData.FSD_AdapterIndex
|
|
#define IP_PROTOCOL_METRIC IP.RR_FamilySpecificData.FSD_ProtocolMetric
|
|
#define IP_PSD IP.RR_ProtocolSpecificData
|
|
|
|
#define IPX_PROTOCOL IPX.RR_RoutingProtocol
|
|
#define IPX_INTERFACE IPX.RR_InterfaceID
|
|
#define IPX_METRIC IPX.RR_FamilySpecificData.FSD_Ticks
|
|
#define IPX_TIMESTAMP IPX.RR_TimeStamp
|
|
#define IPX_NET_NUM IPX.RR_Network.N_NetNumber
|
|
#define IPX_NEXT_HOP_MAC IPX.RR_NextHopAddress.NHA_Mac
|
|
#define IPX_HOP_COUNT IPX.RR_FamilySpecificData.FSD_HopCount
|
|
#define IPX_PSD IPX.RR_ProtocolSpecificData
|
|
|
|
typedef struct _ENABLE_DLG_GROUP_PARAM {
|
|
HWND hCtlFirst;
|
|
BOOLEAN foundFirst;
|
|
BOOLEAN enableFlag;
|
|
} ENABLE_DLG_GROUP_PARAM, *PENABLE_DLG_GROUP_PARAM;
|
|
|
|
HANDLE *Clients;
|
|
HANDLE *Events;
|
|
HANDLE hDLLInstance;
|
|
HANDLE *InteractiveThreads;
|
|
HANDLE *IPXRIPThreads;
|
|
SOCKET *Sockets;
|
|
HANDLE *Enums;
|
|
|
|
DWORD WINAPI
|
|
ClientThread (
|
|
LPVOID param
|
|
);
|
|
|
|
|
|
BOOL CALLBACK
|
|
ClientDlgProc (
|
|
HWND hDlg,
|
|
UINT uMsg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
);
|
|
|
|
BOOL CALLBACK
|
|
DoEnable (
|
|
HWND hwnd, // handle of child window
|
|
LPARAM lParam // application-defined value
|
|
);
|
|
|
|
VOID
|
|
EnableDlgGroup (
|
|
HWND hDlg,
|
|
HWND hCtlFirst,
|
|
BOOLEAN enable
|
|
);
|
|
|
|
VOID
|
|
DoRegister (
|
|
HWND hDlg,
|
|
LONG idx
|
|
);
|
|
|
|
VOID
|
|
DoDeregister (
|
|
HWND hDlg,
|
|
LONG idx
|
|
);
|
|
|
|
VOID
|
|
SetupAdd (
|
|
HWND hDlg
|
|
);
|
|
|
|
VOID
|
|
SetupDelete (
|
|
HWND hDlg
|
|
);
|
|
|
|
VOID
|
|
SetupDequeue (
|
|
HWND hDlg
|
|
);
|
|
|
|
VOID
|
|
SetupSetEnable (
|
|
HWND hDlg
|
|
);
|
|
|
|
VOID
|
|
SetupConvert (
|
|
HWND hDlg
|
|
);
|
|
|
|
VOID
|
|
DoOperation (
|
|
HWND hDlg,
|
|
LONG idx
|
|
);
|
|
|
|
DWORD WINAPI
|
|
IPXRIPListenThread (
|
|
LPVOID param
|
|
);
|
|
|
|
DWORD WINAPI
|
|
EnumThread (
|
|
LPVOID param
|
|
);
|
|
|
|
BOOL CALLBACK
|
|
EnumDlgProc (
|
|
HWND hDlg,
|
|
UINT uMsg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
);
|
|
VOID
|
|
GetCriteria (
|
|
HWND hDlg,
|
|
DWORD *ProtocolFamily,
|
|
DWORD *flags,
|
|
PRTM_ROUTE Route
|
|
);
|
|
|
|
VOID
|
|
GetLastRoute (
|
|
HWND hDlg,
|
|
DWORD ProtocolFamily,
|
|
PRTM_ROUTE Route
|
|
);
|
|
|
|
VOID
|
|
DisplayRoute (
|
|
HWND hDlg,
|
|
DWORD ProtocolFamily,
|
|
PRTM_ROUTE Route
|
|
);
|
|
|
|
|
|
INT
|
|
IPNetCmp (
|
|
PVOID Net1,
|
|
PVOID Net2
|
|
) {
|
|
#define IPNet1 ((PIP_NETWORK)Net1)
|
|
#define IPNet2 ((PIP_NETWORK)Net2)
|
|
if (IPNet1->N_NetNumber>IPNet2->N_NetNumber)
|
|
return 1;
|
|
else if (IPNet1->N_NetNumber<IPNet2->N_NetNumber)
|
|
return -1;
|
|
else if (IPNet1->N_NetMask==IPNet2->N_NetMask)
|
|
return 0;
|
|
else if (IPNet1->N_NetMask>IPNet2->N_NetMask)
|
|
return 1;
|
|
else /*if (IPNet1->N_NetMask<IPNet2->N_NetMask)*/
|
|
return -1;
|
|
|
|
#undef IPNet2
|
|
#undef IPNet1
|
|
}
|
|
INT
|
|
IPNhaCmp (
|
|
PVOID Route1,
|
|
PVOID Route2
|
|
) {
|
|
#define IPRoute1 ((PRTM_ROUTE)Route1)
|
|
#define IPRoute2 ((PRTM_ROUTE)Route2)
|
|
if (IPRoute1->IP_NET_NUM>IPRoute2->IP_NET_NUM)
|
|
return 1;
|
|
else if (IPRoute1->IP_NET_NUM<IPRoute2->IP_NET_NUM)
|
|
return -1;
|
|
else if (IPRoute1->IP_NET_MSK==IPRoute2->IP_NET_MSK)
|
|
return 0;
|
|
else if (IPRoute1->IP_NET_MSK>IPRoute2->IP_NET_MSK)
|
|
return 1;
|
|
else /*if (IPNet1->IP_NET_MSK<IPNet2->IP_NET_MSK)*/
|
|
return -1;
|
|
|
|
#undef IPRoute2
|
|
#undef IPRoute1
|
|
}
|
|
|
|
INT
|
|
IPMetricCmp (
|
|
PVOID Route1,
|
|
PVOID Route2
|
|
) {
|
|
#define IPRoute1 ((PRTM_ROUTE)Route1)
|
|
#define IPRoute2 ((PRTM_ROUTE)Route2)
|
|
if (IPRoute1->IP_METRIC>IPRoute2->IP_METRIC)
|
|
return 1;
|
|
else if (IPRoute1->IP_METRIC<IPRoute2->IP_METRIC)
|
|
return -1;
|
|
else
|
|
return 0;
|
|
#undef IPRoute2
|
|
#undef IPRoute1
|
|
}
|
|
|
|
BOOL
|
|
IPFsdCmp (
|
|
PVOID Route1,
|
|
PVOID Route2
|
|
) {
|
|
#define IPRoute1 ((PRTM_ROUTE)Route1)
|
|
#define IPRoute2 ((PRTM_ROUTE)Route2)
|
|
return memcmp (&IPRoute1->IP.RR_FamilySpecificData,
|
|
&IPRoute2->IP.RR_FamilySpecificData,
|
|
sizeof (IPRoute1->IP.RR_FamilySpecificData))==0;
|
|
#undef IPRoute2
|
|
#undef IPRoute1
|
|
}
|
|
|
|
INT
|
|
IPHash (
|
|
PVOID Net
|
|
) {
|
|
return (*((PULONG)Net))%257;
|
|
}
|
|
|
|
VOID
|
|
IPChange (
|
|
DWORD Flags,
|
|
PVOID CurBestRoute,
|
|
PVOID PrevBestRoute
|
|
) {
|
|
fprintf (stderr, "IPRouteChange: Flags=%d, CurBest: %08x, PrevBest: %08x\n",
|
|
Flags, CurBestRoute, PrevBestRoute);
|
|
}
|
|
|
|
|
|
INT
|
|
IPXNetCmp (
|
|
PVOID Net1,
|
|
PVOID Net2
|
|
) {
|
|
#define IPXNet1 ((PIPX_NETWORK)Net1)
|
|
#define IPXNet2 ((PIPX_NETWORK)Net2)
|
|
if (IPXNet1->N_NetNumber>IPXNet2->N_NetNumber)
|
|
return 1;
|
|
else if (IPXNet1->N_NetNumber<IPXNet2->N_NetNumber)
|
|
return -1;
|
|
else
|
|
return 0;
|
|
#undef IPXNet2
|
|
#undef IPXNet1
|
|
}
|
|
|
|
INT
|
|
IPXNhaCmp (
|
|
PVOID Route1,
|
|
PVOID Route2
|
|
) {
|
|
#define IPXRoute1 ((PRTM_ROUTE)Route1)
|
|
#define IPXRoute2 ((PRTM_ROUTE)Route2)
|
|
return memcmp (IPXRoute1->IPX_NEXT_HOP_MAC,
|
|
IPXRoute2->IPX_NEXT_HOP_MAC,
|
|
sizeof (IPXRoute1->IPX_NEXT_HOP_MAC));
|
|
#undef IPXRoute2
|
|
#undef IPXRoute1
|
|
}
|
|
|
|
INT
|
|
IPXMetricCmp (
|
|
PVOID Route1,
|
|
PVOID Route2
|
|
) {
|
|
#define IPXRoute1 ((PRTM_ROUTE)Route1)
|
|
#define IPXRoute2 ((PRTM_ROUTE)Route2)
|
|
if (IPXRoute1->IPX_METRIC>IPXRoute2->IPX_METRIC)
|
|
return 1;
|
|
else if (IPXRoute1->IPX_METRIC<IPXRoute2->IPX_METRIC)
|
|
return -1;
|
|
else
|
|
return 0;
|
|
#undef IPXRoute2
|
|
#undef IPXRoute1
|
|
}
|
|
|
|
BOOL
|
|
IPXFsdCmp (
|
|
PVOID Route1,
|
|
PVOID Route2
|
|
) {
|
|
#define IPXRoute1 ((PRTM_ROUTE)Route1)
|
|
#define IPXRoute2 ((PRTM_ROUTE)Route2)
|
|
return IPXRoute1->IPX_HOP_COUNT==IPXRoute1->IPX_HOP_COUNT;
|
|
#undef IPXRoute2
|
|
#undef IPXRoute1
|
|
}
|
|
INT
|
|
IPXHash (
|
|
PVOID Net
|
|
) {
|
|
return (*((PULONG)Net))%257;
|
|
}
|
|
|
|
VOID
|
|
IPXChange (
|
|
DWORD Flags,
|
|
PVOID CurBestRoute,
|
|
PVOID PrevBestRoute
|
|
) {
|
|
fprintf (stderr, "IPXRouteChange: Flags=%d, CurBest: %08x, PrevBest: %08x\n",
|
|
Flags, CurBestRoute, PrevBestRoute);
|
|
}
|
|
|
|
DWORD
|
|
Validate (
|
|
PVOID Route
|
|
) {
|
|
return NO_ERROR;
|
|
}
|
|
|
|
int _cdecl
|
|
main (
|
|
int argc,
|
|
char **argv
|
|
) {
|
|
INT i, n, m, p;
|
|
INT id;
|
|
DWORD status;
|
|
static RTM_PROTOCOL_FAMILY_CONFIG IPXConfig = {
|
|
8*1024*1024,
|
|
257,
|
|
sizeof (RTM_IPX_ROUTE),
|
|
IPXNetCmp,
|
|
IPXNhaCmp,
|
|
IPXMetricCmp,
|
|
IPXFsdCmp,
|
|
IPHash,
|
|
Validate,
|
|
IPXChange };
|
|
static RTM_PROTOCOL_FAMILY_CONFIG IPConfig = {
|
|
8*1024*1024,
|
|
257,
|
|
sizeof (RTM_IP_ROUTE),
|
|
IPNetCmp,
|
|
IPNhaCmp,
|
|
IPXMetricCmp,
|
|
IPFsdCmp,
|
|
IPHash,
|
|
Validate,
|
|
IPChange };
|
|
status = RtmCreateRouteTable (RTM_PROTOCOL_FAMILY_IPX,
|
|
&IPXConfig);
|
|
ASSERTMSG ("Could not create IPX Route Table ", status == NO_ERROR);
|
|
|
|
status = RtmCreateRouteTable (RTM_PROTOCOL_FAMILY_IP,
|
|
&IPConfig);
|
|
|
|
|
|
ASSERTMSG ("Could not create IPX Route Table ", status == NO_ERROR);
|
|
if (argc>=4) {
|
|
n = atoi (argv[1]);
|
|
p = atoi (argv[2]);
|
|
m = atoi (argv[3]);
|
|
|
|
Clients = (HANDLE *)GlobalAlloc (GMEM_FIXED, n*sizeof (HANDLE));
|
|
ASSERTERR (Clients!=NULL);
|
|
|
|
Events = (HANDLE *)GlobalAlloc (GMEM_FIXED, n*sizeof (HANDLE));
|
|
ASSERTERR (Events!=NULL);
|
|
|
|
Enums = (HANDLE *)GlobalAlloc (GMEM_FIXED, p*sizeof (HANDLE));
|
|
ASSERTERR (Events!=NULL);
|
|
|
|
InteractiveThreads = (HANDLE *)GlobalAlloc (GMEM_FIXED, (n+p)*sizeof (HANDLE));
|
|
ASSERTERR (InteractiveThreads!=NULL);
|
|
|
|
hDLLInstance = LoadLibrary ("rtm.dll");
|
|
ASSERTERR (hDLLInstance!=NULL);
|
|
|
|
if (m>0) {
|
|
INT m1;
|
|
WORD wVersionRequested;
|
|
WSADATA wsaData;
|
|
INT err, length;
|
|
SOCKADDR_IPX addr;
|
|
SOCKET s;
|
|
IPX_ADDRESS_DATA adptData;
|
|
BOOL flag;
|
|
|
|
wVersionRequested = MAKEWORD( 1, 1 );
|
|
err = WSAStartup( wVersionRequested, &wsaData );
|
|
ASSERT (err==NO_ERROR);
|
|
|
|
s = socket (AF_IPX, SOCK_DGRAM, NSPROTO_IPX);
|
|
ASSERTERR (s!=INVALID_SOCKET);
|
|
|
|
memset (&addr, 0, sizeof (addr));
|
|
addr.sa_family = AF_IPX;
|
|
status = bind (s, (PSOCKADDR)&addr, sizeof (addr));
|
|
ASSERTERRMSG ("Can't bind to default address.\n", status==0);
|
|
|
|
// Get number of available adapters
|
|
length = sizeof (INT);
|
|
status = getsockopt (s,
|
|
NSPROTO_IPX,
|
|
IPX_MAX_ADAPTER_NUM,
|
|
(PUCHAR)&m1,
|
|
&length);
|
|
ASSERTERRMSG ("Can't get number of adapters.", status==0);
|
|
ASSERTMSG ("No adapters available", m1>0);
|
|
if (m>m1)
|
|
m = m1;
|
|
|
|
IPXRIPThreads = (HANDLE *)GlobalAlloc (GMEM_FIXED, m*sizeof(HANDLE));
|
|
ASSERTERR (IPXRIPThreads!=NULL);
|
|
|
|
Sockets = (SOCKET *)GlobalAlloc (GMEM_FIXED, m*sizeof (SOCKET));
|
|
ASSERTERR (Sockets!=NULL);
|
|
|
|
for (i=0; i<m; i++) {
|
|
Sockets[i] = socket (AF_IPX, SOCK_DGRAM, NSPROTO_IPX);
|
|
ASSERTERR (Sockets[i]!=INVALID_SOCKET);
|
|
|
|
flag = TRUE;
|
|
status = setsockopt (Sockets[i],
|
|
SOL_SOCKET,
|
|
SO_BROADCAST,
|
|
(PCHAR)&flag,
|
|
sizeof (BOOL));
|
|
ASSERTERRMSG ("Can't set socket broadcast option.", status==0);
|
|
|
|
flag = TRUE;
|
|
status = setsockopt (Sockets[i],
|
|
NSPROTO_IPX,
|
|
IPX_RECEIVE_BROADCAST,
|
|
(PCHAR)&flag,
|
|
sizeof (BOOL));
|
|
ASSERTERRMSG ("Can't set IPX broadcast option.", status==0);
|
|
|
|
flag = TRUE;
|
|
status = setsockopt (Sockets[i],
|
|
NSPROTO_IPX,
|
|
IPX_RECVHDR,
|
|
(PCHAR)&flag,
|
|
sizeof (BOOL));
|
|
ASSERTERRMSG ("Can't set receive header option.", status==0);
|
|
|
|
length = sizeof (adptData);
|
|
adptData.adapternum = i;
|
|
status = getsockopt (s,
|
|
NSPROTO_IPX,
|
|
IPX_ADDRESS,
|
|
(PCHAR)&adptData,
|
|
&length);
|
|
ASSERTERRMSG ("Can't get adapter parameters.", status==0);
|
|
|
|
memcpy (&addr.sa_netnum, &adptData.netnum, sizeof (addr.sa_netnum));
|
|
fprintf (stderr,
|
|
"IPX RIP Listener # %d: Net=%02x%02x%02x%02x\n",
|
|
i, (UCHAR)addr.sa_netnum[0],
|
|
(UCHAR)addr.sa_netnum[1],
|
|
(UCHAR)addr.sa_netnum[2],
|
|
(UCHAR)addr.sa_netnum[3]);
|
|
memcpy (&addr.sa_nodenum, &adptData.nodenum, sizeof (addr.sa_nodenum));
|
|
fprintf (stderr,
|
|
"IPX RIP Listener # %d: Node=%02x%02x%02x%02x%02x%02x\n",
|
|
i, (UCHAR)addr.sa_nodenum[0],
|
|
(UCHAR)addr.sa_nodenum[1],
|
|
(UCHAR)addr.sa_nodenum[2],
|
|
(UCHAR)addr.sa_nodenum[3],
|
|
(UCHAR)addr.sa_nodenum[4],
|
|
(UCHAR)addr.sa_nodenum[5]);
|
|
|
|
addr.sa_family = AF_IPX;
|
|
addr.sa_socket = htons (0x452);
|
|
|
|
status = bind (Sockets[i], (PSOCKADDR)&addr, sizeof(addr));
|
|
ASSERTERRMSG ("Can't bind to adapter's address.", status==0);
|
|
|
|
IPXRIPThreads[i] = CreateThread (NULL,
|
|
0,
|
|
&IPXRIPListenThread,
|
|
(LPVOID)i,
|
|
0,
|
|
&id);
|
|
ASSERTERR (IPXRIPThreads[i]!=NULL);
|
|
}
|
|
closesocket (s);
|
|
}
|
|
|
|
for (i=0; i<n; i++) {
|
|
InteractiveThreads[i] = CreateThread (NULL,
|
|
0,
|
|
&ClientThread,
|
|
(LPVOID)i,
|
|
0,
|
|
&id);
|
|
ASSERTERR (InteractiveThreads[i]!=NULL);
|
|
}
|
|
|
|
for (i=0; i<p ; i++) {
|
|
InteractiveThreads[n+i] = CreateThread (NULL,
|
|
0,
|
|
&EnumThread,
|
|
(LPVOID)i,
|
|
0,
|
|
&id);
|
|
ASSERTERR (InteractiveThreads[n+i]!=NULL);
|
|
}
|
|
|
|
|
|
WaitForMultipleObjects (n+p, InteractiveThreads, TRUE, INFINITE);
|
|
if (m>0) {
|
|
for (i=0; i<m; i++)
|
|
closesocket (Sockets[i]);
|
|
status = WaitForMultipleObjects (m, IPXRIPThreads, TRUE, 5*1000);
|
|
if (status==WAIT_TIMEOUT) {
|
|
for (i=0; i<m; i++)
|
|
TerminateThread (IPXRIPThreads[i], 0);
|
|
}
|
|
for (i=0; i<m; i++)
|
|
CloseHandle (IPXRIPThreads[i]);
|
|
|
|
}
|
|
|
|
for (i=0; i<=n; i++)
|
|
CloseHandle (InteractiveThreads[i]);
|
|
FreeLibrary (hDLLInstance);
|
|
WSACleanup ();
|
|
}
|
|
else
|
|
fprintf (stderr,
|
|
"Usage: %s <n_of_clients> <n_of_enumerators> <max_rip_listeners>\n",
|
|
argv[0]);
|
|
|
|
RtmDeleteRouteTable (RTM_PROTOCOL_FAMILY_IP);
|
|
RtmDeleteRouteTable (RTM_PROTOCOL_FAMILY_IPX);
|
|
return 0;
|
|
}
|
|
|
|
#define idx ((LONG)param)
|
|
DWORD WINAPI
|
|
ClientThread (
|
|
LPVOID param
|
|
) {
|
|
MSG msg;
|
|
DWORD status;
|
|
HWND ClientDlg;
|
|
char buf[16];
|
|
BOOLEAN done = FALSE;
|
|
|
|
Clients[idx] = NULL;
|
|
|
|
Events[idx] = CreateEvent (NULL, FALSE, FALSE, NULL);
|
|
ASSERTERR (Events[idx]!=NULL);
|
|
|
|
// Create dialog window
|
|
ClientDlg = CreateDialogParam (hDLLInstance,
|
|
MAKEINTRESOURCE(IDD_RTM_CLIENT),
|
|
NULL,
|
|
&ClientDlgProc,
|
|
(LPARAM)idx);
|
|
ASSERTERR (ClientDlg!=NULL);
|
|
|
|
sprintf (buf, "Client # %d", idx+1);
|
|
SetWindowText (ClientDlg, buf);
|
|
|
|
while (!done) {
|
|
status = MsgWaitForMultipleObjects (
|
|
1,
|
|
&Events[idx],
|
|
FALSE,
|
|
1000,
|
|
QS_ALLINPUT
|
|
);
|
|
|
|
ASSERTERR (status!=0xFFFFFFFF);
|
|
if (status==WAIT_OBJECT_0) {
|
|
if (IsWindow (ClientDlg) && (Clients[idx]!=NULL))
|
|
EnableWindow (GetDlgItem (ClientDlg, IDR_DEQUEUE_C), TRUE);
|
|
else
|
|
ASSERTMSG ("Event signalled to dead client or closed window ", FALSE);
|
|
}
|
|
while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE)) {
|
|
if (msg.message!=WM_QUIT) {
|
|
if (!IsWindow(ClientDlg)
|
|
|| !IsDialogMessage(ClientDlg, &msg)) {
|
|
TranslateMessage (&msg);
|
|
DispatchMessage (&msg);
|
|
}
|
|
}
|
|
else
|
|
done = TRUE;
|
|
}
|
|
}
|
|
|
|
if (IsWindow (ClientDlg)) {
|
|
DestroyWindow (ClientDlg);
|
|
ClientDlg = NULL;
|
|
}
|
|
CloseHandle (Events[idx]);
|
|
|
|
return msg.wParam;
|
|
}
|
|
#undef idx
|
|
|
|
|
|
BOOL CALLBACK
|
|
ClientDlgProc (
|
|
HWND hDlg,
|
|
UINT uMsg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
) {
|
|
BOOL res = FALSE;
|
|
LONG idx;
|
|
|
|
idx = GetWindowLong (hDlg, DWL_USER)-1;
|
|
|
|
switch (uMsg) {
|
|
case WM_INITDIALOG: // Dialog is being created
|
|
idx = lParam+1;
|
|
SetWindowLong (hDlg, DWL_USER, idx);
|
|
ASSERTERR (GetLastError ()==NO_ERROR);
|
|
EnableDlgGroup (hDlg, GetDlgItem (hDlg, IDG_CLIENT_OPERATION_C), FALSE);
|
|
EnableDlgGroup (hDlg, GetDlgItem (hDlg, IDG_REQUEST_C), FALSE);
|
|
SendDlgItemMessage (hDlg,
|
|
IDC_PROTOCOL_FAMILY_C,
|
|
CB_INSERTSTRING,
|
|
RTM_PROTOCOL_FAMILY_IPX,
|
|
(LPARAM)"IPX"
|
|
);
|
|
|
|
SendDlgItemMessage (hDlg,
|
|
IDC_PROTOCOL_FAMILY_C,
|
|
CB_INSERTSTRING,
|
|
RTM_PROTOCOL_FAMILY_IP,
|
|
(LPARAM)"IP"
|
|
);
|
|
|
|
SendDlgItemMessage (hDlg,
|
|
IDC_PROTOCOL_FAMILY_C,
|
|
CB_SETCURSEL,
|
|
0,
|
|
0
|
|
);
|
|
SetDlgItemText (hDlg, IDB_REGISTER_OP_C, "Register");
|
|
|
|
res = TRUE;
|
|
break;
|
|
|
|
case WM_COMMAND: // Process child window messages only
|
|
switch (LOWORD(wParam)) {
|
|
case IDCANCEL:
|
|
PostQuitMessage (0);
|
|
res = TRUE;
|
|
break;
|
|
case IDB_REGISTER_OP_C:
|
|
if (Clients[idx]==NULL)
|
|
DoRegister (hDlg, idx);
|
|
else
|
|
DoDeregister (hDlg, idx);
|
|
res = TRUE;
|
|
break;
|
|
case IDR_ADD_C:
|
|
SetupAdd (hDlg);
|
|
res = TRUE;
|
|
break;
|
|
case IDR_DELETE_C:
|
|
SetupDelete (hDlg);
|
|
res = TRUE;
|
|
break;
|
|
case IDR_DEQUEUE_C:
|
|
if (GetDlgItemInt (hDlg, IDE_ROUTING_PROTOCOL_C,
|
|
NULL, FALSE)!=0)
|
|
SetupDequeue (hDlg);
|
|
else
|
|
SetupConvert (hDlg);
|
|
res = TRUE;
|
|
break;
|
|
case IDR_DISABLE_C:
|
|
case IDR_ENABLE_C:
|
|
SetupSetEnable (hDlg);
|
|
res = TRUE;
|
|
break;
|
|
case IDB_DO_IT_C:
|
|
DoOperation (hDlg, idx);
|
|
res = TRUE;
|
|
break;
|
|
}
|
|
break;
|
|
case WM_DESTROY:
|
|
if (Clients[idx]!=NULL) {
|
|
if (RtmDeregisterClient (Clients[idx])!=NO_ERROR)
|
|
MessageBox (hDlg, "Deregister failed!", NULL, MB_OK|MB_ICONSTOP);
|
|
|
|
Clients[idx] = NULL;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
|
|
VOID
|
|
DoRegister (
|
|
HWND hDlg,
|
|
LONG idx
|
|
) {
|
|
DWORD ProtocolFamily;
|
|
DWORD RoutingProtocol;
|
|
|
|
ProtocolFamily = SendDlgItemMessage (hDlg, IDC_PROTOCOL_FAMILY_C,
|
|
CB_GETCURSEL, 0, 0);
|
|
RoutingProtocol = GetDlgItemInt (hDlg, IDE_ROUTING_PROTOCOL_C, NULL, FALSE);
|
|
SetDlgItemInt (hDlg, IDE_ROUTING_PROTOCOL_C, RoutingProtocol, FALSE);
|
|
Clients[idx] = RtmRegisterClient (ProtocolFamily,
|
|
RoutingProtocol,
|
|
(RoutingProtocol!=0)
|
|
? Events[idx]
|
|
: NULL,
|
|
(RoutingProtocol!=0)
|
|
? 0
|
|
: RTM_PROTOCOL_SINGLE_ROUTE);
|
|
if (Clients[idx]!=NULL) {
|
|
RECT rectScr, rectDlg;
|
|
|
|
EnableWindow (GetDlgItem (hDlg, IDC_PROTOCOL_FAMILY_C), FALSE);
|
|
EnableWindow (GetDlgItem (hDlg, IDE_ROUTING_PROTOCOL_C), FALSE);
|
|
SetDlgItemText (hDlg, IDB_REGISTER_OP_C, "Deregister");
|
|
EnableDlgGroup (hDlg, GetDlgItem (hDlg, IDG_REQUEST_C), TRUE);
|
|
if (RoutingProtocol!=0) {
|
|
SetDlgItemText (hDlg, IDR_DEQUEUE_C, "Dequeue");
|
|
EnableWindow (GetDlgItem (hDlg, IDR_DEQUEUE_C), FALSE);
|
|
}
|
|
else
|
|
SetDlgItemText (hDlg, IDR_DEQUEUE_C, "Convert");
|
|
|
|
GetWindowRect (GetDlgItem (hDlg, IDE_NET_NUMBER_C), &rectScr);
|
|
MapWindowPoints (HWND_DESKTOP, hDlg, (LPPOINT)&rectScr, 2);
|
|
rectDlg.left = rectDlg.top = rectDlg.bottom = 0;
|
|
switch (ProtocolFamily) {
|
|
case RTM_PROTOCOL_FAMILY_IPX:
|
|
rectDlg.right = 8*4+5;
|
|
break;
|
|
case RTM_PROTOCOL_FAMILY_IP:
|
|
rectDlg.right = 16*4+5;
|
|
break;
|
|
}
|
|
MapDialogRect (hDlg, &rectDlg);
|
|
MoveWindow (GetDlgItem (hDlg, IDE_NET_NUMBER_C),
|
|
rectScr.left,
|
|
rectScr.top,
|
|
rectDlg.right,
|
|
rectScr.bottom-rectScr.top,
|
|
TRUE);
|
|
|
|
GetWindowRect (GetDlgItem (hDlg, IDE_NEXT_HOP_C), &rectScr);
|
|
MapWindowPoints (HWND_DESKTOP, hDlg, (LPPOINT)&rectScr, 2);
|
|
rectDlg.left = rectDlg.top = rectDlg.bottom = 0;
|
|
switch (ProtocolFamily) {
|
|
case RTM_PROTOCOL_FAMILY_IPX:
|
|
rectDlg.right = 12*4+5;
|
|
break;
|
|
case RTM_PROTOCOL_FAMILY_IP:
|
|
rectDlg.right = 16*4+5;
|
|
break;
|
|
}
|
|
MapDialogRect (hDlg, &rectDlg);
|
|
MoveWindow (GetDlgItem (hDlg, IDE_NEXT_HOP_C),
|
|
rectScr.left,
|
|
rectScr.top,
|
|
rectDlg.right,
|
|
rectScr.bottom-rectScr.top,
|
|
TRUE);
|
|
SendDlgItemMessage (hDlg, IDR_ADD_C, BM_SETCHECK, (WPARAM)1, 0);
|
|
SetupAdd (hDlg);
|
|
}
|
|
else
|
|
MessageBox (hDlg, "Registration failed!", NULL, MB_OK|MB_ICONSTOP);
|
|
}
|
|
|
|
|
|
VOID
|
|
DoDeregister (
|
|
HWND hDlg,
|
|
LONG idx
|
|
) {
|
|
|
|
if (RtmDeregisterClient (Clients[idx])!=NO_ERROR)
|
|
MessageBox (hDlg, "Deregister failed!", NULL, MB_OK|MB_ICONSTOP);
|
|
|
|
Clients[idx] = NULL;
|
|
ResetEvent (Events[idx]);
|
|
|
|
EnableWindow (GetDlgItem (hDlg, IDC_PROTOCOL_FAMILY_C), TRUE);
|
|
EnableWindow (GetDlgItem (hDlg, IDE_ROUTING_PROTOCOL_C), TRUE);
|
|
SetDlgItemText (hDlg, IDB_REGISTER_OP_C, "Register");
|
|
EnableDlgGroup (hDlg, GetDlgItem (hDlg, IDG_CLIENT_OPERATION_C), FALSE);
|
|
EnableDlgGroup (hDlg, GetDlgItem (hDlg, IDG_REQUEST_C), FALSE);
|
|
}
|
|
|
|
VOID
|
|
SetupAdd (
|
|
HWND hDlg
|
|
) {
|
|
EnableDlgGroup (hDlg, GetDlgItem (hDlg, IDG_CLIENT_OPERATION_C), TRUE);
|
|
EnableWindow (GetDlgItem (hDlg, IDB_DO_IT_C), TRUE);
|
|
}
|
|
|
|
VOID
|
|
SetupDelete (
|
|
HWND hDlg
|
|
) {
|
|
EnableDlgGroup (hDlg, GetDlgItem (hDlg, IDG_CLIENT_OPERATION_C), TRUE);
|
|
EnableWindow (GetDlgItem (hDlg, IDE_METRIC_C), FALSE);
|
|
EnableWindow (GetDlgItem (hDlg, IDE_TIMEOUT_C), FALSE);
|
|
EnableWindow (GetDlgItem (hDlg, IDB_DO_IT_C), TRUE);
|
|
}
|
|
|
|
VOID
|
|
SetupDequeue (
|
|
HWND hDlg
|
|
) {
|
|
EnableDlgGroup (hDlg, GetDlgItem (hDlg, IDG_CLIENT_OPERATION_C), TRUE);
|
|
EnableWindow (GetDlgItem (hDlg, IDE_NET_NUMBER_C), FALSE);
|
|
EnableWindow (GetDlgItem (hDlg, IDE_NEXT_HOP_C), FALSE);
|
|
EnableWindow (GetDlgItem (hDlg, IDE_INTERFACE_C), FALSE);
|
|
EnableWindow (GetDlgItem (hDlg, IDE_METRIC_C), FALSE);
|
|
EnableWindow (GetDlgItem (hDlg, IDE_TIMEOUT_C), FALSE);
|
|
EnableWindow (GetDlgItem (hDlg, IDB_DO_IT_C), TRUE);
|
|
}
|
|
|
|
VOID
|
|
SetupSetEnable (
|
|
HWND hDlg
|
|
) {
|
|
EnableDlgGroup (hDlg, GetDlgItem (hDlg, IDG_CLIENT_OPERATION_C), TRUE);
|
|
EnableWindow (GetDlgItem (hDlg, IDE_NET_NUMBER_C), FALSE);
|
|
EnableWindow (GetDlgItem (hDlg, IDE_NEXT_HOP_C), FALSE);
|
|
EnableWindow (GetDlgItem (hDlg, IDE_INTERFACE_C), TRUE);
|
|
EnableWindow (GetDlgItem (hDlg, IDE_METRIC_C), FALSE);
|
|
EnableWindow (GetDlgItem (hDlg, IDE_TIMEOUT_C), FALSE);
|
|
EnableWindow (GetDlgItem (hDlg, IDB_DO_IT_C), TRUE);
|
|
}
|
|
|
|
VOID
|
|
SetupConvert (
|
|
HWND hDlg
|
|
) {
|
|
EnableDlgGroup (hDlg, GetDlgItem (hDlg, IDG_CLIENT_OPERATION_C), TRUE);
|
|
EnableWindow (GetDlgItem (hDlg, IDE_NET_NUMBER_C), FALSE);
|
|
EnableWindow (GetDlgItem (hDlg, IDE_NEXT_HOP_C), FALSE);
|
|
EnableWindow (GetDlgItem (hDlg, IDE_INTERFACE_C), TRUE);
|
|
EnableWindow (GetDlgItem (hDlg, IDE_METRIC_C), FALSE);
|
|
EnableWindow (GetDlgItem (hDlg, IDE_TIMEOUT_C), FALSE);
|
|
EnableWindow (GetDlgItem (hDlg, IDB_DO_IT_C), TRUE);
|
|
}
|
|
|
|
VOID
|
|
DoOperation (
|
|
HWND hDlg,
|
|
LONG idx
|
|
) {
|
|
char buf[32];
|
|
LONG TimeToLive;
|
|
RTM_ROUTE Route;
|
|
DWORD status;
|
|
DWORD ProtocolFamily;
|
|
INT i,n,val;
|
|
DWORD Flags;
|
|
char *p;
|
|
|
|
memset (&Route, 0 , sizeof (RTM_ROUTE));
|
|
ProtocolFamily = SendDlgItemMessage (hDlg, IDC_PROTOCOL_FAMILY_C,
|
|
CB_GETCURSEL, 0, 0);
|
|
|
|
if (IsDlgButtonChecked (hDlg, IDR_ADD_C)
|
|
|| IsDlgButtonChecked (hDlg, IDR_DELETE_C)) {
|
|
Route.XX_PROTOCOL
|
|
= GetDlgItemInt (hDlg, IDE_ROUTING_PROTOCOL_C, NULL, FALSE);
|
|
|
|
|
|
GetDlgItemText (hDlg, IDE_NET_NUMBER_C, buf, sizeof (buf)-1);
|
|
p = buf;
|
|
switch (ProtocolFamily) {
|
|
case RTM_PROTOCOL_FAMILY_IPX:
|
|
if (sscanf (p, "%8X%n", &val, &n)==1)
|
|
Route.IPX_NET_NUM = val;
|
|
else
|
|
Route.IPX_NET_NUM = 0;
|
|
p += n;
|
|
break;
|
|
case RTM_PROTOCOL_FAMILY_IP:
|
|
if (sscanf (p, "%8X%n", &val, &n)==1)
|
|
Route.IP_NET_NUM = val;
|
|
else
|
|
Route.IP_NET_NUM = 0;
|
|
p += n;
|
|
if (sscanf (p, "%8X%n", &val, &n)==1)
|
|
Route.IP_NET_MSK = val;
|
|
else
|
|
Route.IP_NET_MSK = 0;
|
|
p += n;
|
|
break;
|
|
}
|
|
|
|
GetDlgItemText (hDlg, IDE_NEXT_HOP_C, buf, sizeof (buf)-1);
|
|
p = buf;
|
|
switch (ProtocolFamily) {
|
|
case RTM_PROTOCOL_FAMILY_IPX:
|
|
for (i=0; i<sizeof(Route.IPX_NEXT_HOP_MAC); i++, p+=n) {
|
|
if (sscanf (p, "%2X%n", &val, &n)==1)
|
|
Route.IPX_NEXT_HOP_MAC[i] = (BYTE)val;
|
|
else
|
|
Route.IPX_NEXT_HOP_MAC[i] = 0;
|
|
}
|
|
break;
|
|
case RTM_PROTOCOL_FAMILY_IP:
|
|
if (sscanf (p, "%8X%n", &val, &n)==1)
|
|
Route.IP_NEXT_HOP_NUM = val;
|
|
else
|
|
Route.IP_NEXT_HOP_NUM = 0;
|
|
p += n;
|
|
if (sscanf (p, "%8X%n", &val, &n)==1)
|
|
Route.IP_NEXT_HOP_MSK = val;
|
|
else
|
|
Route.IP_NEXT_HOP_MSK = 0;
|
|
p += n;
|
|
break;
|
|
}
|
|
|
|
Route.XX_INTERFACE
|
|
= GetDlgItemInt (hDlg, IDE_INTERFACE_C, NULL, FALSE);
|
|
|
|
if (IsDlgButtonChecked (hDlg, IDR_ADD_C)) {
|
|
switch (ProtocolFamily) {
|
|
case RTM_PROTOCOL_FAMILY_IPX:
|
|
Route.IPX_METRIC = (USHORT)GetDlgItemInt
|
|
(hDlg, IDE_METRIC_C, NULL, FALSE);
|
|
break;
|
|
case RTM_PROTOCOL_FAMILY_IP:
|
|
Route.IP_METRIC = (USHORT)GetDlgItemInt
|
|
(hDlg, IDE_METRIC_C, NULL, FALSE);
|
|
break;
|
|
}
|
|
|
|
|
|
TimeToLive = GetDlgItemInt (hDlg, IDE_TIMEOUT_C, NULL, FALSE);
|
|
SetDlgItemInt (hDlg, IDE_TIMEOUT_C, TimeToLive, FALSE);
|
|
GetDlgItemText (hDlg, IDR_ADD_C, buf, sizeof (buf)-1);
|
|
status = RtmAddRoute (Clients[idx], &Route,
|
|
TimeToLive,
|
|
&Flags, NULL, NULL);
|
|
|
|
}
|
|
else {
|
|
status = RtmDeleteRoute (Clients[idx], &Route,
|
|
&Flags, NULL);
|
|
SetDlgItemText (hDlg, IDE_TIMEOUT_C, "");
|
|
}
|
|
if (status!=NO_ERROR) {
|
|
sprintf (buf, "Rtm returned error: %ld", status);
|
|
MessageBox (hDlg, buf, "Error", MB_OK|MB_ICONEXCLAMATION);
|
|
}
|
|
SetDlgItemText (hDlg, IDL_ROUTING_PROTOCOL_C, "");
|
|
}
|
|
else if (IsDlgButtonChecked (hDlg, IDR_DEQUEUE_C)) {
|
|
RTM_ROUTE Route1;
|
|
Route.XX_PROTOCOL
|
|
= GetDlgItemInt (hDlg, IDE_ROUTING_PROTOCOL_C, NULL, FALSE);
|
|
|
|
if (Route.XX_PROTOCOL!=0) {
|
|
status = RtmDequeueRouteChangeMessage (Clients[idx],
|
|
&Flags,
|
|
&Route,
|
|
&Route1);
|
|
if (status==NO_ERROR) {
|
|
SendDlgItemMessage (hDlg, IDR_DEQUEUE_C, BM_SETCHECK, (WPARAM)0, 0);
|
|
EnableWindow (GetDlgItem (hDlg, IDR_DEQUEUE_C), FALSE);
|
|
EnableWindow (GetDlgItem (hDlg, IDB_DO_IT_C), FALSE);
|
|
}
|
|
else if (status!=ERROR_MORE_MESSAGES) {
|
|
sprintf (buf, "Rtm returned error: %ld", status);
|
|
MessageBox (hDlg, buf, "Error", MB_OK|MB_ICONEXCLAMATION);
|
|
}
|
|
if (!(Flags & RTM_CURRENT_BEST_ROUTE))
|
|
memcpy (&Route, &Route1, sizeof (Route));
|
|
SetDlgItemInt (hDlg, IDL_ROUTING_PROTOCOL_C, (UINT)Route.XX_PROTOCOL, FALSE);
|
|
SetDlgItemText (hDlg, IDE_TIMEOUT_C, "");
|
|
}
|
|
else {
|
|
Route.XX_INTERFACE
|
|
= GetDlgItemInt (hDlg, IDE_INTERFACE_C, NULL, FALSE);
|
|
status = RtmBlockConvertRoutesToStatic (
|
|
Clients[idx],
|
|
RTM_ONLY_THIS_INTERFACE,
|
|
&Route);
|
|
goto OpDone;
|
|
}
|
|
}
|
|
else if (IsDlgButtonChecked (hDlg, IDR_DISABLE_C)
|
|
|| IsDlgButtonChecked (hDlg, IDR_ENABLE_C)) {
|
|
Route.XX_PROTOCOL
|
|
= GetDlgItemInt (hDlg, IDE_ROUTING_PROTOCOL_C, NULL, FALSE);
|
|
Route.XX_INTERFACE
|
|
= GetDlgItemInt (hDlg, IDE_INTERFACE_C, NULL, FALSE);
|
|
status = RtmBlockSetRouteEnable (Clients[idx],
|
|
RTM_ONLY_THIS_INTERFACE,
|
|
&Route,
|
|
IsDlgButtonChecked (hDlg, IDR_ENABLE_C));
|
|
goto OpDone;
|
|
}
|
|
|
|
SetDlgItemInt (hDlg, IDL_MESSAGE_FLAGS_C, (UINT)Flags, FALSE);
|
|
SetDlgItemInt (hDlg, IDE_INTERFACE_C, (UINT)Route.XX_INTERFACE, FALSE);
|
|
|
|
switch (ProtocolFamily) {
|
|
case RTM_PROTOCOL_FAMILY_IPX:
|
|
sprintf (buf,
|
|
"%08X",
|
|
Route.IPX_NET_NUM);
|
|
SetDlgItemInt (hDlg, IDE_METRIC_C, (UINT)Route.IPX_METRIC, FALSE);
|
|
break;
|
|
case RTM_PROTOCOL_FAMILY_IP:
|
|
sprintf (buf,
|
|
"%08X%08X",
|
|
Route.IP_NET_NUM,
|
|
Route.IP_NET_MSK);
|
|
SetDlgItemInt (hDlg, IDE_METRIC_C, (UINT)Route.IP_METRIC, FALSE);
|
|
break;
|
|
}
|
|
SetDlgItemText (hDlg, IDE_NET_NUMBER_C, buf);
|
|
|
|
switch (ProtocolFamily) {
|
|
case RTM_PROTOCOL_FAMILY_IPX:
|
|
sprintf (buf,
|
|
"%02X%02X%02X%02X%02X%02X",
|
|
Route.IPX_NEXT_HOP_MAC[0],
|
|
Route.IPX_NEXT_HOP_MAC[1],
|
|
Route.IPX_NEXT_HOP_MAC[2],
|
|
Route.IPX_NEXT_HOP_MAC[3],
|
|
Route.IPX_NEXT_HOP_MAC[4],
|
|
Route.IPX_NEXT_HOP_MAC[5]);
|
|
break;
|
|
case RTM_PROTOCOL_FAMILY_IP:
|
|
sprintf (buf,
|
|
"%08X%08X",
|
|
Route.IP_NEXT_HOP_NUM,
|
|
Route.IP_NEXT_HOP_MSK);
|
|
break;
|
|
}
|
|
|
|
SetDlgItemText (hDlg, IDE_NEXT_HOP_C, buf);
|
|
OpDone:
|
|
;
|
|
}
|
|
|
|
|
|
#define pParam ((PENABLE_DLG_GROUP_PARAM)lParam)
|
|
BOOL CALLBACK
|
|
DoEnable (
|
|
HWND hwnd, // handle of child window
|
|
LPARAM lParam // application-defined value
|
|
) {
|
|
if (!pParam->foundFirst) {
|
|
if (pParam->hCtlFirst != hwnd)
|
|
return TRUE;
|
|
else
|
|
pParam->foundFirst = TRUE;
|
|
}
|
|
else if (GetWindowLong (hwnd, GWL_STYLE) & WS_GROUP)
|
|
return FALSE;
|
|
|
|
EnableWindow (hwnd, pParam->enableFlag);
|
|
return TRUE;
|
|
}
|
|
#undef pParam
|
|
|
|
|
|
VOID
|
|
EnableDlgGroup (
|
|
HWND hDlg,
|
|
HWND hCtlFirst,
|
|
BOOLEAN enable
|
|
) {
|
|
ENABLE_DLG_GROUP_PARAM param;
|
|
|
|
param.hCtlFirst = hCtlFirst;
|
|
param.foundFirst = FALSE;
|
|
param.enableFlag = enable;
|
|
|
|
EnumChildWindows (hDlg, DoEnable, (LPARAM)¶m);
|
|
}
|
|
|
|
|
|
|
|
|
|
typedef USHORT IPX_SOCKETNUM, *PIPX_SOCKETNUM;
|
|
typedef UCHAR IPX_NETNUM[4], *PIPX_NETNUM;
|
|
typedef UCHAR IPX_NODENUM[6], *PIPX_NODENUM;
|
|
|
|
typedef struct _IPX_ADDRESS_BLOCK {
|
|
IPX_NETNUM net;
|
|
IPX_NODENUM node;
|
|
IPX_SOCKETNUM socket;
|
|
} IPX_ADDRESS_BLOCK, *PIPX_ADDRESS_BLOCK;
|
|
|
|
// IPX Net Number copy macro
|
|
#define IPX_NETNUM_CPY(dst,src) memcpy(dst,src,sizeof(IPX_NETNUM))
|
|
// IPX Net Number comparison
|
|
#define IPX_NETNUM_CMP(addr1,addr2) memcmp(net1,net2,sizeof(IPX_NETNUM))
|
|
|
|
// IPX Node Number copy macro
|
|
#define IPX_NODENUM_CPY(dst,src) memcpy(dst,src,sizeof(IPX_NODENUM))
|
|
// IPX Node Number comparison
|
|
#define IPX_NODENUM_CMP(node1,node2) memcmp(node1,node2,sizeof(IPX_NODENUM))
|
|
|
|
// IPX Address copy macro
|
|
#define IPX_ADDR_CPY(dst,src) memcpy(dst,src,sizeof(IPX_ADDRESS_BLOCK))
|
|
// IPX Address comparison
|
|
#define IPX_ADDR_CMP(addr1,addr2) memcmp(addr1,addr2,sizeof(IPX_ADDRESS_BLOCK))
|
|
|
|
// Header of IPX packet
|
|
typedef struct _IPX_HEADER {
|
|
USHORT checksum;
|
|
USHORT length;
|
|
UCHAR transportctl;
|
|
UCHAR pkttype;
|
|
IPX_ADDRESS_BLOCK dst;
|
|
IPX_ADDRESS_BLOCK src;
|
|
} IPX_HEADER, *PIPX_HEADER;
|
|
|
|
typedef struct _IPX_SAP_PACKET {
|
|
IPX_HEADER hdr;
|
|
USHORT operation;
|
|
struct {
|
|
USHORT type;
|
|
UCHAR name[48];
|
|
IPX_ADDRESS_BLOCK addr;
|
|
USHORT hops;
|
|
} entry[7];
|
|
} IPX_SAP_PACKET, *PIPX_SAP_PACKET;
|
|
|
|
DWORD WINAPI
|
|
IPXRIPListenThread (
|
|
LPVOID param
|
|
) {
|
|
#define adptIdx ((INT)param)
|
|
INT status;
|
|
IPX_SAP_PACKET packet;
|
|
HANDLE hClient;
|
|
RTM_IPX_ROUTE Route;
|
|
DWORD flags;
|
|
IPX_NETNUM_DATA netData;
|
|
INT length;
|
|
|
|
|
|
fprintf (stderr, "IXP RIP Listener # %d: Started.\n", adptIdx);
|
|
|
|
hClient = RtmRegisterClient (RTM_PROTOCOL_FAMILY_IPX, 1000+adptIdx, NULL, 0);
|
|
ASSERT (hClient!=NULL);
|
|
|
|
while (((status=recvfrom (Sockets[adptIdx],
|
|
(PCHAR)&packet,
|
|
sizeof (packet),
|
|
0, NULL, NULL)) != 0)
|
|
&& (status!=SOCKET_ERROR)) {
|
|
|
|
// fprintf (stderr, "IXP RIP Listener # %d: Packet received.\n", adptIdx);
|
|
if (status>=sizeof (IPX_HEADER)) {
|
|
packet.hdr.length = (USHORT)ntohs (packet.hdr.length);
|
|
if (packet.hdr.length>status)
|
|
packet.hdr.length = (USHORT)status;
|
|
if (packet.hdr.length>=FIELD_OFFSET (IPX_SAP_PACKET, entry[0])) {
|
|
if ((packet.hdr.pkttype==4)
|
|
&& (ntohs(packet.operation)==2)) {
|
|
if (FIELD_OFFSET(IPX_SAP_PACKET,entry[1])
|
|
<= packet.hdr.length) {
|
|
IPX_NETNUM_CPY (&netData.netnum, &packet.entry[0].addr.net);
|
|
length = sizeof (netData);
|
|
status = getsockopt (Sockets[adptIdx],
|
|
NSPROTO_IPX,
|
|
IPX_GETNETINFO,
|
|
(PCHAR)&netData,
|
|
&length);
|
|
if (status==0) {
|
|
Route.RR_InterfaceID = (1000+adptIdx);
|
|
Route.RR_RoutingProtocol = 0;
|
|
Route.RR_FamilySpecificData.FSD_Ticks =
|
|
(USHORT)netData.netdelay;
|
|
RtlRetrieveUlong (&Route.RR_Network.N_NetNumber,
|
|
netData.netnum);
|
|
Route.RR_Network.N_NetNumber =
|
|
ntohl (Route.RR_Network.N_NetNumber);
|
|
IPX_NODENUM_CPY (&Route.RR_NextHopAddress.NHA_Mac,
|
|
&netData.router);
|
|
Route.RR_FamilySpecificData.FSD_HopCount = netData.hopcount;
|
|
if (Route.RR_FamilySpecificData.FSD_HopCount<16)
|
|
status = RtmAddRoute (hClient, &Route, 200, &flags, NULL, NULL);
|
|
else
|
|
status = RtmDeleteRoute (hClient, &Route, &flags, NULL);
|
|
if (status!=0) {
|
|
fprintf (stderr,
|
|
"IPX RIP Listener # %d: %s failed with status %d\n",
|
|
adptIdx,
|
|
Route.RR_FamilySpecificData.FSD_HopCount<16 ? "AddRoute" : "DeleteRoute",
|
|
status);
|
|
}
|
|
}
|
|
else
|
|
fprintf (stderr,
|
|
"IPX RIP Listener # %d:"
|
|
" Can't get info about net # %02x%02x%02x%02x\n",
|
|
adptIdx,
|
|
netData.netnum[0],
|
|
netData.netnum[1],
|
|
netData.netnum[2],
|
|
netData.netnum[3]);
|
|
|
|
}
|
|
else
|
|
fprintf (stderr,
|
|
"IPX RIP Listener # %d:"
|
|
" Invalid packet length %d.\n",
|
|
adptIdx,
|
|
packet.hdr.length);
|
|
|
|
}
|
|
// else
|
|
// fprintf (stderr,
|
|
// "IPX RIP Listener # %d:"
|
|
// " Packet type %d, operation %d ignored.\n",
|
|
// adptIdx,
|
|
// packet.hdr.pkttype,
|
|
// ntohs (packet.operation));
|
|
}
|
|
else
|
|
fprintf (stderr, "IPX RIP Listener # %d: Short packet: %d\n",
|
|
adptIdx,
|
|
packet.hdr.length);
|
|
}
|
|
else
|
|
fprintf (stderr, "IPX RIP Listener # %d: Invalid packet: %d\n",
|
|
adptIdx,
|
|
status);
|
|
// Sleep (5*1000);
|
|
}
|
|
|
|
fprintf (stderr,
|
|
"IPX RIP Listener # %d: Terminating loop. Status: %d, err: %d\n",
|
|
adptIdx, status, GetLastError ());
|
|
|
|
if (RtmDeregisterClient (hClient)!=NO_ERROR)
|
|
fprintf (stderr, "Deregister client failed.\n");
|
|
|
|
fprintf (stderr, "IXP RIP Listener # %d exited.\n", adptIdx);
|
|
|
|
return 0;
|
|
#undef adptIdx
|
|
}
|
|
|
|
|
|
#define idx ((LONG)param)
|
|
DWORD WINAPI
|
|
EnumThread (
|
|
LPVOID param
|
|
) {
|
|
MSG msg;
|
|
HWND EnumDlg;
|
|
char buf[16];
|
|
|
|
Enums[idx] = NULL;
|
|
|
|
// Create dialog window
|
|
EnumDlg = CreateDialogParam (hDLLInstance,
|
|
MAKEINTRESOURCE(IDD_ENUMERATION),
|
|
NULL,
|
|
&EnumDlgProc,
|
|
(LPARAM)idx);
|
|
ASSERTERR (EnumDlg!=NULL);
|
|
|
|
sprintf (buf, "Enumerator # %d", idx+1);
|
|
SetWindowText (EnumDlg, buf);
|
|
|
|
while (GetMessage (&msg, NULL, 0, 0)) {
|
|
if (!IsWindow(EnumDlg)
|
|
|| !IsDialogMessage(EnumDlg, &msg)) {
|
|
TranslateMessage (&msg);
|
|
DispatchMessage (&msg);
|
|
}
|
|
}
|
|
|
|
if (IsWindow (EnumDlg)) {
|
|
DestroyWindow (EnumDlg);
|
|
EnumDlg = NULL;
|
|
}
|
|
|
|
if (Enums[idx]!=NULL) {
|
|
if (Enums[idx]!=INVALID_HANDLE_VALUE) {
|
|
if (RtmCloseEnumerationHandle (Enums[idx])!=NO_ERROR)
|
|
MessageBox (NULL, "Close handle failed!", NULL, MB_OK|MB_ICONSTOP);
|
|
}
|
|
Enums[idx] = NULL;
|
|
}
|
|
|
|
return msg.wParam;
|
|
}
|
|
#undef idx
|
|
|
|
BOOL CALLBACK
|
|
EnumDlgProc (
|
|
HWND hDlg,
|
|
UINT uMsg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
) {
|
|
BOOL res = FALSE;
|
|
LONG idx;
|
|
RTM_ROUTE Route;
|
|
DWORD ProtocolFamily;
|
|
DWORD flags;
|
|
DWORD status;
|
|
RECT rectDlg, rectScr;
|
|
|
|
idx = GetWindowLong (hDlg, DWL_USER)-1;
|
|
|
|
switch (uMsg) {
|
|
case WM_INITDIALOG: // Dialog is being created
|
|
idx = lParam+1;
|
|
SetWindowLong (hDlg, DWL_USER, idx);
|
|
ASSERTERR (GetLastError ()==NO_ERROR);
|
|
EnableDlgGroup (hDlg, GetDlgItem (hDlg, IDG_CRITERIA_E), TRUE);
|
|
EnableDlgGroup (hDlg, GetDlgItem (hDlg, IDG_BUTTONS_E), TRUE);
|
|
EnableWindow (GetDlgItem (hDlg, IDB_GETNEXT_E), FALSE);
|
|
SendDlgItemMessage (hDlg,
|
|
IDC_PROTOCOL_FAMILY_E,
|
|
CB_INSERTSTRING,
|
|
RTM_PROTOCOL_FAMILY_IPX,
|
|
(LPARAM)"IPX"
|
|
);
|
|
|
|
SendDlgItemMessage (hDlg,
|
|
IDC_PROTOCOL_FAMILY_E,
|
|
CB_INSERTSTRING,
|
|
RTM_PROTOCOL_FAMILY_IP,
|
|
(LPARAM)"IP"
|
|
);
|
|
|
|
SendDlgItemMessage (hDlg,
|
|
IDC_PROTOCOL_FAMILY_E,
|
|
CB_SETCURSEL,
|
|
0,
|
|
0
|
|
);
|
|
GetWindowRect (GetDlgItem (hDlg, IDE_NETWORK_E), &rectScr);
|
|
MapWindowPoints (HWND_DESKTOP, hDlg, (LPPOINT)&rectScr, 2);
|
|
rectDlg.left = rectDlg.top = rectDlg.bottom = 0;
|
|
rectDlg.right = 8*4+5;
|
|
MapDialogRect (hDlg, &rectDlg);
|
|
EnableWindow (GetDlgItem (hDlg, IDE_NETWORK_E), TRUE);
|
|
MoveWindow (GetDlgItem (hDlg, IDE_NETWORK_E),
|
|
rectScr.left,
|
|
rectScr.top,
|
|
rectDlg.right,
|
|
rectScr.bottom-rectScr.top,
|
|
TRUE);
|
|
|
|
EnableWindow (GetDlgItem (hDlg, IDE_INTERFACE_E),
|
|
IsDlgButtonChecked (hDlg, IDC_INTERFACE_E));
|
|
EnableWindow (GetDlgItem (hDlg, IDE_PROTOCOL_E),
|
|
IsDlgButtonChecked (hDlg, IDC_PROTOCOL_E));
|
|
EnableWindow (GetDlgItem (hDlg, IDE_NETWORK_E),
|
|
IsDlgButtonChecked (hDlg, IDC_NETWORK_E));
|
|
|
|
EnableWindow (GetDlgItem (hDlg, IDB_GETBEST_E),
|
|
IsDlgButtonChecked (hDlg, IDC_NETWORK_E));
|
|
|
|
SetDlgItemText (hDlg, IDB_CREATEDELETE_E, "Create Handle");
|
|
SetDlgItemText (hDlg, IDB_GETFIRST_E, "Get First");
|
|
res = TRUE;
|
|
break;
|
|
|
|
case WM_COMMAND: // Process child window messages only
|
|
switch (LOWORD(wParam)) {
|
|
case IDCANCEL:
|
|
PostQuitMessage (0);
|
|
res = TRUE;
|
|
break;
|
|
case IDC_PROTOCOL_FAMILY_E:
|
|
if (HIWORD(wParam)==CBN_SELENDOK) {
|
|
ProtocolFamily = SendMessage (
|
|
(HWND)lParam,
|
|
CB_GETCURSEL,
|
|
0, 0);
|
|
GetWindowRect (GetDlgItem (hDlg, IDE_NETWORK_E), &rectScr);
|
|
MapWindowPoints (HWND_DESKTOP, hDlg, (LPPOINT)&rectScr, 2);
|
|
rectDlg.left = rectDlg.top = rectDlg.bottom = 0;
|
|
switch (ProtocolFamily) {
|
|
case RTM_PROTOCOL_FAMILY_IPX:
|
|
rectDlg.right = 8*4+5;
|
|
break;
|
|
case RTM_PROTOCOL_FAMILY_IP:
|
|
rectDlg.right = 16*4+5;
|
|
break;
|
|
}
|
|
MapDialogRect (hDlg, &rectDlg);
|
|
EnableWindow (GetDlgItem (hDlg, IDE_NETWORK_E), TRUE);
|
|
MoveWindow (GetDlgItem (hDlg, IDE_NETWORK_E),
|
|
rectScr.left,
|
|
rectScr.top,
|
|
rectDlg.right,
|
|
rectScr.bottom-rectScr.top,
|
|
TRUE);
|
|
EnableWindow (GetDlgItem (hDlg, IDE_NETWORK_E),
|
|
IsDlgButtonChecked (hDlg, IDC_NETWORK_E));
|
|
}
|
|
break;
|
|
|
|
case IDC_NETWORK_E:
|
|
if (HIWORD(wParam)==BN_CLICKED)
|
|
EnableWindow (GetDlgItem (hDlg, IDB_GETBEST_E),
|
|
IsDlgButtonChecked (hDlg, LOWORD(wParam)));
|
|
break;
|
|
case IDC_INTERFACE_E:
|
|
case IDC_PROTOCOL_E:
|
|
if (HIWORD(wParam)==BN_CLICKED)
|
|
EnableWindow (GetDlgItem (hDlg, LOWORD(wParam)+1),
|
|
IsDlgButtonChecked (hDlg, LOWORD(wParam)));
|
|
break;
|
|
|
|
case IDB_CREATEDELETE_E:
|
|
if (Enums[idx]==NULL) {
|
|
GetCriteria (hDlg, &ProtocolFamily, &flags, &Route);
|
|
Enums[idx] = RtmCreateEnumerationHandle (
|
|
ProtocolFamily,
|
|
flags,
|
|
&Route);
|
|
if (Enums[idx]!=NULL) {
|
|
EnableDlgGroup (hDlg,
|
|
GetDlgItem (hDlg, IDG_CRITERIA_E), FALSE);
|
|
EnableWindow (GetDlgItem (hDlg, IDB_GETFIRST_E),
|
|
FALSE);
|
|
SetWindowText ((HWND)lParam, "Close Handle");
|
|
EnableWindow (GetDlgItem (hDlg, IDB_GETNEXT_E),
|
|
TRUE);
|
|
}
|
|
else
|
|
MessageBox (hDlg, "Create Handle failed!",
|
|
NULL, MB_OK|MB_ICONSTOP);
|
|
}
|
|
else {
|
|
if (RtmCloseEnumerationHandle (Enums[idx])!=NO_ERROR)
|
|
MessageBox (hDlg, "Close handle failed!",
|
|
NULL, MB_OK|MB_ICONSTOP);
|
|
Enums[idx] = NULL;
|
|
EnableWindow (GetDlgItem (hDlg, IDB_GETNEXT_E), FALSE);
|
|
SetWindowText ((HWND)lParam, "Create Handle");
|
|
EnableWindow (GetDlgItem (hDlg, IDB_GETFIRST_E), TRUE);
|
|
EnableDlgGroup (hDlg,
|
|
GetDlgItem (hDlg, IDG_CRITERIA_E), TRUE);
|
|
}
|
|
res = TRUE;
|
|
break;
|
|
case IDB_GETFIRST_E:
|
|
if (Enums[idx]==NULL) {
|
|
GetCriteria (hDlg, &ProtocolFamily, &flags, &Route);
|
|
status = RtmGetFirstRoute (
|
|
ProtocolFamily,
|
|
flags,
|
|
&Route);
|
|
if (status==NO_ERROR) {
|
|
DisplayRoute (hDlg, ProtocolFamily, &Route);
|
|
Enums[idx] = INVALID_HANDLE_VALUE;
|
|
EnableWindow (GetDlgItem (hDlg, IDB_GETBEST_E), FALSE);
|
|
EnableDlgGroup (hDlg,
|
|
GetDlgItem (hDlg, IDG_CRITERIA_E), FALSE);
|
|
EnableWindow (GetDlgItem (hDlg, IDB_CREATEDELETE_E),
|
|
FALSE);
|
|
SetWindowText ((HWND)lParam, "Stop Scan");
|
|
EnableWindow (GetDlgItem (hDlg, IDB_GETNEXT_E),
|
|
TRUE);
|
|
}
|
|
else if (status==ERROR_NO_ROUTES)
|
|
MessageBox (hDlg, "ERROR_NO_ROUTES!",
|
|
NULL, MB_OK|MB_ICONSTOP);
|
|
else
|
|
MessageBox (hDlg, "ERROR!",
|
|
NULL, MB_OK|MB_ICONSTOP);
|
|
}
|
|
else {
|
|
Enums[idx] = NULL;
|
|
EnableWindow (GetDlgItem (hDlg, IDB_GETNEXT_E), FALSE);
|
|
SetWindowText ((HWND)lParam, "Get First");
|
|
EnableWindow (GetDlgItem (hDlg, IDB_CREATEDELETE_E), TRUE);
|
|
EnableDlgGroup (hDlg,
|
|
GetDlgItem (hDlg, IDG_CRITERIA_E), TRUE);
|
|
EnableWindow (GetDlgItem (hDlg, IDB_GETBEST_E),
|
|
IsDlgButtonChecked (hDlg, IDC_NETWORK_E));
|
|
}
|
|
res = TRUE;
|
|
break;
|
|
case IDB_GETNEXT_E:
|
|
if (Enums[idx]==INVALID_HANDLE_VALUE) {
|
|
GetCriteria (hDlg, &ProtocolFamily, &flags, &Route);
|
|
GetLastRoute (hDlg, ProtocolFamily, &Route);
|
|
status = RtmGetNextRoute (ProtocolFamily, flags, &Route);
|
|
}
|
|
else {
|
|
status = RtmEnumerateGetNextRoute (Enums[idx], &Route);
|
|
ProtocolFamily = SendDlgItemMessage (hDlg,
|
|
IDC_PROTOCOL_FAMILY_E,
|
|
CB_GETCURSEL, 0, 0);
|
|
}
|
|
if (status==NO_ERROR)
|
|
DisplayRoute (hDlg, ProtocolFamily, &Route);
|
|
else if (status==ERROR_NO_MORE_ROUTES)
|
|
MessageBox (hDlg, "ERROR_NO_MORE_ROUTES!",
|
|
NULL, MB_OK|MB_ICONSTOP);
|
|
else
|
|
MessageBox (hDlg, "ERROR!",
|
|
NULL, MB_OK|MB_ICONSTOP);
|
|
|
|
res = TRUE;
|
|
break;
|
|
case IDB_GETBEST_E:
|
|
GetCriteria (hDlg, &ProtocolFamily, &flags, &Route);
|
|
res = RtmIsRoute (ProtocolFamily, ((char *)&Route)+sizeof(RTM_XX_ROUTE), &Route);
|
|
|
|
if (res)
|
|
DisplayRoute (hDlg, ProtocolFamily, &Route);
|
|
else
|
|
MessageBox (hDlg, "NO_ROUTES!",
|
|
NULL, MB_OK|MB_ICONSTOP);
|
|
res = TRUE;
|
|
break;
|
|
case IDB_GETAGE_E:
|
|
ProtocolFamily = SendDlgItemMessage (hDlg,
|
|
IDC_PROTOCOL_FAMILY_E,
|
|
CB_GETCURSEL, 0, 0);
|
|
GetLastRoute (hDlg, ProtocolFamily, &Route);
|
|
status = RtmGetSpecificRoute (ProtocolFamily, &Route);
|
|
|
|
if (status==NO_ERROR) {
|
|
DisplayRoute (hDlg, ProtocolFamily, &Route);
|
|
SetDlgItemInt (hDlg, IDL_AGESEC_E,
|
|
RtmGetRouteAge (&Route), FALSE);
|
|
}
|
|
else
|
|
MessageBox (hDlg, "NO_ROUTES!",
|
|
NULL, MB_OK|MB_ICONSTOP);
|
|
res = TRUE;
|
|
break;
|
|
}
|
|
break;
|
|
case WM_DESTROY:
|
|
if (Enums[idx]!=NULL) {
|
|
if (Enums[idx]!=INVALID_HANDLE_VALUE) {
|
|
if (RtmCloseEnumerationHandle (Enums[idx])!=NO_ERROR)
|
|
MessageBox (hDlg, "Close handle failed!",
|
|
NULL, MB_OK|MB_ICONSTOP);
|
|
}
|
|
Enums[idx] = NULL;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
VOID
|
|
GetCriteria (
|
|
HWND hDlg,
|
|
DWORD *ProtocolFamily,
|
|
DWORD *flags,
|
|
PRTM_ROUTE Route
|
|
) {
|
|
char buf[32];
|
|
char *p;
|
|
INT val,i,n;
|
|
|
|
*ProtocolFamily = SendDlgItemMessage (hDlg, IDC_PROTOCOL_FAMILY_E,
|
|
CB_GETCURSEL, 0, 0);
|
|
|
|
if (IsDlgButtonChecked (hDlg, IDC_BESTROUTES_E)) {
|
|
*flags = RTM_ONLY_BEST_ROUTES;
|
|
}
|
|
else
|
|
*flags = 0;
|
|
|
|
if (IsDlgButtonChecked (hDlg, IDC_INTERFACE_E)) {
|
|
*flags |= RTM_ONLY_THIS_INTERFACE;
|
|
|
|
Route->XX_INTERFACE = GetDlgItemInt (hDlg,
|
|
IDE_INTERFACE_E, NULL, FALSE);
|
|
}
|
|
if (IsDlgButtonChecked (hDlg, IDC_PROTOCOL_E)) {
|
|
*flags |= RTM_ONLY_THIS_PROTOCOL;
|
|
Route->XX.RR_RoutingProtocol = GetDlgItemInt (hDlg,
|
|
IDE_PROTOCOL_E, NULL, FALSE);
|
|
}
|
|
if (IsDlgButtonChecked (hDlg, IDC_NETWORK_E)) {
|
|
*flags |= RTM_ONLY_THIS_NETWORK;
|
|
GetDlgItemText (hDlg, IDE_NETWORK_E, buf, sizeof (buf)-1);
|
|
p = buf;
|
|
switch (*ProtocolFamily) {
|
|
case RTM_PROTOCOL_FAMILY_IPX:
|
|
if (sscanf (p, "%8X%n", &val, &n)==1)
|
|
Route->IPX_NET_NUM = val;
|
|
else
|
|
Route->IPX_NET_NUM = 0;
|
|
p += n;
|
|
sprintf (buf,
|
|
"%08X",
|
|
Route->IPX_NET_NUM);
|
|
break;
|
|
case RTM_PROTOCOL_FAMILY_IP:
|
|
if (sscanf (p, "%8X%n", &val, &n)==1)
|
|
Route->IP_NET_NUM = val;
|
|
else
|
|
Route->IP_NET_NUM = 0;
|
|
p += n;
|
|
if (sscanf (p, "%8X%n", &val, &n)==1)
|
|
Route->IP_NET_MSK = val;
|
|
else
|
|
Route->IP_NET_MSK = 0;
|
|
p += n;
|
|
sprintf (buf,
|
|
"%08X%08X",
|
|
Route->IP_NET_NUM,
|
|
Route->IP_NET_MSK);
|
|
break;
|
|
}
|
|
SetDlgItemText (hDlg, IDE_NETWORK_E, buf);
|
|
}
|
|
}
|
|
|
|
VOID
|
|
GetLastRoute (
|
|
HWND hDlg,
|
|
DWORD ProtocolFamily,
|
|
PRTM_ROUTE Route
|
|
) {
|
|
char buf[128];
|
|
char *p;
|
|
INT i,n,val;
|
|
|
|
|
|
GetDlgItemText (hDlg, IDL_ROUTE_E, buf, sizeof (buf)-1);
|
|
p = buf;
|
|
switch (ProtocolFamily) {
|
|
case RTM_PROTOCOL_FAMILY_IPX:
|
|
if (sscanf (p, "%8X%n", &val, &n)==1)
|
|
Route->IPX_NET_NUM = val;
|
|
else
|
|
Route->IPX_NET_NUM = 0;
|
|
p += n;
|
|
sscanf (p,
|
|
" %d %d %n",
|
|
&Route->XX_INTERFACE,
|
|
&Route->XX_PROTOCOL,
|
|
&n);
|
|
p += n;
|
|
for (i=0; i<sizeof(Route->IPX_NEXT_HOP_MAC); i++, p+=n) {
|
|
if (sscanf (p, "%2X%n", &val, &n)==1)
|
|
Route->IPX_NEXT_HOP_MAC[i] = (BYTE)val;
|
|
else
|
|
Route->IPX_NEXT_HOP_MAC[i] = 0;
|
|
}
|
|
break;
|
|
case RTM_PROTOCOL_FAMILY_IP:
|
|
if (sscanf (p, "%8X%n", &val, &n)==1)
|
|
Route->IP_NET_NUM = val;
|
|
else
|
|
Route->IP_NET_NUM = 0;
|
|
p += n;
|
|
sscanf (p, "-%n", &n);
|
|
p += n;
|
|
if (sscanf (p, "%8X%n", &val, &n)==1)
|
|
Route->IP_NET_MSK = val;
|
|
else
|
|
Route->IP_NET_MSK = 0;
|
|
p += n;
|
|
sscanf (p,
|
|
" %d %d %n",
|
|
&Route->XX_INTERFACE,
|
|
&Route->XX_PROTOCOL,
|
|
&n);
|
|
p += n;
|
|
|
|
if (sscanf (p, "%8X%n", &val, &n)==1)
|
|
Route->IP_NEXT_HOP_NUM = val;
|
|
else
|
|
Route->IP_NEXT_HOP_NUM = 0;
|
|
p += n;
|
|
sscanf (p, "-%n", &n);
|
|
p += n;
|
|
if (sscanf (p, "%8X%n", &val, &n)==1)
|
|
Route->IP_NEXT_HOP_MSK = val;
|
|
else
|
|
Route->IP_NEXT_HOP_MSK = 0;
|
|
p += n;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
VOID
|
|
DisplayRoute (
|
|
HWND hDlg,
|
|
DWORD ProtocolFamily,
|
|
PRTM_ROUTE Route
|
|
) {
|
|
char buf[128];
|
|
|
|
switch (ProtocolFamily) {
|
|
case RTM_PROTOCOL_FAMILY_IPX:
|
|
sprintf (buf,
|
|
" %08X "
|
|
" %4d %4d"
|
|
" %02X%02X%02X%02X%02X%02X "
|
|
" %4d",
|
|
Route->IPX_NET_NUM,
|
|
Route->XX_INTERFACE,
|
|
Route->XX_PROTOCOL,
|
|
Route->IPX_NEXT_HOP_MAC[0],
|
|
Route->IPX_NEXT_HOP_MAC[1],
|
|
Route->IPX_NEXT_HOP_MAC[2],
|
|
Route->IPX_NEXT_HOP_MAC[3],
|
|
Route->IPX_NEXT_HOP_MAC[4],
|
|
Route->IPX_NEXT_HOP_MAC[5],
|
|
Route->IPX_METRIC);
|
|
break;
|
|
case RTM_PROTOCOL_FAMILY_IP:
|
|
sprintf (buf,
|
|
"%08X-%08X"
|
|
" %4d %4d"
|
|
" %08X-%08X"
|
|
" %4d",
|
|
Route->IP_NET_NUM,
|
|
Route->IP_NET_MSK,
|
|
Route->XX_INTERFACE,
|
|
Route->XX_PROTOCOL,
|
|
Route->IP_NEXT_HOP_NUM,
|
|
Route->IP_NEXT_HOP_MSK,
|
|
Route->IP_METRIC);
|
|
|
|
break;
|
|
}
|
|
|
|
SetDlgItemText (hDlg, IDL_ROUTE_E, buf);
|
|
sprintf (buf, "%08X", Route->XX_TIMESTAMP.dwHighDateTime);
|
|
SetDlgItemText (hDlg, IDL_TIMEHIGH_E, buf);
|
|
sprintf (buf, "%08X", Route->XX_TIMESTAMP.dwLowDateTime);
|
|
SetDlgItemText (hDlg, IDL_TIMELOW_E, buf);
|
|
}
|