windows-nt/Source/XPSP1/NT/net/homenet/alg/alg_test/myalg.cpp

602 lines
13 KiB
C++
Raw Normal View History

2020-09-26 03:20:57 -05:00
//////////////////////////////////////////////////////////////////////////////
//
// MyALG.cpp : Implementation of CMyALG
//
// Main interface called by ALG.exe it wil call Initialise and stop when the ALG.exe is unloading
// or this ALG Module is disable/removed
//
#include "PreComp.h"
#include "MyALG.h"
#include "MyAdapterNotify.h"
#include <winsock.h>
#pragma comment(lib, "wsock32.lib")
/////////////////////////////////////////////////////////////////////////////
//
// CMyALG
//
#define PORTNUM 1313
#define HOSTNAME "localhost" // Server name string
#define MAX_PENDING_CONNECTS 4 // Maximum length of the queue of pending connections
IApplicationGatewayServices* g_pIAlgServices=NULL; // Cache main interface of ALG
IAdapterNotificationSink* g_pIAdapterNotificationSink=NULL;
IPrimaryControlChannel* g_pIControlChannel=NULL;
USHORT g_usPort= 0; // Test Reserve some ports
DWORD g_dwAdapterSinkCookie=0;
DWORD g_dwThreadID_Listen;
SOCKET g_ClientSock = INVALID_SOCKET; // Socket for communicating
//
// Forward declaration
//
DWORD WINAPI ThreadListenRedirect(LPVOID lpThreadParameter);
//
//
// Main entry point for ALG Modules
//
//
STDMETHODIMP
CMyALG::Initialize(
IApplicationGatewayServices* pIAlgServices
)
{
MYTRACE_ENTER("CMyALG::Initialize");
USES_CONVERSION;
HRESULT hr;
ULONG nAddress;
//
// Keep the service alive (this is optional since the ALG Manager is loading us it will always be around)
//
g_pIAlgServices = pIAlgServices;
g_pIAlgServices->AddRef();
#if 1
//
// Requesting Notification of adapter ADD/REMOVE/MODIFY
// when an adapter gets Added Removed or is modified this ALG will receive a notification
//
{
MYTRACE_ENTER("###TEST### - STARTADAPTERNOTIFICATIONS");
CComObject<CMyAdapterNotify>* pIAdapterNotify;
CComObject<CMyAdapterNotify>::CreateInstance(&pIAdapterNotify);
hr = pIAdapterNotify->QueryInterface(IID_IAdapterNotificationSink, (void**)&g_pIAdapterNotificationSink);
if ( FAILED(hr) )
MYTRACE_ERROR("No QI on IID_IAdapterNotificationSink", hr);
hr = g_pIAlgServices->StartAdapterNotifications(g_pIAdapterNotificationSink, &g_dwAdapterSinkCookie);
}
#endif
#if 1
//
// Reserver some ports, these port will be garantied to be free and available for this ALG
//
{
MYTRACE_ENTER("###TEST### - RESERVE PORT");
hr = g_pIAlgServices->ReservePort(4, &g_usPort);
if ( SUCCEEDED(hr) )
MYTRACE("ALG_TEST->ReservePorts (%d) to (%d)", ntohs(g_usPort), ntohs(g_usPort)+3);
else
{
MYTRACE_ERROR("Could no reserver port", hr);
return E_FAIL;
}
}
#endif
#if 1
//
// Redirect traffic of a well unknown port here we invented port 5000 as a port of interest
//
{
MYTRACE_ENTER("###TEST### - CREATE PRIMARY CONTROL CHANNEL");
hr = g_pIAlgServices->CreatePrimaryControlChannel(
eALG_TCP,
htons(5000),
eALG_DESTINATION_CAPTURE,
true,
inet_addr("127.0.0.1"),
htons(PORTNUM),
&g_pIControlChannel
);
if ( FAILED(hr) )
{
MYTRACE_ERROR("FAILED the CreatePrimaryControlChannel", hr);
}
}
#endif
#if 1
//
// SECONDARY CHANNEL
//
{
MYTRACE_ENTER("###TEST### - CREATE SECONDARY CHANNAL");
ISecondaryControlChannel* mySecondaryDataChannel=NULL;
hr = g_pIAlgServices->CreateSecondaryControlChannel(
eALG_UDP,
inet_addr("192.168.0.2"),
htons(99),
inet_addr("157.157.157.2"),
htons(5001),
inet_addr("205.157.157.1"),
htons(5002),
inet_addr("127.0.0.1"),
htons(666),
eALG_INBOUND,
false,
&mySecondaryDataChannel
);
if ( FAILED(hr) )
{
MYTRACE_ERROR("Could not create SecondaryDataChannel", hr);
}
else
{
hr = mySecondaryDataChannel->Cancel();
if ( FAILED(hr) )
{
MYTRACE_ERROR("Failed to cancel", hr);
}
mySecondaryDataChannel->Release();
}
}
#endif
//
// Listen on another thread for redirected packet
//
HANDLE hThread = CreateThread(
NULL, // SecurityDesc
0, // initial stack size
ThreadListenRedirect, // thread function
NULL, // thread argument
0, // creation option
&g_dwThreadID_Listen // thread identifier
);
if ( !hThread )
MYTRACE_ERROR("Could not start listenning thread", 0);
#if 1
//
// TEST GetBestSourceAddressForDestinationAddress
// should return the best IP Address to use
//
{
MYTRACE_ENTER("###TEST### - GET BEST SOURCE ADDRESS FOR DESTINATION ADDRESS");
ULONG nAddressDest = inet_addr("157.157.157.2");
hr = g_pIAlgServices->GetBestSourceAddressForDestinationAddress(
nAddressDest, // IP Address of destination
false, // if Dialup is involved
&nAddress // the Address to use
);
if ( FAILED(hr) )
{
MYTRACE_ERROR("FAILED the CreatePrimaryControlChannel", hr);
}
MYTRACE( "Best address is %s", MYTRACE_IP(nAddress) );
}
#endif
#if 1
//
// D A T A C H A N N E L
//
{
MYTRACE_ENTER("###TEST### - CREATE DATA CHANNEL");
IDataChannel* myDataChannel=NULL;
hr = g_pIAlgServices->CreateDataChannel(
eALG_TCP,
nAddress,
g_usPort,
inet_addr("157.157.157.2"),
htons(5001),
inet_addr("157.157.157.1"),
htons(5001),
eALG_INBOUND,
eALG_NONE,
false,
&myDataChannel
);
if ( FAILED(hr) )
{
MYTRACE_ERROR("Could not create DataChannel", hr);
}
else
{
hr = myDataChannel->Cancel();
if ( FAILED(hr) )
{
MYTRACE_ERROR("Failed to cancel", hr);
}
myDataChannel->Release();
}
}
#endif
//
//
// TEST - PrepareProxyConnection
//
//
#if 1
{
MYTRACE_ENTER("###TEST### - PREPARE PROXY CONNECTION");
IPendingProxyConnection* myPendingProxyConnection=NULL;
hr = g_pIAlgServices->PrepareProxyConnection(
eALG_TCP, // Protocal
nAddress, // Source Address
g_usPort, // Source Port
inet_addr("172.31.77.13"), // Public Destination Address
htons(21), // Public Destination port
FALSE,
&myPendingProxyConnection
);
if ( FAILED(hr) )
{
MYTRACE_ERROR("Could not create shadow redirect", hr);
}
else
{
hr = myPendingProxyConnection->Cancel();
if ( FAILED(hr) )
{
MYTRACE_ERROR("Failed to cancel", hr);
}
myPendingProxyConnection->Release();
}
}
#endif
#if 1
//
//
// TEST - PrepareSourceModifiedProxyConnection
//
//
{
MYTRACE_ENTER("###TEST### - PREPARE SOURCE MODIFIED PROXY CONNECTION");
IPendingProxyConnection* myPendingProxyConnection2=NULL;
hr = g_pIAlgServices->PrepareSourceModifiedProxyConnection(
eALG_TCP,
nAddress,
htons(1212),
inet_addr("172.31.77.13"),
htons(21),
inet_addr("172.31.77.14"),
htons(22),
&myPendingProxyConnection2
);
if ( FAILED(hr) )
{
MYTRACE_ERROR("Could not create shadow redirect", hr);
}
else
{
hr = myPendingProxyConnection2->Cancel();
if ( FAILED(hr) )
{
MYTRACE_ERROR("Failed to cancel", hr);
}
myPendingProxyConnection2->Release();
}
}
#endif
return S_OK;
}
//
//
//
STDMETHODIMP
CMyALG::Stop()
{
MYTRACE_ENTER("CMyALG::Stop(void)");
closesocket(g_ClientSock);
g_ClientSock = INVALID_SOCKET;
if ( g_dwAdapterSinkCookie )
{
HRESULT hr = g_pIAlgServices->StopAdapterNotifications(g_dwAdapterSinkCookie);
g_pIAdapterNotificationSink->Release();
}
if ( g_pIControlChannel )
{
g_pIControlChannel->Cancel();
}
MYTRACE("ReleaseReservedPort %d", g_usPort);
g_pIAlgServices->ReleaseReservedPort(g_usPort, 4);
MYTRACE("About To Release");
// g_pIAlgServices->Release();
MYTRACE("Return");
return S_OK;
}
//
//
//
HRESULT
WaitForData()
{
MYTRACE_ENTER("WaitForData()");
//
// Prepare winsock
//
int index = 0; // Integer index
SOCKET WinSocket = INVALID_SOCKET; // Window socket
// between the server and client
SOCKADDR_IN local_sin; // Local socket address
WSADATA WSAData; // Contains details of the Winsock implementation
// Initialize Winsock.
if ( WSAStartup (MAKEWORD(1,1), &WSAData) != 0 )
{
MYTRACE_ERROR("WSAStartup failed.", WSAGetLastError ());
}
// Create a TCP/IP socket, WinSocket.
if ((WinSocket = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
{
MYTRACE_ERROR("Allocating socket failed", WSAGetLastError());
return E_FAIL;
}
// Fill out the local socket's address information.
local_sin.sin_family = AF_INET;
local_sin.sin_port = htons(PORTNUM); //g_usPort;
local_sin.sin_addr.s_addr = inet_addr("127.0.0.1");
// Associate the local address with WinSocket.
if ( bind(WinSocket, (struct sockaddr *) &local_sin, sizeof (local_sin)) == SOCKET_ERROR )
{
MYTRACE_ERROR("Binding socket failed.", WSAGetLastError ());
closesocket (WinSocket);
return E_FAIL;
}
// Establish a socket to listen for incoming connections.
if ( listen(WinSocket, MAX_PENDING_CONNECTS) == SOCKET_ERROR )
{
MYTRACE_ERROR("Listening to the client failed.", WSAGetLastError ());
closesocket (WinSocket);
return E_FAIL;
}
// Accept an incoming connection attempt on WinSocket.
SOCKADDR_IN accept_sin; // Receives the address of the
// connecting entity
int accept_sin_len; // Length of accept_sin
accept_sin_len = sizeof (accept_sin);
MYTRACE("*** Accept is waiting for a connection");
g_ClientSock = accept(
WinSocket,
(struct sockaddr *) &accept_sin,
(int *) &accept_sin_len
);
// Stop listening for connections from clients.
closesocket (WinSocket);
{
MYTRACE ("Getting original address");
//
ULONG ulOriginalDestinationAddress;
USHORT usOriginalDestinationPort;
IAdapterInfo* pAdapterInfo;
HRESULT hr = g_pIControlChannel->GetOriginalDestinationInformation(
accept_sin.sin_addr.S_un.S_addr,
accept_sin.sin_port,
&ulOriginalDestinationAddress,
&usOriginalDestinationPort,
&pAdapterInfo
);
if ( FAILED(hr) )
{
MYTRACE_ERROR("GetOriginalDestinationInformation did not work", hr);
}
else
{
MYTRACE("Original Address %s:%d", MYTRACE_IP(ulOriginalDestinationAddress), ntohs(usOriginalDestinationPort));
ULONG nIndex;
pAdapterInfo->GetAdapterIndex(&nIndex);
ALG_ADAPTER_TYPE eType;
pAdapterInfo->GetAdapterType(&eType);
MYTRACE("AdapterIndex %d", nIndex);
MYTRACE("AdapterType %d", eType);
}
}
if ( g_ClientSock == INVALID_SOCKET)
{
MYTRACE_ERROR("Accepting connection with client failed. Error: %d", WSAGetLastError ());
return E_FAIL;
}
MYTRACE("**** AFTER Listen on port %d", g_usPort);
TCHAR cData;
int iReturn;
for (;;)
{
// Receive data from the client.
iReturn = recv(
g_ClientSock,
(char*)&cData,
sizeof(cData),
0);
// Check if there is any data received. If there is, display it.
if (iReturn == SOCKET_ERROR)
{
MYTRACE("Received failed. Error: %d", WSAGetLastError ());
return E_FAIL;
}
else if (iReturn == 0)
{
MYTRACE("Finished receiving data");
break;
}
else
{
MYTRACE("%c", cData);
}
}
closesocket(g_ClientSock);
//
// Enumerate The Adapters
//
IEnumAdapterInfo* pAdapters = NULL;
HRESULT hr = g_pIAlgServices->EnumerateAdapters(&pAdapters);
if ( FAILED(hr) )
{
MYTRACE_ERROR("Call EnumerateAdapters did not worked", hr);
}
else
pAdapters->Release();
return S_OK;
}
//
//
//
DWORD WINAPI
ThreadListenRedirect(LPVOID lpThreadParameter)
{
MYTRACE_ENTER("ThreadListenRedirect()");
while ( WaitForData() == S_OK );
return 0;
}