/*
* Class: javm_nativeimp_NsDatagramSocketImpl
* Method: peek
* Signature: (Ljavm/net/InetAddress;)I
*/
JNIEXPORT jint JNICALL Java_agentj_nativeimp_NsDatagramSocketImpl_peek
(JNIEnv *env, jobject javaobj, jobject longAddress) {
PLOG(PL_DEBUG, "Java_agentj_nativeimp_NsDatagramSocketImpl_peek: Entering\n");
ProtoSocket *socket = (ProtoSocket *)getSocket(env, javaobj); // gets the socket...
int len=1;
char *bdata = new char[len];
unsigned int actualRead=len;
socket->Recv(bdata, actualRead);
delete []bdata;
char sendersAddress[5];
int sendersPort;
ProtoAddress sendersProtoAddress = socket->GetDestination();
sendersPort = sendersProtoAddress.GetPort();
sendersProtoAddress.GetHostString(sendersAddress, strlen(sendersAddress));
jclass longClass = env->FindClass("java/lang/Long");
jmethodID setAddressID = env->GetMethodID(longClass, "<init>", "(J)V");
longAddress = env->NewObject(longClass, setAddressID, (jlong)sendersProtoAddress.SimGetAddress());
return 0;
}
void Pipe2Sock::SendMessage()
{
if(socket.IsOpen())
{
TRACE("Sending message %s to %s/%d\n",msg_buffer,dst_addr.GetHostString(),dst_addr.GetPort());
unsigned int len = strlen(msg_buffer);
socket.SendTo(msg_buffer,len,dst_addr);
memset(msg_buffer,0,msg_len); //clear out the message
}
}
bool Pipe2Sock::OnStartup(int argc, const char*const* argv)
{
if (argc == 1)
{
TRACE("No args! Are you sure you want to be running without any args?\n");
Usage();
}
if (!ProcessCommands(argc, argv))
{
PLOG(PL_ERROR, "pipe2Sock::OnStartup() error processing command line\n");
Usage();
return false;
}
//set the destination address/port info
dst_addr.SetPort(dst_port);
TRACE("Destination address set to %s/%d\n",dst_addr.GetHostString(),dst_port);
//set the socket sending/binding port info
if(!(socket.Bind(snd_port))){
PLOG(PL_ERROR,"pipe2Sock::OnStartup() error binding to port %d\n",snd_port);
return false;
}
if(!(socket.Open(snd_port,ProtoAddress::IPv4,false)))
{
PLOG(PL_ERROR,"pipe2Sock::OnStartup() error opening the socket on port %d\n",snd_port);
return false;
}
if(dst_addr.IsMulticast())
{
if(!socket.JoinGroup(dst_addr))
{
PLOG(PL_ERROR,"pipe2Sock::OnStartup() error joining multicast group %s\n",dst_addr.GetHostString());
socket.Close();
return false;
}
TRACE("Joined multicast group %s\n",dst_addr.GetHostString());
}
TRACE("Sending port set to %d\n",snd_port);
//open up a listening pipe
if (!listen_pipe.Listen(listen_pipe_name))
{
socket.Close();
PLOG(PL_ERROR, "Pipe2Sock::OnCommand() listen_pipe.Listen() error opening pipe with name %s\n",listen_pipe_name);
return false;
}
TRACE("pipe2Sock: listen \"%s\" listening ...\n", listen_pipe_name);
return true;
} // end Pipe2Sock::OnStartup()
/*
* Class: javm_nativeimp_NsDatagramSocketImpl
* Method: leave
* Signature: (Ljavm/net/InetAddress;Ljavm/net/NetworkInterface;)V
*/
JNIEXPORT void JNICALL Java_agentj_nativeimp_NsDatagramSocketImpl_leave
(JNIEnv *env, jobject javaobj, jlong socketAddress) {
PLOG(PL_DEBUG, "Java_agentj_nativeimp_NsDatagramSocketImpl_leave entering \n");
ProtoSocket *socket = (ProtoSocket *)getSocket(env, javaobj); // gets the socket...
ProtoAddress multicastAddress;
multicastAddress.SimSetAddress((unsigned int)socketAddress);
socket->LeaveGroup(multicastAddress, NULL);
PLOG(PL_DEBUG, "Java_agentj_nativeimp_NsDatagramSocketImpl_leave: exiting...\n");
}
bool ScenargieRouteMgr::DeleteRoute(
const ProtoAddress& destinationProtoAddress,
unsigned int prefixLength,
const ProtoAddress& gatewayProtoAddress,
unsigned int protoInterfaceIndex)
{
bool routeIsDeletedFromProtoRouteTable = protoRouteTable.DeleteRoute(
destinationProtoAddress,
prefixLength,
&gatewayProtoAddress);
if(routeIsDeletedFromProtoRouteTable){
NetworkAddress destinationNetworkAddress(
destinationProtoAddress.SimGetAddress());
NetworkAddress destinationNetworkAddressSubnetMask =
NetworkAddress(0xFFFFFFFF << (32 - prefixLength));
shared_ptr<RoutingTable> routingTablePtr =
networkLayerPtr->GetRoutingTableInterface();
routingTablePtr->DeleteRoute(
destinationNetworkAddress,
destinationNetworkAddressSubnetMask);
nrlolsrProtocolPtr->OutputTraceAndStatsForDeleteRoutingTableEntry(
destinationNetworkAddress,
destinationNetworkAddressSubnetMask);
}//if//
return routeIsDeletedFromProtoRouteTable;
}//DeleteRoute//
bool ScenargieRouteMgr::SetRoute(
const ProtoAddress& destinationProtoAddress,
unsigned int prefixLength,
const ProtoAddress& gatewayProtoAddress,
unsigned int protoInterfaceIndex,
int metric)
{
bool routeIsSetToProtoRouteTable = protoRouteTable.SetRoute(
destinationProtoAddress,
prefixLength,
gatewayProtoAddress,
protoInterfaceIndex,
metric);
if (routeIsSetToProtoRouteTable){
NetworkAddress destinationNetworkAddress(
destinationProtoAddress.SimGetAddress());
NetworkAddress destinationNetworkAddressSubnetMask =
NetworkAddress(0xFFFFFFFF << (32 - prefixLength));
SIMADDR gatewayRawAddress = gatewayProtoAddress.SimGetAddress();
NetworkAddress nextHopNetworkAddress(gatewayRawAddress);
if(gatewayRawAddress == 0){
nextHopNetworkAddress = destinationNetworkAddress;
}
shared_ptr<RoutingTable> routingTablePtr =
networkLayerPtr->GetRoutingTableInterface();
routingTablePtr->AddOrUpdateRoute(
destinationNetworkAddress,
destinationNetworkAddressSubnetMask,
nextHopNetworkAddress,
interfaceIndex);
nrlolsrProtocolPtr->OutputTraceAndStatsForAddRoutingTableEntry(
destinationNetworkAddress,
destinationNetworkAddressSubnetMask,
nextHopNetworkAddress);
}//if//
return routeIsSetToProtoRouteTable;
}//SetRoute//
void Pipe2Sock::OnShutdown()
{
if (listen_pipe.IsOpen()) listen_pipe.Close();
if (socket.IsOpen())
{
if(dst_addr.IsMulticast())
{
socket.LeaveGroup(dst_addr);
}
socket.Close();
}
PLOG(PL_ERROR, "pipe2Sock: Done.\n");
} // end Pipe2Sock::OnShutdown()
bool Pipe2Sock::ProcessCommands(int argc, const char*const* argv)
{
// Dispatch command-line commands to our OnCommand() method
int i = 1;
while ( i < argc)
{
if (!strcmp("listen", argv[i]))
{
i++;
strcpy(listen_pipe_name,argv[i]);
}
else if (!strcmp("send", argv[i]))
{
i++;
const char* index = strchr(argv[i],'/');
if(index!=NULL)
{
char charAddr[255];
memset(charAddr,0,255);
strncpy(charAddr,argv[i],index-argv[i]);
if(!dst_addr.ResolveFromString(charAddr))
{
PLOG(PL_ERROR, "Pipe2Sock::OnCommand() send error: setting dst address to %s\n",charAddr);
return false;
}
dst_port = atoi(index+1);
}
else
{
PLOG(PL_ERROR,"Pipe2Sock::OnCommand() missing \"/\" for send command\n");
return false;
}
}
else if (!strcmp("port", argv[i]))
{
i++;
snd_port = atoi(argv[i]);
}
else
{
PLOG(PL_ERROR, "Pipe2Sock::OnCommand() unknown command error?\n");
return false;
}
i++;
}
return true;
} // end Pipe2Sock::ProcessCommands()
bool ProtoSocket::SendTo(const char* buffer,
unsigned int buflen,
const ProtoAddress& dstAddr)
{
if (!IsOpen())
{
if (!Open())
{
fprintf(stderr, "ProtoSocket::SendTo() error opening socket\n");
return false;
}
}
else if (TCP == protocol)
{
if (!IsConnected() || dstAddr.IsEqual(destination)) Connect(dstAddr);
if (IsConnected())
{
unsigned int put = 0;
while (put < buflen)
{
unsigned int numBytes = buflen - put;
if (Send(buffer+put, numBytes))
{
put += numBytes;
}
else
{
fprintf(stderr, "ProtoSocket::SendTo() error sending to connected socket\n");
return false;
}
}
return true;
}
}
PLOG(PL_DETAIL, "ProtoSocket::SendTo sending data to Proxy ...\n");
return (static_cast<ProtoSimAgent::SocketProxy*>(handle))->SendTo(buffer, buflen, dstAddr);
} // end ProtoSocket::SendTo()
int main(int argc, char* argv[])
{
UINT16 serverPort = 0;
ProtoAddress serverAddr;
if (3 == argc) // "simple listen <portNumber>"
{
if (!strncmp("listen", argv[1], strlen(argv[1])))
{
if (1 != (sscanf(argv[2], "%hu", &serverPort)))
{
fprintf(stderr, "simple: bad <port>\n");
serverPort = 0;
}
}
}
else if (4 == argc) // "simple connect <serverAddr> <serverPort>
{
if (!strncmp("connect", argv[1], strlen(argv[1])))
{
if (1 != (sscanf(argv[3], "%hu", &serverPort)))
{
fprintf(stderr, "simple: bad <serverPort>\n");
serverPort = 0;
}
else if (!serverAddr.ResolveFromString(argv[2]))
{
fprintf(stderr, "simple: bad <serverAddr>\n");
serverPort = 0;
}
else
{
serverAddr.SetPort(serverPort);
}
}
}
if (!serverAddr.IsValid() && (0 == serverPort))
{
usage();
return -1;
}
if (serverAddr.IsValid()) // connect to server address as a "client" and make a request
{
ProtoSocket clientSocket(ProtoSocket::TCP);
fprintf(stderr, "simple: client connecting to server: %s/%hu ...\n",
serverAddr.GetHostString(), serverAddr.GetPort());
if (!clientSocket.Connect(serverAddr))
{
fprintf(stderr, "simple: error connecting to server: %s/%hu\n",
serverAddr.GetHostString(),
serverAddr.GetPort());
return -1;
}
fprintf(stderr, "simple: client sending request to server ...\n");
char* clientRequest = "Hello Server, this is a simple protolib client!";
unsigned int length = strlen(clientRequest) + 1;
unsigned int sent = 0;
while (sent < length)
{
unsigned int numBytes = length - sent;
if (!clientSocket.Send(clientRequest+sent, numBytes))
{
fprintf(stderr, "simple: error sending to server\n");
clientSocket.Close();
return -1;
}
else
{
sent += numBytes;
}
}
fprintf(stderr, "simple: client awaiting response from server ...\n");
bool receiving = true;
while (receiving)
{
char buffer[256];
buffer[256] = '\0';
unsigned int numBytes = 255;
if (!clientSocket.Recv(buffer, numBytes))
{
fprintf(stderr, "simple: error receiving from server\n");
clientSocket.Close();
return -1;
}
else if (numBytes > 0)
{
fprintf(stdout, "simple: client recvd \"%s\" from server: %s/%hu\n",
buffer,
serverAddr.GetHostString(),
serverAddr.GetPort());
}
else
{
fprintf(stderr, "simple: server shutdown connection.\n");
receiving = false;
}
} // end while(receiving)
clientSocket.Close();
}
else // act as a "server" listening to the indicated port, responding to requests
{
for (;;)
{
ProtoSocket serverSocket(ProtoSocket::TCP);
if (!serverSocket.Listen(serverPort))
{
fprintf(stderr, "simple: server error listening\n");
serverSocket.Close();
return -1;
}
else
{
fprintf(stderr, "simple: server listening on port:%hu ... (use <CTRL-C> to exit)\n", serverPort);
if (!serverSocket.Accept())
{
fprintf(stderr, "simple: server error accepting connection\n");
serverSocket.Close();
return -1;
}
fprintf(stderr, "simple: server accepted connection from client: %s/%hu ...\n",
serverSocket.GetDestination().GetHostString(),
serverSocket.GetDestination().GetPort());
bool receiving = true;
while (receiving)
{
char buffer[256];
buffer[256] = '\0';
unsigned int numBytes = 255;
if (!serverSocket.Recv(buffer, numBytes))
{
fprintf(stderr, "simple: error receiving from client\n");
serverSocket.Close();
return -1;
}
else if (numBytes > 0)
{
fprintf(stdout, "simple: server recvd \"%s\" from client: %s/%hu\n",
buffer,
serverSocket.GetDestination().GetHostString(),
serverSocket.GetDestination().GetPort());
if (NULL != strchr(buffer, '!'))
{
fprintf(stderr, "simple: server recvd EOT character '!' from client ...\n");
receiving = false;
}
break;
}
else
{
fprintf(stderr, "simple: client closed connection\n");
receiving = false;
}
}
fprintf(stderr, "simple: server sending response to client ...\n");
char* serverResponse = "Hi there Client, this is a simple protolib server";
unsigned int length = strlen(serverResponse) + 1;
unsigned int sent = 0;
while (sent < length)
{
unsigned int numBytes = length - sent;
if (!serverSocket.Send(serverResponse+sent, numBytes))
{
fprintf(stderr, "simple: error sending to client\n");
serverSocket.Close();
return -1;
}
else
{
sent += numBytes;
}
}
serverSocket.Shutdown();
// After "Shutdown" on a blocking socket, ProtoSocket::Recv() will unblock upon
// receiving "FIN" from client TCP
char buffer[8];
unsigned int numBytes = 8;
serverSocket.Recv(buffer, numBytes);
if (0!= numBytes)
fprintf(stderr, "simple: server received extra data from client?\n\n");
else
fprintf(stderr, "simple: server transmission complete.\n\n");
}
serverSocket.Close();
} // end for (;;)
}
} // end main();
bool Win32Vif::ConfigureTap(char* adapterid,char* vifName,ProtoAddress vifAddr,unsigned int maskLen)
{
ULONG status;
HKEY key;
DWORD nameType;
const char nameString[] = "Name";
char regpath[1024];
char nameData[1024];
long len = sizeof(nameData);
/* Find out more about this adapter */
sprintf(regpath, "%s\\%s\\Connection", NETWORK_CONNECTIONS_KEY, adapterid);
/* Open the adapter key */
status = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
regpath,
0,
KEY_READ,
&key);
if (status != ERROR_SUCCESS)
{
PLOG(PL_WARN,"Win32Vif::ConfigureTap() Error opening adapter registry key:%s\n",regpath);
return false;
}
/* Get the adapter name */
status = RegQueryValueEx(key,
nameString,
NULL,
&nameType,
(LPBYTE)nameData,
(LPDWORD)&len);
if (status != ERROR_SUCCESS) // ljt || nameType != REG_SZ)
{
PLOG(PL_ERROR,"Win32Vif::ConfigureTap() Error opening registry key: %s\n%s\n%s\n\n",
NETWORK_CONNECTIONS_KEY,regpath,"Name");
return false;;
}
RegCloseKey(key);
/* Configure the interface */
char cmd[256];
char subnetMask[16];
ProtoAddress subnetMaskAddr;
subnetMaskAddr.ResolveFromString("255.255.255.255");
ProtoAddress tmpAddr;
subnetMaskAddr.GetSubnetAddress(maskLen, tmpAddr);
sprintf(subnetMask," %s ", tmpAddr.GetHostString());
sprintf(cmd,
"netsh interface ip set address \"%s\" static %s %s ",
nameData, vifAddr.GetHostString(), subnetMask);
if (LONG ret = system(cmd))
{
PLOG(PL_ERROR,"Win32Vif::ConfigureTap(%s) Open failed. netsh call returned: %u", nameData, ret);
return false;
}
// Rename the connection
if (strcmp(nameData, vifName) != 0)
{
sprintf(cmd, "netsh interface set interface name=\"%s\" newname=\"%s\"",
nameData,vifName);
if (LONG ret = system(cmd))
{
PLOG(PL_ERROR,"Win32Vif::ConfigureTap(%s) Rename failed (%s). netsh call returned: %u",
nameData, vifName, ret);
return false;
}
}
PLOG(PL_INFO,"Win32Vif::ConfigureTap() Tap opened on interface: %s\n",vifName);
/* set driver media status to 'connected' */
status = TRUE;
if (!DeviceIoControl(tap_handle, TAP_IOCTL_SET_MEDIA_STATUS,
&status, sizeof (status),
&status, sizeof (status),
(LPDWORD)&len, NULL))
PLOG(PL_WARN, "Win32Vif::ConfigureTap() warning: The TAP-Win32 driver rejected a TAP_IOCTL_SET_MEDIA_STATUS DeviceIoControl call.");
return true;
} // end Win32Five::ConfigureTap()
bool Win32Vif::FindIPAddr(ProtoAddress vifAddr)
{
// Iterate through addresses looking for an address match
ULONG bufferSize = 0;
ULONG index = 0;
if (ERROR_INSUFFICIENT_BUFFER == GetIpAddrTable(NULL, &bufferSize, FALSE))
{
char* tableBuffer = new char[bufferSize];
if (NULL == tableBuffer)
{
PLOG(PL_ERROR, "ProtoSocket::GetInterfaceName() new tableBuffer error: %s\n", ::GetErrorString());
return false;
}
MIB_IPADDRTABLE* addrTable = (MIB_IPADDRTABLE*)tableBuffer;
if (ERROR_SUCCESS == GetIpAddrTable(addrTable, &bufferSize, FALSE))
{
for (DWORD i = 0; i < addrTable->dwNumEntries; i++)
{
MIB_IPADDRROW* entry = &(addrTable->table[i]);
ProtoAddress tempAddress;
tempAddress.SetRawHostAddress(ProtoAddress::IPv4, (char*)&entry->dwAddr, 4);
if (tempAddress.HostIsEqual(vifAddr))
{
return true; // ljt fix me
MIB_IFROW ifEntry;
index = entry->dwIndex;
if (NO_ERROR != GetIfEntry(&ifEntry))
{
PLOG(PL_ERROR, "ProtoSocket::GetInterfaceName() GetIfEntry(%d) error: %s\n", i, ::GetErrorString());
return false;
}
delete[] tableBuffer;
break;
}
}
}
else
{
PLOG(PL_WARN, "ProtoSocket::GetInterfaceName(%s) warning GetIpAddrTable() error: %s\n", vifAddr.GetHostString(), GetErrorString());
}
delete[] tableBuffer;
}
if (index)
{
// we found one - add another address
// ljt need to check if this is a vif etc
// maybe don't do this at all? just fail
// if we've found one?
ULONG status = TRUE;
UINT tmpIPAddr;
UINT tmpIPMask;
ULONG NTEContext = 0;
ULONG NTEInstance = 0;
tmpIPAddr = inet_addr(vifAddr.GetHostString());
tmpIPMask = inet_addr("255.255.255.0");
if ((status = AddIPAddress(tmpIPAddr,
tmpIPMask,
index,
&NTEContext,
&NTEInstance)) != NO_ERROR)
{
PLOG(PL_ERROR,"Win32Vif::Open() AddIPAddress call failed with %d\n",status);
return false;
}
return true;
}
return false;
} // end Win32Vif::FindIPAddr()
