void passiveClose(peerInfo peer)
{
tcpPacket fin1Pkt;
tcpHeader fin1ack;
tcpHeader fin2Pkt;
tcpPacket fin2ack;
while(client_wndw.state != CLOSE_WAIT)
{
fin1ack.type = FIN_ACK;
fin1ack.msglen = 0;
fin1ack.seqNo = 0;
fin1ack.ackNo = 0;
fin1ack.drop_probablity = 1.0;
readPackets(peer,&fin1Pkt,sizeof(tcpPacket),0);
if(fin1Pkt.header.type == FIN)
{
printf("<--FIN RECVD\n");
sendData(peer,&fin1ack,sizeof(tcpHeader),0);
printf("FIN ACK SENT-->\n");
client_wndw.state = CLOSE_WAIT;
}
}
fin2Pkt.type = FIN;
fin2Pkt.msglen = 0;
fin2Pkt.seqNo = 0;
fin2Pkt.ackNo = 0;
fin2Pkt.drop_probablity = 1.0;
printf("FIN 2 SENT-->\n");
sendData(peer,&fin2Pkt,sizeof(tcpHeader),0);
while ( client_wndw.state != LAST_ACK)
{
readPackets(peer,&fin2ack,sizeof(tcpPacket),0);
if(fin2ack.header.type == FIN_ACK)
{
printf("<--FIN ACK RECVD\n");
client_wndw.state = LAST_ACK;
}
}
printf("COMMUNICATION CLOSED PROPERLY\n");
}
CCS_TYPE CCCSProtocolHandler::read()
{
bool res = true;
// Loop until we have no more data from the socket or we have data for the higher layers
while (res)
res = readPackets();
return m_type;
}
NETWORK_TYPE CGatewayProtocolHandler::read(wxUint16& id, in_addr& address, unsigned int& port)
{
bool res = true;
// Loop until we have no more data from the socket or we have data for the higher layers
while (res)
res = readPackets(id, address, port);
return m_type;
}
REPEATER_TYPE CDExtraGatewayRepeaterProtocolHandler::read()
{
bool res = true;
// Loop until we have no more data from the socket or we have data for the higher layers
while (res)
res = readPackets();
return m_type;
}
void *packetreader(void *arg) {
bcm2835_gpio_fsel(RPI_BPLUS_GPIO_J8_38, BCM2835_GPIO_FSEL_INPT);
while(1) {
//usleep(10);
readPackets();
}
}
NETWORK_TYPE CDExtraProtocolHandler::read()
{
if (m_socket == NULL) {
m_type = NETWORK_NONE;
return NETWORK_NONE;
}
bool res = true;
// Loop until we have no more data from the socket or we have data for the higher layers
while (res)
res = readPackets();
return m_type;
}
void ServiceMain(int argc, char** argv)
{
ServiceStatus.dwServiceType = SERVICE_WIN32;
ServiceStatus.dwCurrentState = SERVICE_START_PENDING;
ServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
ServiceStatus.dwWin32ExitCode = 0;
ServiceStatus.dwServiceSpecificExitCode = 0;
ServiceStatus.dwCheckPoint = 0;
ServiceStatus.dwWaitHint = 0;
if (isService) {
hStatus = RegisterServiceCtrlHandler(HSP_SERVICE_NAME,
(LPHANDLER_FUNCTION)ControlHandler);
if (hStatus == 0)
{
return;
}
}
// Test for only one instance is running
HANDLE mutex = CreateMutex(NULL, TRUE, instanceMutexName);
DWORD err = GetLastError();
if (mutex != NULL && err == ERROR_ALREADY_EXISTS ||
mutex == NULL && err == ERROR_ACCESS_DENIED) {
// Mutex found, so another instance is running
if (hStatus != 0) {
ServiceStatus.dwCurrentState = SERVICE_STOPPED;
ServiceStatus.dwWin32ExitCode = ERROR_SINGLE_INSTANCE_APP;
SetServiceStatus(hStatus, &ServiceStatus);
} else {
myLog(LOG_ERR, "%s.ServiceMain: only one instance can run, existing instance found", HSP_SERVICE_NAME);
}
return;
} else {
ServiceStatus.dwCurrentState = SERVICE_RUNNING;
if (hStatus != 0) {
// We are the first instance, report the running status to SCM.
SetServiceStatus (hStatus, &ServiceStatus);
}
}
wchar_t programDataDir[MAX_PATH];
if (!initialiseProgramDataDir(programDataDir, MAX_PATH)) {
*programDataDir = NULL;
}
char mbcLogFilename[MAX_PATH];
if (isService && *programDataDir != NULL) {
//set the log file name to the default.
size_t dirLen = 0;
if (0 == wcstombs_s(&dirLen, mbcLogFilename, MAX_PATH, programDataDir, wcslen(programDataDir))) {
PathAppend(mbcLogFilename, HSP_DEFAULT_LOGFILE);
logFilename = mbcLogFilename;
} else {
logFilename = NULL;
}
}
if (logFilename != NULL) {
// Logging on
errno_t error = fopen_s(&logFile, logFilename, "wt");
if (error != 0) {
logFile = stderr;
myLog(LOG_ERR, "%s.ServiceMain: could not open log file %s: error %d\n", HSP_SERVICE_NAME, logFilename, error);
}
logFilename = NULL;
}
myLog(debug, "-------------Starting %s %s--------------", HSP_SERVICE_NAME, HSP_VERSION);
fflush(logFile);
HSP sp = { 0 };
// look up host-id fields at startup only (hostname
// may change dynamically so will have to revisit this $$$)
sp.host_hid.hostname.str = (char *)my_calloc(SFL_MAX_HOSTNAME_CHARS+1);
sp.host_hid.os_release.str = (char *)my_calloc(SFL_MAX_OSRELEASE_CHARS+1);
readHidCounters(&sp, &sp.host_hid);
sp.nio_polling_secs = HSP_NIO_POLLING_SECS_32BIT;
readInterfaces(&sp, TRUE);
if (!readConfig(&sp)) {
myLog(LOG_ERR, "%s.ServiceMain: invalid configuration", HSP_SERVICE_NAME);
if (hStatus != 0) {
ServiceStatus.dwCurrentState = SERVICE_STOPPED;
ServiceStatus.dwWin32ExitCode = ERROR_INVALID_PARAMETER;
SetServiceStatus(hStatus, &ServiceStatus);
}
return;
}
sp.hyperV = testForHyperv();
if (sp.hyperV) {
myLog(debug, "%s.ServiceMain Hyper-V services are running", HSP_SERVICE_NAME);
if (programDataDir == NULL || !initialiseProgramDataFiles(&sp, programDataDir)) {
myLog(LOG_ERR, "%s.ServiceMain: cannot initialise switch port and VM state files", HSP_SERVICE_NAME);
if (hStatus != 0) {
ServiceStatus.dwCurrentState = SERVICE_STOPPED;
ServiceStatus.dwWin32ExitCode = ERROR_FILE_NOT_FOUND;
SetServiceStatus(hStatus, &ServiceStatus);
}
return;
}
readGuidStore(sp.f_vmStore, sp.vmStoreFile, &sp.vmStore, &sp.maxDsIndex);
readGuidStore(sp.f_portStore, sp.portStoreFile, &sp.portStore, &sp.maxIfIndex);
}
openFilter(&sp); //try to initialise the sFlow filter for sampling
initAgent(&sp);
// initialize the clock so we can detect second boundaries
sp.clk = time(NULL);
// main loop
BOOL dataAvailable = true;
uint32_t currReadNum = 0;
while (ServiceStatus.dwCurrentState == SERVICE_RUNNING && dataAvailable)
{
// check for second boundaries and generate ticks for the sFlow library
time_t now = time(NULL);
if ((now < sp.clk) || (now - sp.clk) > HSP_MAX_TICKS) {
// avoid a busy-loop of ticks if time jumps
myLog(LOG_INFO, "%s.ServiceMain: time jump detected", HSP_SERVICE_NAME);
sp.clk = now - 1;
}
while (sp.clk < now) { //only happens on second boundary
//start critical
if (sp.sFlow->sFlowSettings) {
// update polling interval here if config has changed.
tick(&sp);
}
//end critical
sp.clk++;
}
DWORD result;
//process a queued counter poller
processQueuedPoller(&sp);
//timeout is set so that we loop around checking for ticks and samples
//several times/s.
//calculate timeout 200 if the counter poller queue is empty, 0 otherwise
DWORD timeout = sp.pollerQHead == NULL ? HSP_TIMEOUT : 0;
if (HSP_FILTER_ACTIVE(sp.filter)) {
result = WaitForSingleObject(sp.filter.overlaps[currReadNum].hEvent,
timeout);
if (result == WAIT_OBJECT_0) {
dataAvailable = sp.filter.overlaps[currReadNum].Internal == ERROR_SUCCESS;
if (dataAvailable && sp.filter.overlaps[currReadNum].InternalHigh > 0) {
//process the sample info in sp.filter.buffers[currReadNum]
readPackets(&sp, sp.filter.buffers[currReadNum]);
}
// Re-queue this read
queueRead(sp.filter.dev,
sp.filter.buffers[currReadNum],
sizeof(sp.filter.buffers[currReadNum]),
&sp.filter.overlaps[currReadNum]);
//set the next buffer to read
currReadNum = (currReadNum+1)%numConcurrentReads;
}
} else {
Sleep(timeout);
}
}
return;
}