home *** CD-ROM | disk | FTP | other *** search
/ PCNET 2006 September - Disc 1 / PCNET_CD_2006_09.iso / surpriz / MSRMesh-VirtualWIFI.MSI / ServiceLoop.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2005-06-24  |  8.1 KB  |  216 lines
  1. /*
  2.  * Author   : Ranveer Chandra
  3.  * Directory: VirtualWiFi_Root\Service
  4.  * File Name: ServiceLoop.cpp
  5.  * Purpose  : Defines the main loop of the Service, including switching networks
  6.  */
  7. #include "VirtualWiFiservice.h"
  8. #include "ioctl.h"
  9.  
  10. extern FILE *fpConfig;
  11. //using namespace std;
  12.  
  13. bool DEBUG_ON;
  14.  
  15. void SleepM(DWORD Duration)
  16. {
  17.     MSG msg;
  18.     MsgWaitForMultipleObjects(0, NULL, TRUE, Duration, QS_ALLINPUT | QS_ALLPOSTMESSAGE); 
  19.     if (0 != PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) 
  20.         DispatchMessage(&msg); 
  21. }
  22.  
  23.  
  24. // The main routine for the VirtualWiFi Client
  25. extern VOID ServiceLoop(HANDLE *hEvents)
  26. {
  27.     ULONG numNodes=0;
  28.     RemoteNode VirtualWiFiNodes[MAX_VirtualWiFi_NODES];
  29.     int i;
  30.     ULONG j=0;
  31.     int k;
  32.     char *adapterNum="1\0";
  33.     DEBUG_ON = false;
  34.     ULONG totalTimeToStay = 0;
  35.     ULONG adaptiveScheduling = 0;
  36.     int adaptiveWindowSize = 5;
  37.     DWORD dwWait;
  38.     ULONG switchTime = 0;
  39.     ULONG waitTime = 0;
  40.     char lpOutputString[50];
  41.     ULONG numVirtualWiFiNodes=0;
  42.     ULONG isAdaptiveScheduling = 0;
  43.     char VirtualWiFiChar[50], ssidChar[SSID_LENGTH], modeChar[3];
  44.     char dataFileName[100];
  45.  
  46.     DEBUG_ON = true;
  47.     
  48.     SleepM(1000);
  49.     //fpConfig = fopen("C:\\Windows\\VirtualWiFiData.txt", "r");
  50.     sprintf(dataFileName, "%s\\VirtualWiFiData.txt", getenv("windir"));
  51.     fpConfig = fopen(dataFileName, "r");
  52.     if(fpConfig != NULL) {
  53.         sprintf(lpOutputString, "Successfully opened the config file\n");
  54.         OutputDebugString(TEXT(lpOutputString));
  55.         while(!feof(fpConfig)) {
  56.             NetworkModeAndSSID networkModeAndSSID;
  57.             dwWait = WaitForMultipleObjects( 2, hEvents, FALSE, 3 );
  58.             if ( dwWait == WAIT_OBJECT_0 )     // not overlapped i/o event - error occurred,
  59.                 break;                           // or server stop signaled
  60.    
  61.             fscanf(fpConfig, "%s %s %s\n", VirtualWiFiChar, modeChar, ssidChar);
  62.             sprintf(lpOutputString, "Connection is %s %s\n", ssidChar, modeChar);
  63.             OutputDebugString(TEXT(lpOutputString));
  64.             if(!_stricmp(modeChar, "ah"))
  65.                 networkModeAndSSID.networkMode = MODE_AH;
  66.             else if(!_stricmp(modeChar, "is"))
  67.                 networkModeAndSSID.networkMode = MODE_IS;
  68.             else {
  69.                 sprintf(lpOutputString, "Could not understand the mode\n");
  70.                 OutputDebugString(TEXT(lpOutputString));
  71.             }
  72.             strcpy(networkModeAndSSID.networkSSID, ssidChar);
  73.             networkModeAndSSID.adapterNum = "1";
  74.             networkModeAndSSID.ssidLength = (ULONG)strlen(networkModeAndSSID.networkSSID);
  75.             ioctlSet(IOCTL_SET_CURRENT_SSID, &networkModeAndSSID, (DWORD) sizeof(networkModeAndSSID));
  76.         }
  77.         fclose(fpConfig);
  78.     } else {
  79.         sprintf(lpOutputString, "Problems opening the config file\n");
  80.         OutputDebugString(TEXT(lpOutputString));
  81.     }
  82.  
  83.  
  84.     // Initialize the data structures
  85.     // numVirtualWiFiNodes = ioctlGetULongFromAdapter(IOCTL_GET_NUM_NETWORKS, adapterNum, (DWORD)strlen(adapterNum));
  86.     numVirtualWiFiNodes = ioctlGetFromAdapter(IOCTL_GET_NUM_NETWORKS, adapterNum, (DWORD)strlen(adapterNum), &numNodes, sizeof(ULONG));
  87.     
  88.     sprintf(lpOutputString, "Number of nodes is %d\n", numVirtualWiFiNodes);
  89.     OutputDebugString(TEXT(lpOutputString));
  90.  
  91.     adaptiveScheduling = ioctlGetFromAdapter(IOCTL_GET_SCHEDULING_SCHEME, adapterNum, 
  92.         (DWORD)strlen(adapterNum), &isAdaptiveScheduling, sizeof(ULONG));
  93.  
  94.     sprintf(lpOutputString, "Scheduling scheme is %d\n", adaptiveScheduling);
  95.     OutputDebugString(TEXT(lpOutputString));
  96.  
  97.  
  98.     for(j=0; j<numVirtualWiFiNodes; j++) {
  99.         ULONG tempSwitchTime = 0;
  100.         ULONG tempWaitTime = 0;
  101.         ioctlSet(IOCTL_SWITCH_SSID, adapterNum, sizeof(adapterNum));
  102.         switchTime = ioctlGetFromAdapter(IOCTL_GET_SWITCH_TIME, adapterNum, 
  103.             (DWORD)strlen(adapterNum), &tempSwitchTime, sizeof(ULONG));
  104.         VirtualWiFiNodes[j].timeToSwitchToNetwork = switchTime;
  105.         waitTime = ioctlGetFromAdapter(IOCTL_GET_WAIT_TIME, adapterNum, 
  106.             (DWORD)strlen(adapterNum), &tempWaitTime, sizeof(ULONG));
  107.         VirtualWiFiNodes[j].timeInNetwork = waitTime;
  108.         totalTimeToStay += waitTime;
  109.         sprintf(lpOutputString, "Network %d, switch time %d, wait time %d\n", j, switchTime, waitTime);
  110.         OutputDebugString(TEXT(lpOutputString));
  111.     }
  112.  
  113.     // Initialize for adaptive scheduling
  114.     if(adaptiveScheduling) {
  115.         for(j=0; j<numVirtualWiFiNodes; j++) {
  116.             for(k=0; k<adaptiveWindowSize; k++)
  117.                 VirtualWiFiNodes[j].bufferLengthHistory[k] = 0;
  118.             VirtualWiFiNodes[j].currentWindowPosition = 0;
  119.             VirtualWiFiNodes[j].totalPacketsOverWindow = 0;
  120.         }
  121.     }
  122.  
  123.     j = 0;
  124.     //adaptiveScheduling = 0;
  125.  
  126.     // Main Service Routine
  127.     // - Switch Card, send buffer messages, and coordinate with remote VirtualWiFi nodes
  128.     while(1) 
  129.     {
  130.         // char currentSSID[33];
  131.         char bufferLength[10];
  132.         double timeInNetwork = 0; // Used for adaptive Scheduling
  133.         int intTimeInNetwork = 0;
  134.         ULONG retVal = 0;
  135.  
  136.         dwWait = WaitForMultipleObjects( 2, hEvents, FALSE, 3 );
  137.         if ( dwWait == WAIT_OBJECT_0 ) {     // not overlapped i/o event - error occurred,
  138.             sprintf(lpOutputString, "Service break received in loop\n");
  139.             OutputDebugString(TEXT(lpOutputString));
  140.             break;                           // or server stop signaled
  141.         }   
  142.         // Switch the SSID
  143.         retVal = ioctlSet(IOCTL_SWITCH_SSID, adapterNum, sizeof(adapterNum));
  144.         //if(retVal == 1) continue;
  145.         if(j < MAX_VirtualWiFi_NODES) {
  146.             sprintf(lpOutputString, "j=%d, TTSN %ld\n", j, VirtualWiFiNodes[j].timeToSwitchToNetwork);
  147.             OutputDebugString(TEXT(lpOutputString));
  148.             SleepM(VirtualWiFiNodes[j].timeToSwitchToNetwork);
  149.             sprintf(lpOutputString, "VirtualWiFi connection %d active, totalTimeToStay %d\n", j, totalTimeToStay);
  150.             OutputDebugString(TEXT(lpOutputString));
  151.         }
  152.         // if the scheduling is adaptive, then get the buffer lengths
  153.         if(adaptiveScheduling) {
  154.             ULONG totalBufferedPackets = 0;
  155.             ULONG k;
  156.  
  157.             // Get the number of packets buffered on the current network
  158.             retVal = ioctlGetFromAdapter(IOCTL_GET_BUFFER_QUEUE_LENGTH, adapterNum, sizeof(adapterNum), bufferLength, 20);
  159.             //if(retVal == 1) continue;
  160.             // Reduce the oldest entry for the current network
  161.             if (j < MAX_VirtualWiFi_NODES) {
  162.                 VirtualWiFiNodes[j].totalPacketsOverWindow -= VirtualWiFiNodes[j].bufferLengthHistory[VirtualWiFiNodes[j].currentWindowPosition];
  163.                 sscanf(bufferLength, "%d", &VirtualWiFiNodes[j].bufferLengthHistory[VirtualWiFiNodes[j].currentWindowPosition]);
  164.                 VirtualWiFiNodes[j].totalPacketsOverWindow += VirtualWiFiNodes[j].bufferLengthHistory[VirtualWiFiNodes[j].currentWindowPosition];
  165.  
  166.                 for(k=0; k<numVirtualWiFiNodes; k++)
  167.                     totalBufferedPackets += VirtualWiFiNodes[k].totalPacketsOverWindow;
  168.     
  169.                 if(totalBufferedPackets != 0)
  170.                     timeInNetwork = VirtualWiFiNodes[j].totalPacketsOverWindow/(totalBufferedPackets*1.0)*totalTimeToStay;
  171.                 else 
  172.                     timeInNetwork = VirtualWiFiNodes[j].timeInNetwork/2;
  173.     
  174.                 if(timeInNetwork == 0)
  175.                     timeInNetwork = VirtualWiFiNodes[j].timeInNetwork;
  176.             }
  177.             if (j < MAX_VirtualWiFi_NODES) {
  178.                 sprintf(lpOutputString, "total buffered here %ld, overall %ld\n", 
  179.                     VirtualWiFiNodes[j].totalPacketsOverWindow, totalBufferedPackets);
  180.                 OutputDebugString(TEXT(lpOutputString));
  181.             
  182.                 intTimeInNetwork = (int)timeInNetwork;
  183.                 sprintf(lpOutputString, "time to stay in network %f and %d ms\n", timeInNetwork, intTimeInNetwork);
  184.                 OutputDebugString(TEXT(lpOutputString));
  185.  
  186.                 // we need to handle the buffer lengths. here we maintain it as a circular queue
  187.                 VirtualWiFiNodes[j].currentWindowPosition++;
  188.                 if(VirtualWiFiNodes[j].currentWindowPosition == adaptiveWindowSize)
  189.                     VirtualWiFiNodes[j].currentWindowPosition = 0;
  190.             }
  191.         }
  192.         
  193.         // Send the packets buffered on the current SSID
  194.         retVal = ioctlSet(IOCTL_SEND_BUFFERED_PACKETS, adapterNum, sizeof(adapterNum));
  195.         //if(retVal == 1) continue;
  196.  
  197.         // Stay in the network for the amount of time
  198.         if(adaptiveScheduling && intTimeInNetwork < 10000) {
  199.             sprintf(lpOutputString, "Sleeping for %d seconds\n", intTimeInNetwork);
  200.             OutputDebugString(TEXT(lpOutputString));
  201.             SleepM(intTimeInNetwork);
  202.         } else if (j < MAX_VirtualWiFi_NODES && VirtualWiFiNodes[j].timeInNetwork < 10000) {
  203.             sprintf(lpOutputString, "Sleeping for j %d seconds\n", VirtualWiFiNodes[j].timeInNetwork);
  204.             OutputDebugString(TEXT(lpOutputString));
  205.             SleepM(VirtualWiFiNodes[j].timeInNetwork);
  206.         }
  207.  
  208.         j++;
  209.         if(j>=numVirtualWiFiNodes)
  210.             j = 0;
  211.     }
  212.  
  213.     return;
  214. }
  215.  
  216.