Changeset 260

Show
Ignore:
Timestamp:
02/12/08 08:39:23 (10 years ago)
Author:
rsteenson
Message:

Create 2.01 branch containing deadlock
* When unloading the network packet dumper deadlock could occur
* Correctly exit the client if 7zip doesn't launch
* Server does not require any locking to send anymore

Location:
capture-hpc/tags/2.01
Files:
6 modified
1 copied

Legend:

Unmodified
Added
Removed
  • capture-hpc/tags/2.01/capture-client/Analyzer.cpp

    r217 r260  
    210210                &piProcessInfo); 
    211211 
    212         DWORD err = WaitForSingleObject( piProcessInfo.hProcess, INFINITE ); 
     212         
     213        if( created ) 
     214        { 
     215                DWORD err = WaitForSingleObject( piProcessInfo.hProcess, INFINITE ); 
     216        } 
     217        else 
     218        { 
     219                printf("Analyzer::compressLogDirectory 7zip failed to launch\n"); 
     220        } 
    213221 
    214222        //DebugPrint(L"Analyzer: compressLogDirectory - WaitForSingleObject = 0x%08x, CreateProcess=%i", err, created); 
     
    217225                printf("Analyzer: Cannot open 7za.exe process - 0x%08x\n", GetLastError()); 
    218226                printf("Log directory not compressed ... \n"); 
     227                exit(0); 
    219228                return false; 
    220229        } else { 
  • capture-hpc/tags/2.01/capture-client/CaptureClient.cpp

    r217 r260  
    101101                        } 
    102102                } 
    103                 SetEvent(hStopRunning); 
     103                running = false; 
     104                //SetEvent(hStopRunning); 
    104105        } 
    105106 
     
    114115                        if(OptionsManager::getInstance()->getOption(L"server") != L"") 
    115116                                printf("Disconnected from server: Exiting client\n"); 
    116                         SetEvent(hStopRunning); 
     117                        //SetEvent(hStopRunning); 
     118                        running = false; 
    117119                } 
    118120#endif 
     
    242244        } 
    243245 
     246        void update( float time ) 
     247        { 
     248                server->receiveData(); 
     249        } 
     250 
     251        static bool running; 
    244252        HANDLE hStopRunning; 
    245253private: 
     
    252260         
    253261}; 
     262 
     263bool CaptureClient::running = true; 
    254264 
    255265int _tmain(int argc, WCHAR* argv[]) 
     
    393403 
    394404        CaptureClient* cp = new CaptureClient(); 
    395         WaitForSingleObject(cp->hStopRunning, INFINITE); 
     405 
     406        while(CaptureClient::running) 
     407        { 
     408                cp->update(0.0f); 
     409                Sleep(10); 
     410        } 
     411 
     412        //WaitForSingleObject(cp->hStopRunning, INFINITE); 
    396413        delete cp; 
    397414        return 0; 
  • capture-hpc/tags/2.01/capture-client/NetworkAdapter.cpp

    r217 r260  
    88        running = false; 
    99 
    10  
     10        InitializeCriticalSection(&adapter_thread_lock); 
    1111         
    1212} 
     
    2222        if(!running) 
    2323        { 
     24                running = true; 
    2425                char* szLogFileName = new char[1024]; 
    2526                string logName = "logs\\"; 
     
    3334                char* t = (char*)threadName.c_str(); 
    3435                adapterThread->start(t); 
    35                 running = true; 
     36                 
    3637                delete [] szLogFileName; 
    3738        } 
     
    4344        if(running) 
    4445        { 
     46                // Set to false so the thread will exit 
     47                running = false; 
     48 
     49                // Wait for the thread to exit (by setting running to false) and delete 
     50                EnterCriticalSection(&adapter_thread_lock); 
     51                 
     52                // Once we are in the critical section we can be sure the thread has not got 
     53                // any handles to resources that we may deadlock on so now we can stop the thread 
     54                // if it hasn't alread 
    4555                adapterThread->stop(); 
    4656                delete adapterThread; 
     57 
    4758                if(dumpFile != NULL) 
     59                { 
     60                        // Close the dump file 
    4861                        networkPacketDumper->pfn_pcap_dump_close(dumpFile); 
    49                 //networkPacketDumper->pfn_pcap_close(adapter); 
    50                 running = false; 
     62                }        
     63 
     64                LeaveCriticalSection(&adapter_thread_lock); 
    5165        } 
    5266} 
     
    5872        struct pcap_pkthdr *header; 
    5973        const u_char *pkt_data; 
    60         while((res = networkPacketDumper->pfn_pcap_next_ex( adapter, &header, &pkt_data)) >= 0) 
    61         {      
    62         if(res > 0) 
    63                 { 
    64                         if(dumpFile != NULL) 
     74        EnterCriticalSection(&adapter_thread_lock); 
     75        while( running ) 
     76        { 
     77                if((res = networkPacketDumper->pfn_pcap_next_ex( adapter, &header, &pkt_data)) >= 0) 
     78                {      
     79                        if(res > 0) 
    6580                        { 
    66                                 networkPacketDumper->pfn_pcap_dump((unsigned char *) dumpFile, header, pkt_data); 
     81                                if(dumpFile != NULL) 
     82                                { 
     83                                        networkPacketDumper->pfn_pcap_dump((unsigned char *) dumpFile, header, pkt_data); 
     84                                } 
    6785                        } 
    6886                } 
    69         }        
     87        } 
     88        LeaveCriticalSection(&adapter_thread_lock); 
    7089} 
  • capture-hpc/tags/2.01/capture-client/NetworkAdapter.h

    r217 r260  
    6060        pcap_dumper_t *dumpFile; 
    6161        Thread* adapterThread; 
     62 
     63        CRITICAL_SECTION adapter_thread_lock; 
    6264}; 
  • capture-hpc/tags/2.01/capture-client/Server.cpp

    r217 r260  
    3333        port = p; 
    3434        connected = false; 
     35        server_thread = new Thread(this); 
     36        server_thread->start("s"); 
    3537        //serverSend = new ServerSend(this); 
    36         serverReceive = new ServerReceive(this); 
     38        //serverReceive = new ServerReceive(this); 
    3739} 
    3840 
     
    4042{ 
    4143        //delete serverSend; 
    42         delete serverReceive; 
     44        //delete serverReceive; 
    4345        WSACleanup(); 
    4446        disconnectFromServer(); 
     47        server_thread->stop(); 
     48        delete server_thread; 
    4549} 
    4650 
     
    7983                                if(startSenderAndReciever) 
    8084                                { 
    81                                         serverReceive->start(); 
     85                                        //serverReceive->start(); 
    8286                                } 
    8387                                freeaddrinfo(aiList); 
     
    105109                        char *szMessage = (char*)malloc(mbsize); 
    106110                        int bytes = WideCharToMultiByte(CP_UTF8, 0, message->c_str(), static_cast<int>(message->length()), szMessage, mbsize, NULL, NULL); 
    107                         result = send(serverSocket, szMessage, bytes, 0);                
     111                        result = send(serverSocket, szMessage, bytes, 0);        
    108112                        DebugPrint(L"Capture-Server-sendMessage: Allocated: %i, Converted: %i, Sent: %i\n", mbsize, bytes, result); 
    109113                        if(result == SOCKET_ERROR) 
     
    117121} 
    118122 
     123 
     124 
    119125void 
    120126Server::sendData(char* data, size_t length) 
     
    132138 
    133139void 
     140Server::run() 
     141{ 
     142        while(true) 
     143        { 
     144                if(!receiveQueue.empty()) 
     145                { 
     146                        string document = receiveQueue.front(); 
     147                        receiveQueue.pop(); 
     148                        EventController::getInstance()->receiveServerEvent(document.c_str()); 
     149                } else { 
     150                        Sleep(10); 
     151                } 
     152        } 
     153} 
     154 
     155void 
     156Server::receiveData() 
     157{ 
     158        fd_set receive_set; 
     159        timeval t; 
     160        FD_ZERO(&receive_set); 
     161        t.tv_usec = 10; 
     162        FD_SET(serverSocket, &receive_set); 
     163 
     164        if(select(0, &receive_set, NULL, NULL, &t) > 0) 
     165        { 
     166                if( FD_ISSET(serverSocket, &receive_set) ) 
     167                { 
     168                        char buffer[MAX_RECEIVE_BUFFER]; 
     169                        string xmlDocument = ""; 
     170                        int bytesRecv = 0; 
     171                        if((bytesRecv = recv(serverSocket, buffer, MAX_RECEIVE_BUFFER, 0)) > 2) 
     172                        { 
     173                                for(int i = 0; i < bytesRecv; i++) 
     174                                { 
     175                                        if(buffer[i] != '\0') 
     176                                        { 
     177                                                xmlDocument += buffer[i]; 
     178                                        } else { 
     179                                                printf("Got: %s\n", xmlDocument.c_str()); 
     180                                                DebugPrint(L"Capture-ServerReceiver: Received document - length: %i\n", xmlDocument.length()); 
     181                                                //EventController::getInstance()->receiveServerEvent(xmlDocument.c_str()); 
     182                                                receiveQueue.push(xmlDocument); 
     183                                                xmlDocument = ""; 
     184                                        } 
     185                                } 
     186                        } 
     187                } 
     188        } 
     189} 
     190 
     191void 
    134192Server::sendXMLElement(Element* pElement) 
    135193{ 
     
    138196                return; 
    139197        } 
    140         EnterCriticalSection(&sendQueueLock); 
     198        //EnterCriticalSection(&sendQueueLock); 
    141199        wstring xmlDocument = L"<"; 
    142200        xmlDocument += pElement->name; 
     
    164222                sendMessage(&xmlDocument); 
    165223        } 
    166         LeaveCriticalSection(&sendQueueLock); 
     224        //LeaveCriticalSection(&sendQueueLock); 
    167225         
    168226} 
     
    196254                return; 
    197255        } 
    198         EnterCriticalSection(&sendQueueLock); 
     256        //EnterCriticalSection(&sendQueueLock); 
    199257        wstring xmlDocument = L"<"; 
    200258        xmlDocument += elementName; 
     
    212270        xmlDocument += L"/>\r\n"; 
    213271        sendMessage(&xmlDocument); 
    214         LeaveCriticalSection(&sendQueueLock); 
     272        //LeaveCriticalSection(&sendQueueLock); 
    215273} 
    216274 
  • capture-hpc/tags/2.01/capture-client/Server.h

    r217 r260  
    2929 
    3030#include "CaptureGlobal.h" 
     31#include "Thread.h" 
    3132#include <string> 
    3233#include <queue> 
     
    5657        can exit gracefully and free all allocated memory. 
    5758*/ 
    58 class Server 
     59class Server : public Runnable 
    5960{ 
    6061        friend class ServerSend; 
     
    7576        bool isConnected(); 
    7677 
     78        void receiveData(); 
     79 
     80        void run(); 
    7781 
    7882        wstring getServerAddress() { return serverAddress; } 
     
    9195        CRITICAL_SECTION sendQueueLock; 
    9296        queue<wstring> sendQueue; 
     97        queue<string> receiveQueue; 
    9398        ServerSend* serverSend; 
    9499        ServerReceive* serverReceive; 
    95100         
    96101        signal_setConnected signalSetConnected; 
     102        Thread* server_thread; 
    97103protected: 
    98104        SOCKET getSocket() { return serverSocket; }