Skip to content
Snippets Groups Projects
Select Git revision
  • cd9b99eb8034b752a6c94da66a1a8ff964128f34
  • master default protected
  • fix_Makefile.mingw#2
  • update_Makefile.mingw
  • fix_Makefile.mingw
  • fix_API_for_C_apps
  • fix_procinfo_mac
  • boinccmd_gpu_mode_always_until_sigterm
  • fgrp_osx_hotfix
  • fix_boinc_master@f8250782
  • eah_wrapper_improvements
  • diagnostics_win-hotfix
  • diagnostics_win-hotfix-old
  • current_fgrp_apps
  • testing_gw_apps
  • gw_app_darwin_15
  • current_brp_apps
  • current_brp_apps_android10
  • current_gfx_apps
  • current_server
  • current_gw_apps
  • previous_fgrp_apps
  • previous_gw_apps
  • testing_brp_apps
  • apps_FGRP3_1.07
  • apps_FGRP3_1.08
26 results

AsyncRPC.cpp

Blame
  • AsyncRPC.cpp 41.63 KiB
    // This file is part of BOINC.
    // http://boinc.berkeley.edu
    // Copyright (C) 2013 University of California
    //
    // BOINC is free software; you can redistribute it and/or modify it
    // under the terms of the GNU Lesser General Public License
    // as published by the Free Software Foundation,
    // either version 3 of the License, or (at your option) any later version.
    //
    // BOINC is distributed in the hope that it will be useful,
    // but WITHOUT ANY WARRANTY; without even the implied warranty of
    // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
    // See the GNU Lesser General Public License for more details.
    //
    // You should have received a copy of the GNU Lesser General Public License
    // along with BOINC.  If not, see <http://www.gnu.org/licenses/>.
    
    #if defined(__GNUG__) && !defined(__APPLE__)
    #pragma implementation "AsyncRPC.h"
    #endif
    
    #if !(defined(_WIN32) || (defined(__WXMAC__) && (MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_4)))
    #include <xlocale.h>
    #endif
    
    #include "stdwx.h"
    #include "BOINCGUIApp.h"
    #include "MainDocument.h"
    #include "AsyncRPC.h"
    #include "BOINCBaseFrame.h"
    #include "BOINCTaskBar.h"
    #include "error_numbers.h"
    #include "SkinManager.h"
    #include "DlgEventLog.h"
    #include "util.h"
    
    extern bool s_bSkipExitConfirmation;
    
    // Delay in milliseconds before showing AsyncRPCDlg
    #define RPC_WAIT_DLG_DELAY 1500
    // How often to check for events when minimized and waiting for Demand RPC
    #define DELAY_WHEN_MINIMIZED 500
    // Delay in milliseconds to allow thread to exit before killing it
    #define RPC_KILL_DELAY 2000
    
    ASYNC_RPC_REQUEST::ASYNC_RPC_REQUEST() {
        clear();
    }
    
    
    ASYNC_RPC_REQUEST::~ASYNC_RPC_REQUEST() {
        clear();
    }
    
    
    void ASYNC_RPC_REQUEST::clear() {
        rpcType = (ASYNC_RPC_TYPE) 0;
        which_rpc = (RPC_SELECTOR) 0;
        exchangeBuf = NULL;
        arg1 = NULL;
        arg2 = NULL;
        arg3 = NULL;
        arg4 = NULL;
        completionTime = NULL;
        RPCExecutionTime = NULL;
        resultPtr = NULL;
        retval = 0;
        isActive = false;
    }
    
    
    bool ASYNC_RPC_REQUEST::isSameAs(ASYNC_RPC_REQUEST& otherRequest) {
        if (which_rpc != otherRequest.which_rpc) return false;
        if (arg1 != otherRequest.arg1) return false;
        if (exchangeBuf != otherRequest.exchangeBuf) return false;
        if (arg2 != otherRequest.arg2) return false;
        if (arg3 != otherRequest.arg3) return false;
        if (arg4 != otherRequest.arg4) return false;
        if (rpcType != otherRequest.rpcType) return false;
        if (completionTime != otherRequest.completionTime) return false;
        if (resultPtr != otherRequest.resultPtr) return false;
        // OK if isActive and retval don't match.
        return true;
    }
    
    
    AsyncRPC::AsyncRPC(CMainDocument *pDoc) {
        m_pDoc = pDoc;
    }
    
    
    AsyncRPC::~AsyncRPC() {}
    
    
    int AsyncRPC::RPC_Wait(RPC_SELECTOR which_rpc, void *arg1, void *arg2, 
        void *arg3, void *arg4, bool hasPriority
    ) {
        ASYNC_RPC_REQUEST request;
        int retval = 0;
    
        request.which_rpc = which_rpc;
        request.arg1 = arg1;
        request.arg2 = arg2;
        request.arg3 = arg3;
        request.arg4 = arg4;
        if (which_rpc == RPC_QUIT) {
            request.rpcType = RPC_TYPE_ASYNC_NO_REFRESH;
        } else {
            request.rpcType = RPC_TYPE_WAIT_FOR_COMPLETION;
        }
        request.RPCExecutionTime = NULL;
        retval = m_pDoc->RequestRPC(request, hasPriority);
        return retval;
    }
    
    
    RPCThread::RPCThread(CMainDocument *pDoc, 
                            BOINC_Mutex* pRPC_Thread_Mutex, 
                            BOINC_Condition* pRPC_Thread_Condition, 
                            BOINC_Mutex* pRPC_Request_Mutex, 
                            BOINC_Condition* pRPC_Request_Condition)
                            : wxThread() {
        m_pDoc = pDoc;
        m_pRPC_Thread_Mutex = pRPC_Thread_Mutex;
        m_pRPC_Thread_Condition = pRPC_Thread_Condition;
        m_pRPC_Request_Mutex = pRPC_Request_Mutex;
        m_pRPC_Request_Condition = pRPC_Request_Condition;
    }
    
    void *RPCThread::Entry() {
        int retval = 0;
        CRPCFinishedEvent RPC_done_event( wxEVT_RPC_FINISHED );
        ASYNC_RPC_REQUEST *current_request;
        double startTime = 0;
        wxMutexError mutexErr = wxMUTEX_NO_ERROR;
        wxCondError condErr = wxCOND_NO_ERROR;
    
    #ifndef NO_PER_THREAD_LOCALE
    #ifdef __WXMSW__
        // On Windows, set all locales for this thread on a per-thread basis
        _configthreadlocale(_ENABLE_PER_THREAD_LOCALE);
        setlocale(LC_ALL, "C");
    #else
        // We initialize RPC_Thread_Locale to fix a compiler warning
        locale_t RPC_Thread_Locale = LC_GLOBAL_LOCALE;
    #if defined(__APPLE__) && (MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_4)
        if (uselocale)    // uselocale() is not available in Mac OS 10.3.9
    #endif
        {
            // On Mac / Unix / Linux, set "C" locale for this thread only
            RPC_Thread_Locale = newlocale(LC_ALL_MASK, "C", NULL);
            uselocale(RPC_Thread_Locale);
        }
    #endif      // ifndef __WXMSW__
    #endif      // ifndef NO_PER_THREAD_LOCALE
       
        m_pRPC_Thread_Mutex->Lock();
        m_pDoc->m_bRPCThreadIsReady = true;
        while(true) {
            // Wait for main thread to wake us
            // This does the following:
            // (1) Unlocks the Mutex and puts the RPC thread to sleep as an atomic operation.
            // (2) On Signal from main thread: locks Mutex again and wakes the RPC thread.
            condErr = m_pRPC_Thread_Condition->Wait();
            wxASSERT(condErr == wxCOND_NO_ERROR);
            
            if (m_pDoc->m_bShutDownRPCThread) {
    #if !defined(NO_PER_THREAD_LOCALE) && !defined(__WXMSW__)
    #if defined(__APPLE__) && (MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_4)
            if (uselocale)    // uselocale() is not available in Mac OS 10.3.9
    #endif
            {
                uselocale(LC_GLOBAL_LOCALE);
                freelocale(RPC_Thread_Locale);
            }
    #endif
                m_pRPC_Thread_Mutex->Unlock();  // Just for safety - not really needed
                // Tell CMainDocument that thread has gracefully ended 
                // We do this here because OnExit() is not called on Windows
                m_pDoc->m_RPCThread = NULL;
                return 0;
            }
            
            current_request = m_pDoc->GetCurrentRPCRequest();
    
            if (!current_request->isActive)  continue;       // Should never happen
            
            if (current_request->RPCExecutionTime) {
                startTime = dtime();
            }
            retval = ProcessRPCRequest();
            if (current_request->RPCExecutionTime) {
                *(current_request->RPCExecutionTime) = dtime() - startTime;
            }
            
            current_request->retval = retval;
    
            mutexErr = m_pRPC_Request_Mutex->Lock();
            wxASSERT(mutexErr == wxMUTEX_NO_ERROR);
    
            current_request->isActive = false;
            wxPostEvent( wxTheApp, RPC_done_event );
    
            // Signal() is ignored / discarded unless the main thread is 
            // currently blocked by m_pRPC_Request_Condition->Wait[Timeout]()
            m_pRPC_Request_Condition->Signal();
            
            mutexErr = m_pRPC_Request_Mutex->Unlock();
            wxASSERT(mutexErr == wxMUTEX_NO_ERROR);
        }
    
        return NULL;
    }
    
    
    int RPCThread::ProcessRPCRequest() {
        int                     retval = 0;
        ASYNC_RPC_REQUEST       *current_request = m_pDoc->GetCurrentRPCRequest();
        
        switch (current_request->which_rpc) {
        // RPC_SELECTORS with no arguments
        case RPC_RUN_BENCHMARKS:
        case RPC_QUIT:
        case RPC_NETWORK_AVAILABLE:
        case RPC_PROJECT_ATTACH_FROM_FILE:
        case RPC_READ_GLOBAL_PREFS_OVERRIDE:
        case RPC_READ_CC_CONFIG:
            break;
        default:
            // All others must have at least one argument
            if (current_request->arg1 == NULL) {
                wxASSERT(false);
                return -1;
            }
            break;
        }
        switch (current_request->which_rpc) {
        case RPC_AUTHORIZE:
            retval = (m_pDoc->rpcClient).authorize((const char*)(current_request->arg1));
            break;
        case RPC_EXCHANGE_VERSIONS:
            retval = (m_pDoc->rpcClient).exchange_versions(*(VERSION_INFO*)(current_request->arg1));
            break;
        case RPC_GET_STATE:
            retval = (m_pDoc->rpcClient).get_state(*(CC_STATE*)(current_request->arg1));
            break;
        case RPC_GET_RESULTS:
            retval = (m_pDoc->rpcClient).get_results(*(RESULTS*)(current_request->arg1), *(bool*)(current_request->arg2));
            break;
        case RPC_GET_FILE_TRANSFERS:
            retval = (m_pDoc->rpcClient).get_file_transfers(*(FILE_TRANSFERS*)(current_request->arg1));
            break;
        case RPC_GET_SIMPLE_GUI_INFO1:
            retval = (m_pDoc->rpcClient).get_simple_gui_info(*(SIMPLE_GUI_INFO*)(current_request->arg1));
            break;
        case RPC_GET_SIMPLE_GUI_INFO2:
            // RPC_GET_SIMPLE_GUI_INFO2 is equivalent to doing both 
            // RPC_GET_PROJECT_STATUS1 and RPC_GET_RESULTS
            retval = (m_pDoc->rpcClient).get_results(*(RESULTS*)(current_request->arg3), *(bool*)(current_request->arg4));
            if (!retval) {
                retval = (m_pDoc->rpcClient).get_project_status(*(PROJECTS*)(current_request->arg1));
            }
            break;
        case RPC_GET_PROJECT_STATUS1:
            retval = (m_pDoc->rpcClient).get_project_status(*(PROJECTS*)(current_request->arg1));
            break;
        case RPC_GET_PROJECT_STATUS2:
            retval = (m_pDoc->rpcClient).get_project_status(*(PROJECTS*)(current_request->arg1));
            break;
        case RPC_GET_ALL_PROJECTS_LIST:
            retval = (m_pDoc->rpcClient).get_all_projects_list(*(ALL_PROJECTS_LIST*)(current_request->arg1));
            break;
        case RPC_GET_DISK_USAGE:
            retval = (m_pDoc->rpcClient).get_disk_usage(*(DISK_USAGE*)(current_request->arg1));
            break;
        case RPC_PROJECT_OP:
            retval = (m_pDoc->rpcClient).project_op(
                *(PROJECT*)(current_request->arg1), 
                (const char*)(current_request->arg2)
            );
            break;
        case RPC_SET_RUN_MODE:
            retval = (m_pDoc->rpcClient).set_run_mode(
                *(int*)(current_request->arg1), 
                *(double*)(current_request->arg2)
            );
            break;
        case RPC_SET_GPU_MODE:
            retval = (m_pDoc->rpcClient).set_gpu_mode(
                *(int*)(current_request->arg1), 
                *(double*)(current_request->arg2)
            );
            break;
        case RPC_SET_NETWORK_MODE:
            retval = (m_pDoc->rpcClient).set_network_mode(
                *(int*)(current_request->arg1),
                *(double*)(current_request->arg2)
            );
            break;
        case RPC_GET_SCREENSAVER_TASKS:
            retval = (m_pDoc->rpcClient).get_screensaver_tasks(
                *(int*)(current_request->arg1),
                *(RESULTS*)(current_request->arg2)
            );
            break;
        case RPC_RUN_BENCHMARKS:
            retval = (m_pDoc->rpcClient).run_benchmarks();
            break;
        case RPC_SET_PROXY_SETTINGS:
            retval = (m_pDoc->rpcClient).set_proxy_settings(*(GR_PROXY_INFO*)(current_request->arg1));
            break;
        case RPC_GET_PROXY_SETTINGS:
            retval = (m_pDoc->rpcClient).get_proxy_settings(*(GR_PROXY_INFO*)(current_request->arg1));
            break;
        case RPC_GET_NOTICES:
            retval = (m_pDoc->rpcClient).get_notices(
                *(int*)(current_request->arg1), 
                *(NOTICES*)(current_request->arg2)
            );
            break;
        case RPC_GET_MESSAGES:
            retval = (m_pDoc->rpcClient).get_messages(
                *(int*)(current_request->arg1), 
                *(MESSAGES*)(current_request->arg2),
                *(bool*)(current_request->arg3)
            );
            break;
        case RPC_FILE_TRANSFER_OP:
            retval = (m_pDoc->rpcClient).file_transfer_op(
                *(FILE_TRANSFER*)(current_request->arg1), 
                (const char*)(current_request->arg2)
            );
            break;
        case RPC_RESULT_OP:
            retval = (m_pDoc->rpcClient).result_op(
                *(RESULT*)(current_request->arg1),
                (const char*)(current_request->arg2)
            );
            break;
        case RPC_GET_HOST_INFO:
            retval = (m_pDoc->rpcClient).get_host_info(*(HOST_INFO*)(current_request->arg1));
            break;
        case RPC_QUIT:
            retval = (m_pDoc->rpcClient).quit();
            break;
        case RPC_ACCT_MGR_INFO:
            retval = (m_pDoc->rpcClient).acct_mgr_info(*(ACCT_MGR_INFO*)(current_request->arg1));
            break;
        case RPC_GET_STATISTICS:
            retval = (m_pDoc->rpcClient).get_statistics(*(PROJECTS*)(current_request->arg1));
            break;
        case RPC_NETWORK_AVAILABLE:
            retval = (m_pDoc->rpcClient).network_available();
            break;
        case RPC_GET_PROJECT_INIT_STATUS:
            retval = (m_pDoc->rpcClient).get_project_init_status(*(PROJECT_INIT_STATUS*)(current_request->arg1));
            break;
        case RPC_GET_PROJECT_CONFIG:
            retval = (m_pDoc->rpcClient).get_project_config(*(std::string*)(current_request->arg1));
            break;
        case RPC_GET_PROJECT_CONFIG_POLL:
            retval = (m_pDoc->rpcClient).get_project_config_poll(*(PROJECT_CONFIG*)(current_request->arg1));
            break;
        case RPC_LOOKUP_ACCOUNT:
            retval = (m_pDoc->rpcClient).lookup_account(*(ACCOUNT_IN*)(current_request->arg1));
            break;
        case RPC_LOOKUP_ACCOUNT_POLL:
            retval = (m_pDoc->rpcClient).lookup_account_poll(*(ACCOUNT_OUT*)(current_request->arg1));
            break;
        case RPC_CREATE_ACCOUNT:
            retval = (m_pDoc->rpcClient).create_account(*(ACCOUNT_IN*)(current_request->arg1));
            break;
        case RPC_CREATE_ACCOUNT_POLL:
            retval = (m_pDoc->rpcClient).create_account_poll(*(ACCOUNT_OUT*)(current_request->arg1));
            break;
        case RPC_PROJECT_ATTACH:
            retval = (m_pDoc->rpcClient).project_attach(
                (const char*)(current_request->arg1), 
                (const char*)(current_request->arg2), 
                (const char*)(current_request->arg3)
            );
            break;
        case RPC_PROJECT_ATTACH_FROM_FILE:
            retval = (m_pDoc->rpcClient).project_attach_from_file();
            break;
        case RPC_PROJECT_ATTACH_POLL:
            retval = (m_pDoc->rpcClient).project_attach_poll(*(PROJECT_ATTACH_REPLY*)(current_request->arg1));
            break;
        case RPC_ACCT_MGR_RPC:
            retval = (m_pDoc->rpcClient).acct_mgr_rpc(
                (const char*)(current_request->arg1), 
                (const char*)(current_request->arg2), 
                (const char*)(current_request->arg3),
                (bool)(current_request->arg4 != NULL)
            );
            break;
        case RPC_ACCT_MGR_RPC_POLL:
            retval = (m_pDoc->rpcClient).acct_mgr_rpc_poll(*(ACCT_MGR_RPC_REPLY*)(current_request->arg1));
            break;
        case RPC_GET_NEWER_VERSION:
            retval = (m_pDoc->rpcClient).get_newer_version(
                *(std::string*)(current_request->arg1),
                *(std::string*)(current_request->arg2)
            );
            break;
        case RPC_READ_GLOBAL_PREFS_OVERRIDE:
            retval = (m_pDoc->rpcClient).read_global_prefs_override();
            break;
        case RPC_READ_CC_CONFIG:
            retval = (m_pDoc->rpcClient).read_cc_config();
            break;
        case RPC_GET_CC_STATUS:
            retval = (m_pDoc->rpcClient).get_cc_status(*(CC_STATUS*)(current_request->arg1));
            break;
        case RPC_GET_GLOBAL_PREFS_FILE:
            retval = (m_pDoc->rpcClient).get_global_prefs_file(*(std::string*)(current_request->arg1));
            break;
        case RPC_GET_GLOBAL_PREFS_WORKING:
            retval = (m_pDoc->rpcClient).get_global_prefs_working(*(std::string*)(current_request->arg1));
            break;
        case RPC_GET_GLOBAL_PREFS_WORKING_STRUCT:
            retval = (m_pDoc->rpcClient).get_global_prefs_working_struct(
                *(GLOBAL_PREFS*)(current_request->arg1), 
                *(GLOBAL_PREFS_MASK*)(current_request->arg2)
            );
            break;
        case RPC_GET_GLOBAL_PREFS_OVERRIDE:
            retval = (m_pDoc->rpcClient).get_global_prefs_override(*(std::string*)(current_request->arg1));
            break;
        case RPC_SET_GLOBAL_PREFS_OVERRIDE:
             retval = (m_pDoc->rpcClient).set_global_prefs_override(*(std::string*)(current_request->arg1));
            break;
        case RPC_GET_GLOBAL_PREFS_OVERRIDE_STRUCT:
            retval = (m_pDoc->rpcClient).get_global_prefs_override_struct(
                *(GLOBAL_PREFS*)(current_request->arg1), 
                *(GLOBAL_PREFS_MASK*)(current_request->arg2)
            );
            break;
        case RPC_SET_GLOBAL_PREFS_OVERRIDE_STRUCT:
            retval = (m_pDoc->rpcClient).set_global_prefs_override_struct(
                *(GLOBAL_PREFS*)(current_request->arg1), 
                *(GLOBAL_PREFS_MASK*)(current_request->arg2)
            );
            break;
        case RPC_GET_CC_CONFIG:
             retval = (m_pDoc->rpcClient).get_cc_config(
                *(CC_CONFIG*)(current_request->arg1),
                *(LOG_FLAGS*)(current_request->arg2)
            );
            break;
        case RPC_SET_CC_CONFIG:
             retval = (m_pDoc->rpcClient).set_cc_config(
                *(CC_CONFIG*)(current_request->arg1),
                *(LOG_FLAGS*)(current_request->arg2)
            );
            break;
    	case RPC_SET_LANGUAGE:
    		retval = (m_pDoc->rpcClient).set_language(
    			(const char*)(current_request->arg1)
    		);
    		break;
        default:
            break;
        }
    
        return retval;
    }
    
    
    // TODO: combine RPC requests for different buffers, then just copy the buffer.
    
    int CMainDocument::RequestRPC(ASYNC_RPC_REQUEST& request, bool hasPriority) {
        std::vector<ASYNC_RPC_REQUEST>::iterator iter;
        int retval = 0;
        int response = wxID_OK;
        wxMutexError mutexErr = wxMUTEX_NO_ERROR;
        long delayTimeRemaining, timeToSleep;
        bool shown = false;
        
        if (!m_RPCThread) return -1;
    
        if ( (request.rpcType < RPC_TYPE_WAIT_FOR_COMPLETION) || 
                (request.rpcType >= NUM_RPC_TYPES) ) {
            wxASSERT(false);
            return -1;
        }
        
        // If we are quitting, cancel any pending RPCs
        if (request.which_rpc == RPC_QUIT) {
            if (current_rpc_request.isActive) {
                RPC_requests.erase(RPC_requests.begin()+1, RPC_requests.end());
    
            } else {
                RPC_requests.clear();
            }
        }
        
        // Check if a duplicate request is already on the queue
        for (iter=RPC_requests.begin(); iter!=RPC_requests.end(); ++iter) {
            if (iter->isSameAs(request)) {
                return 0;
            }
        }
    
        if ((request.rpcType == RPC_TYPE_WAIT_FOR_COMPLETION) && (request.resultPtr == NULL)) {
            request.resultPtr = &retval;
        }
        
        if (hasPriority) {
            // We may want to set hasPriority for some user-initiated events. 
            // Since the user is waiting, insert this at head of request queue.
            // As of 8/14/08, hasPriority is never set true, so hasn't been tested.
            iter = RPC_requests.insert(RPC_requests.begin(), request);
        } else {
               RPC_requests.push_back(request);
        }
        
        // Start this RPC if no other RPC is already in progress.
        if (RPC_requests.size() == 1) {
            // Wait for thread to unlock mutex with m_pRPC_Thread_Condition->Wait()
            mutexErr = m_pRPC_Thread_Mutex->Lock();  // Blocks until thread unlocks the mutex
            wxASSERT(mutexErr == wxMUTEX_NO_ERROR);
    
            // Make sure activation is an atomic operation
            request.isActive = false;
            current_rpc_request = request;
            current_rpc_request.isActive = true;
    
            m_pRPC_Thread_Condition->Signal();  // Unblock the thread
    
            // m_pRPC_Thread_Condition->Wait() will Lock() the mutex upon receiving Signal(), 
            // causing it to block again if we still have our lock on the mutex.
            mutexErr = m_pRPC_Thread_Mutex->Unlock();
            wxASSERT(mutexErr == wxMUTEX_NO_ERROR);
        }
    
        // If this is a user-initiated event wait for completion but show 
        // a dialog allowing the user to cancel.
        if (request.rpcType == RPC_TYPE_WAIT_FOR_COMPLETION) {
        // TODO: proper handling if a second user request is received while first is pending ??
            if (m_bWaitingForRPC) {
                wxLogMessage(wxT("Second user RPC request while another was pending"));
                wxASSERT(false);
                return -1;
            }
            // Don't show dialog if RPC completes before RPC_WAIT_DLG_DELAY
            // or while BOINC is minimized
            CBOINCBaseFrame* pFrame = wxGetApp().GetFrame();
            wxStopWatch Dlgdelay = wxStopWatch();        
            m_RPCWaitDlg = new AsyncRPCDlg();
            m_bWaitingForRPC = true;
            
            // Allow RPC_WAIT_DLG_DELAY seconds for Demand RPC to complete before 
            // displaying "Please Wait" dialog, but keep checking for completion.
            delayTimeRemaining = RPC_WAIT_DLG_DELAY;
            while (true) {
                if (delayTimeRemaining >= 0) {  // Prevent overflow if minimized for a very long time
                    delayTimeRemaining = RPC_WAIT_DLG_DELAY - Dlgdelay.Time();
                }
                
                if (pFrame) {
                    shown = pFrame->IsShown();
                } else {
                    shown = false;
                }
                
                if (shown) {
                    if (delayTimeRemaining <= 0) break; // Display the Please Wait dialog
                    timeToSleep = delayTimeRemaining;
                } else {
                    // Don't show dialog while Manager is minimized, but do 
                    // process events so user can maximize the manager. 
                    //
                    // NOTE: CBOINCGUIApp::FilterEvent() discards those events 
                    // which might cause posting of more RPC requests while 
                    // we are in this loop, to prevent undesirable recursion.
                    // Since the manager is minimized, we don't have to worry about 
                    // discarding crucial drawing or command events. 
                    // The filter does allow the the Open Manager menu item from 
                    // the system tray icon and wxEVT_RPC_FINISHED event. 
                    //
                    timeToSleep = DELAY_WHEN_MINIMIZED; // Allow user to maximize Manager
                    wxSafeYield(NULL, true);
                }
                
                // OnRPCComplete() clears m_bWaitingForRPC if RPC completed 
                if (! m_bWaitingForRPC) {
                    return retval;
                }
                
                mutexErr = m_pRPC_Request_Mutex->Lock();
                wxASSERT(mutexErr == wxMUTEX_NO_ERROR);
    
                // Simulate handling of CRPCFinishedEvent but don't allow any other 
                // events (so no user activity) to prevent undesirable recursion.
                // Since we don't need to filter and discard events, they remain on 
                // the queue until it is safe to process them.
                // Allow RPC thread to run while we wait for it.
                if (!current_rpc_request.isActive) {
                    mutexErr = m_pRPC_Request_Mutex->Unlock();
                    wxASSERT(mutexErr == wxMUTEX_NO_ERROR);
                    
                    HandleCompletedRPC();
                    continue;
                }
    
                // Wait for RPC thread to wake us
                // This does the following:
                // (1) Unlocks the Mutex and puts the main thread to sleep as an atomic operation.
                // (2) On Signal from RPC thread: locks Mutex again and wakes the main thread.
                m_pRPC_Request_Condition->WaitTimeout(timeToSleep);
    
                mutexErr = m_pRPC_Request_Mutex->Unlock();
                wxASSERT(mutexErr == wxMUTEX_NO_ERROR);
            }
            
            // Demand RPC has taken longer than RPC_WAIT_DLG_DELAY seconds and 
            // Manager is not minimized, so display the "Please Wait" dialog 
            // with a Cancel button.  If the RPC does complete while the dialog 
            // is up, HandleCompletedRPC() will call EndModal with wxID_OK.
            //
            // NOTE: the Modal dialog permits processing of all events, but 
            // CBOINCGUIApp::FilterEvent() blocks those events which might cause 
            // posting of more RPC requests while in this dialog, to prevent 
            // undesirable recursion.
            //
            if (m_RPCWaitDlg) {
                response = m_RPCWaitDlg->ShowModal();
                // Remember time the dialog was closed for use by RunPeriodicRPCs()
                m_dtLasAsyncRPCDlgTime = wxDateTime::Now();
                if (response != wxID_OK) {
                    // TODO: If user presses Cancel in Please Wait dialog but request 
                    // has not yet been started, should we just remove it from queue? 
                    // If we make that change, should we also add a separate menu item  
                    // to reset the RPC connection (or does one already exist)?
    
                    retval = -1;
                    // If the RPC continues to get data after we return to 
                    // our caller, it may try to write into a buffer or struct
                    // which the caller has already deleted.  To prevent this, 
                    // we close the socket (disconnect) and kill the RPC thread.
                    // This is ugly but necessary.  We must then reconnect and 
                    // start a new RPC thread.
                    if (current_rpc_request.isActive) {
                        current_rpc_request.isActive = false;
                        rpcClient.close();
                        RPC_requests.clear();
                        current_rpc_request.clear();
                        m_bNeedRefresh = false;
                        m_bNeedTaskBarRefresh = false;
    
                        // We will be reconnected to the same client (if possible) by 
                        // CBOINCDialUpManager::OnPoll() and CNetworkConnection::Poll().
                        m_pNetworkConnection->SetStateDisconnected();
                    }
                    if (response == wxID_EXIT) {
                        pFrame = wxGetApp().GetFrame();
                        wxCommandEvent evt(wxEVT_COMMAND_MENU_SELECTED, wxID_EXIT);
                        s_bSkipExitConfirmation = true;
                        pFrame->GetEventHandler()->AddPendingEvent(evt);
                    }
                }
                if (m_RPCWaitDlg) {
                    m_RPCWaitDlg->Destroy();
                }
                m_RPCWaitDlg = NULL;
                m_bWaitingForRPC = false;
            }
        }
        return retval;
    }
    
    
    void CMainDocument::KillRPCThread() {
        wxMutexError mutexErr = wxMUTEX_NO_ERROR;
        int i;
    
        if (!m_RPCThread) {
            return;
        }
    
        m_bNeedRefresh = false;
        m_bNeedTaskBarRefresh = false;
        
        rpcClient.close();  // Abort any async RPC in progress (in case hung)
       
        // On some platforms, Delete() takes effect only when thread calls TestDestroy()
        // Wait for thread to unlock mutex with m_pRPC_Thread_Condition->Wait()
        mutexErr = m_pRPC_Thread_Mutex->Lock();  // Blocks until thread unlocks the mutex
        wxASSERT(mutexErr == wxMUTEX_NO_ERROR);
    
        m_bShutDownRPCThread = true;
        m_pRPC_Thread_Condition->Signal();  // Unblock the thread
    
        mutexErr = m_pRPC_Thread_Mutex->Unlock(); // Release the mutex so thread can lock it
        wxASSERT(mutexErr == wxMUTEX_NO_ERROR);
    
        RPC_requests.clear();
        current_rpc_request.clear();
    
        // Wait up to RPC_KILL_DELAY milliseconds for thread to exit on its own
        for (i=0; i< RPC_KILL_DELAY; ++i) {
            boinc_sleep(.001);  // Defer to RPC thread for 1 millisecond
            if (!m_RPCThread) {
                return; // RPC thread sets m_RPCThread to NULL when it exits
            }
        }
        // Thread failed to exit, so forcefully kill it
        m_RPCThread->Kill();
    }
    
    
    void CMainDocument::OnRPCComplete(CRPCFinishedEvent&) {
        HandleCompletedRPC();
    }   
    
    
    void CMainDocument::HandleCompletedRPC() {
        int retval = 0;
        wxMutexError mutexErr = wxMUTEX_NO_ERROR;
        int i, n, requestIndex = -1;
        bool stillWaitingForPendingRequests = false;
        
        if (!m_RPCThread) return;
       
        if (current_rpc_request.isActive) return;
        
        // We can get here either via a CRPCFinishedEvent event posted 
        // by the RPC thread or by a call from RequestRPC.  If we were 
        // called from RequestRPC, the CRPCFinishedEvent will still be 
        // on the event queue, so we get called twice.  Check for this here.
        if (current_rpc_request.which_rpc == 0) return; // already handled by a call from RequestRPC
    
        // Find our completed request in the queue
        n = (int) RPC_requests.size();
        for (i=0; i<n; ++i) {
            if (RPC_requests[i].isSameAs(current_rpc_request)) {
                requestIndex = i;
            } else {
                if (RPC_requests[i].rpcType == RPC_TYPE_WAIT_FOR_COMPLETION) {
                    stillWaitingForPendingRequests = true;
                }
            }
        }
        
        if (! stillWaitingForPendingRequests) {
            if (m_RPCWaitDlg) {
                if (m_RPCWaitDlg->IsShown()) {
                    m_RPCWaitDlg->EndModal(wxID_OK);
                }
                    m_RPCWaitDlg->Destroy();
                    m_RPCWaitDlg = NULL;
            }
            m_bWaitingForRPC = false;
        }
    
        if (requestIndex >= 0) {
            // Remove completed request from the queue
            RPC_requests.erase(RPC_requests.begin()+requestIndex);
        }
        
        retval = current_rpc_request.retval;
    
        
        if (current_rpc_request.completionTime) {
            *(current_rpc_request.completionTime) = wxDateTime::Now();
        }
        
        if (current_rpc_request.resultPtr) {
            *(current_rpc_request.resultPtr) = retval;
        }
        
        // Post-processing
        if (! retval) {
             if (current_rpc_request.rpcType == RPC_TYPE_ASYNC_WITH_REFRESH_AFTER) {
                if (!retval) {
                    m_bNeedRefresh = true;
                }
            }
        
             if (current_rpc_request.rpcType == RPC_TYPE_ASYNC_WITH_UPDATE_TASKBAR_ICON_AFTER) {
                if (!retval) {
                    m_bNeedTaskBarRefresh = true;
                }
            }
        
           switch (current_rpc_request.which_rpc) {
            case RPC_GET_STATE:
                if (current_rpc_request.exchangeBuf && !retval) {
                    CC_STATE* arg1 = (CC_STATE*)current_rpc_request.arg1;
                    CC_STATE* exchangeBuf = (CC_STATE*)current_rpc_request.exchangeBuf;
                    arg1->projects.swap(exchangeBuf->projects);
                    arg1->apps.swap(exchangeBuf->apps);
                    arg1->app_versions.swap(exchangeBuf->app_versions);
                    arg1->wus.swap(exchangeBuf->wus);
                    arg1->results.swap(exchangeBuf->results);
                    exchangeBuf->global_prefs = arg1->global_prefs;
                    exchangeBuf->version_info = arg1->version_info;
                    exchangeBuf->executing_as_daemon = arg1->executing_as_daemon;
                    exchangeBuf->host_info = arg1->host_info;
                    exchangeBuf->time_stats = arg1->time_stats;
                    exchangeBuf->have_nvidia = arg1->have_nvidia;
                    exchangeBuf->have_ati = arg1->have_ati;
                }
                break;
            case RPC_GET_RESULTS:
                if (current_rpc_request.exchangeBuf && !retval) {
                    RESULTS* arg1 = (RESULTS*)current_rpc_request.arg1;
                    RESULTS* exchangeBuf = (RESULTS*)current_rpc_request.exchangeBuf;
                    arg1->results.swap(exchangeBuf->results);
                }
                break;
            case RPC_GET_FILE_TRANSFERS:
                if (current_rpc_request.exchangeBuf && !retval) {
                    FILE_TRANSFERS* arg1 = (FILE_TRANSFERS*)current_rpc_request.arg1;
                    FILE_TRANSFERS* exchangeBuf = (FILE_TRANSFERS*)current_rpc_request.exchangeBuf;
                    arg1->file_transfers.swap(exchangeBuf->file_transfers);
                }
                break;
            case RPC_GET_SIMPLE_GUI_INFO2:
                if (!retval) {
                    retval = CopyProjectsToStateBuffer(*(PROJECTS*)(current_rpc_request.arg1), *(CC_STATE*)(current_rpc_request.arg2));
                }
                if (current_rpc_request.exchangeBuf && !retval) {
                    RESULTS* arg3 = (RESULTS*)current_rpc_request.arg3;
                    RESULTS* exchangeBuf = (RESULTS*)current_rpc_request.exchangeBuf;
                    arg3->results.swap(exchangeBuf->results);
                }
                break;
            case RPC_GET_PROJECT_STATUS1:
                if (!retval) {
                    retval = CopyProjectsToStateBuffer(*(PROJECTS*)(current_rpc_request.arg1), *(CC_STATE*)(current_rpc_request.arg2));
                }
                break;
            case RPC_GET_ALL_PROJECTS_LIST:
                if (current_rpc_request.exchangeBuf && !retval) {
                    ALL_PROJECTS_LIST* arg1 = (ALL_PROJECTS_LIST*)current_rpc_request.arg1;
                    ALL_PROJECTS_LIST* exchangeBuf = (ALL_PROJECTS_LIST*)current_rpc_request.exchangeBuf;
                    arg1->projects.swap(exchangeBuf->projects);
                }
                break;
            case RPC_GET_DISK_USAGE:
                if (current_rpc_request.exchangeBuf && !retval) {
                    DISK_USAGE* arg1 = (DISK_USAGE*)current_rpc_request.arg1;
                    DISK_USAGE* exchangeBuf = (DISK_USAGE*)current_rpc_request.exchangeBuf;
                    arg1->projects.swap(exchangeBuf->projects);
                    exchangeBuf->d_total = arg1->d_total;
                    exchangeBuf->d_free = arg1->d_free;
                    exchangeBuf->d_boinc = arg1->d_boinc;
                    exchangeBuf->d_allowed = arg1->d_allowed;
                }
                break;
            case RPC_GET_NOTICES:
                if (current_rpc_request.exchangeBuf && !retval) {
                    NOTICES* arg2 = (NOTICES*)current_rpc_request.arg2;
                    NOTICES* exchangeBuf = (NOTICES*)current_rpc_request.exchangeBuf;
                    arg2->notices.swap(exchangeBuf->notices);
                }
                if (!retval) {
                    CachedNoticeUpdate();  // Call this only when notice buffer is stable
                }
                m_bWaitingForGetNoticesRPC = false;
                break;
            case RPC_GET_MESSAGES:
                if (current_rpc_request.exchangeBuf && !retval) {
                    MESSAGES* arg2 = (MESSAGES*)current_rpc_request.arg2;
                    MESSAGES* exchangeBuf = (MESSAGES*)current_rpc_request.exchangeBuf;
                    arg2->messages.swap(exchangeBuf->messages);
                }
                if (!retval) {
                    CachedMessageUpdate();  // Call this only when message buffer is stable
                }
                break;
            case RPC_GET_HOST_INFO:
                if (current_rpc_request.exchangeBuf && !retval) {
                    HOST_INFO* arg1 = (HOST_INFO*)current_rpc_request.arg1;
                    HOST_INFO* exchangeBuf = (HOST_INFO*)current_rpc_request.exchangeBuf;
                    *exchangeBuf = *arg1;
                }
                break;
            case RPC_GET_STATISTICS:
                if (current_rpc_request.exchangeBuf && !retval) {
                    PROJECTS* arg1 = (PROJECTS*)current_rpc_request.arg1;
                    PROJECTS* exchangeBuf = (PROJECTS*)current_rpc_request.exchangeBuf;
                    arg1->projects.swap(exchangeBuf->projects);
                }
                break;
                
            case RPC_GET_CC_STATUS:
                if (current_rpc_request.exchangeBuf && !retval) {
                    CC_STATUS* arg1 = (CC_STATUS*)current_rpc_request.arg1;
                    CC_STATUS* exchangeBuf = (CC_STATUS*)current_rpc_request.exchangeBuf;
                    *exchangeBuf = *arg1;
                }
                break;
            case RPC_ACCT_MGR_INFO:
                if (current_rpc_request.exchangeBuf && !retval) {
                    ACCT_MGR_INFO* arg1 = (ACCT_MGR_INFO*)current_rpc_request.arg1;
                    ACCT_MGR_INFO* exchangeBuf = (ACCT_MGR_INFO*)current_rpc_request.exchangeBuf;
                    *exchangeBuf = *arg1;
               }
                break;
            default:
                // We don't support double buffering for other RPC calls 
                wxASSERT(current_rpc_request.exchangeBuf == NULL);
                break;
            }
        }
        
        if (current_rpc_request.resultPtr) {
            // In case post-processing changed retval
            *(current_rpc_request.resultPtr) = retval;
        }
    
        // We must call ProcessEvent() rather than AddPendingEvent() here to 
        // guarantee integrity of data when other events are handled (such as 
        // Abort, Suspend/Resume, Show Graphics, Update, Detach, Reset, No 
        // New Work, etc.)  Otherwise, if one of those events is pending it 
        // might be processed first, and the data in the selected rows may not 
        // match the data which the user selected if any rows were added or 
        // deleted due to the RPC.  
        // The refresh event called here adjusts the selections to fix any 
        // such mismatch before other pending events are processed.  
        //
        // However, the refresh code may itself request a Demand RPC, which 
        // would cause undesirable recursion if we are already waiting for 
        // another Demand RPC to complete.  In that case, we defer the refresh 
        // until all pending Demand RPCs have been done.
        //
        if (m_bNeedRefresh && !m_bWaitingForRPC) {
            m_bNeedRefresh = false;
            // We must get the frame immediately before using it, 
            // since it may have been changed by SetActiveGUI().
            CBOINCBaseFrame* pFrame = wxGetApp().GetFrame();
            if (pFrame) {
                CFrameEvent event(wxEVT_FRAME_REFRESHVIEW, pFrame);
                pFrame->GetEventHandler()->ProcessEvent(event);
            }
        }
    
        if (m_bNeedTaskBarRefresh && !m_bWaitingForRPC) {
            m_bNeedTaskBarRefresh = false;
            CTaskBarIcon* pTaskbar = wxGetApp().GetTaskBarIcon();
            if (pTaskbar) {
                CTaskbarEvent event(wxEVT_TASKBAR_REFRESH, pTaskbar);
                pTaskbar->ProcessEvent(event);
            }
        }
    
        if (current_rpc_request.rpcType == RPC_TYPE_ASYNC_WITH_REFRESH_EVENT_LOG_AFTER) {
            CDlgEventLog* eventLog = wxGetApp().GetEventLog();
            if (eventLog) {
                eventLog->OnRefresh();
            }
        }
        
        current_rpc_request.clear();
    
        // Start the next RPC request.  
        // We can't start this until finished processing the previous RPC's 
        // event because the two requests may write into the same buffer.
        if (RPC_requests.size() > 0) {
            // Wait for thread to unlock mutex with m_pRPC_Thread_Condition->Wait()
            mutexErr = m_pRPC_Thread_Mutex->Lock();  // Blocks until thread unlocks the mutex
            wxASSERT(mutexErr == wxMUTEX_NO_ERROR);
    
            // Make sure activation is an atomic operation
            RPC_requests[0].isActive = false;
            current_rpc_request = RPC_requests[0];
            current_rpc_request.isActive = true;
    
            m_pRPC_Thread_Condition->Signal();  // Unblock the thread
    
            // m_pRPC_Thread_Condition->Wait() will Lock() the mutex upon receiving Signal(), 
            // causing it to block again if we still have our lock on the mutex.
            mutexErr = m_pRPC_Thread_Mutex->Unlock();
            wxASSERT(mutexErr == wxMUTEX_NO_ERROR);
        }
    }
    
    
    int CMainDocument::CopyProjectsToStateBuffer(PROJECTS& p, CC_STATE& ccstate) {
        int retval = 0;
        unsigned int i;
        PROJECT* state_project = NULL;
    
        // flag for delete
        for (i=0; i<ccstate.projects.size(); i++) {
            state_project = ccstate.projects[i];
            state_project->flag_for_delete = true;
        }
    
        for (i=0; i<p.projects.size(); i++) {
            state_project = ccstate.lookup_project(p.projects[i]->master_url);
            if (state_project && (!strcmp(p.projects[i]->master_url, state_project->master_url))) {
                // Because the CC_STATE contains several pointers to each element of the 
                // CC_STATE::projects vector, we must update these elements in place.
                *state_project = *(p.projects[i]);
                state_project->flag_for_delete = false;
            } else {
                retval = ERR_NOT_FOUND;
            }
            continue;
        }
    
        // Anything need to be deleted?
        if (!retval) {
            for (i=0; i<ccstate.projects.size(); i++) {
                state_project = ccstate.projects[i];
                if (state_project->flag_for_delete) {
                    retval = ERR_FILE_MISSING;
                }
            }
        }
        
        return retval;
    }
    
    
    BEGIN_EVENT_TABLE(AsyncRPCDlg, wxDialog)
        EVT_BUTTON(wxID_EXIT, AsyncRPCDlg::OnExit)
    END_EVENT_TABLE()
    
    IMPLEMENT_CLASS(AsyncRPCDlg, wxDialog)
    
    AsyncRPCDlg::AsyncRPCDlg() : wxDialog( NULL, wxID_ANY, wxT(""), wxDefaultPosition ) {
        CSkinAdvanced*  pSkinAdvanced = wxGetApp().GetSkinManager()->GetAdvanced();
        wxString exit_label;
        wxASSERT(pSkinAdvanced);
    
        wxString message = wxString(_("Communicating with BOINC client.  Please wait ..."));
        
    #ifdef __WXMAC__
        exit_label.Printf(_("&Quit %s"), pSkinAdvanced->GetApplicationName().c_str());
    #else
        exit_label.Printf(_("E&xit %s"), pSkinAdvanced->GetApplicationName().c_str());
    #endif
    
        wxString strCaption;
        strCaption.Printf(_("%s - Communication"), pSkinAdvanced->GetApplicationName().c_str());
        SetTitle(strCaption.c_str());
    
        wxBoxSizer *topsizer = new wxBoxSizer( wxVERTICAL );
        wxBoxSizer *icon_text = new wxBoxSizer( wxHORIZONTAL );
    
        icon_text->Add( CreateTextSizer( message ), 0, wxALIGN_CENTER | wxLEFT, 10 );
        topsizer->Add( icon_text, 1, wxCENTER | wxLEFT|wxRIGHT|wxTOP, 10 );
        
        wxStdDialogButtonSizer *sizerBtn = CreateStdDialogButtonSizer(0);
        
        wxButton* exitbutton = new wxButton;
        exitbutton->Create( this, wxID_EXIT, exit_label, wxDefaultPosition, wxDefaultSize, 0 );
        sizerBtn->Add(exitbutton, 0, wxLEFT|wxRIGHT|wxALL, 5);
    
        wxButton* cancelbutton = new wxButton;
        cancelbutton->Create( this, wxID_CANCEL, _("Cancel"), wxDefaultPosition, wxDefaultSize, 0 );
        sizerBtn->Add(cancelbutton, 0, wxLEFT|wxRIGHT|wxALL, 5);
        
        if ( sizerBtn )
            topsizer->Add(sizerBtn, 0, wxEXPAND | wxALL, 10 );
    
        SetAutoLayout( true );
        SetSizer( topsizer );
    
        topsizer->SetSizeHints( this );
        topsizer->Fit( this );
        wxSize size( GetSize() );
        if (size.x < size.y*3/2)
        {
            size.x = size.y*3/2;
            SetSize( size );
        }
    
        Centre( wxBOTH | wxCENTER_FRAME);
    }
    
    
    void AsyncRPCDlg::OnExit(wxCommandEvent& WXUNUSED(eventUnused)) {
        EndModal(wxID_EXIT);
    }
    
    
    #if 0
    
    /// For testing: triggered by Advanced / Options menu item.
    void CMainDocument::TestAsyncRPC() {
        ALL_PROJECTS_LIST pl;
        ASYNC_RPC_REQUEST request;
        wxDateTime completionTime = wxDateTime((time_t)0);
        int req_retval = 0, rpc_result = 0;
    
        completionTime.ResetTime();
    
        request.which_rpc = RPC_GET_ALL_PROJECTS_LIST;
        request.arg1 = &pl;
        request.exchangeBuf = NULL;
        request.arg2 = NULL;
        request.arg3 = NULL;
        request.arg4 = NULL;
        request.rpcType = RPC_TYPE_WAIT_FOR_COMPLETION;
        request.completionTime = &completionTime;
    //    request.result = NULL;
        request.resultPtr = &rpc_result;        // For testing async RPCs
        request.isActive = false;
        
    //retval = rpcClient.get_all_projects_list(pl);
    
        req_retval = RequestRPC(request, true);
    
        wxString s = FormatTime();
        wxLogMessage(wxT("Completion time = %s"), s.c_str());
        wxLogMessage(wxT("RequestRPC returned %d\n"), req_retval);
        ::wxSafeYield(NULL, true);  // Allow processing of RPC_FINISHED event
        wxLogMessage(wxT("rpcClient.get_all_projects_list returned %d\n"), rpc_result);
    }
    
    #endif