diff options
Diffstat (limited to 'utils/vmpi')
183 files changed, 32136 insertions, 0 deletions
diff --git a/utils/vmpi/IThreadedTCPSocket.h b/utils/vmpi/IThreadedTCPSocket.h new file mode 100644 index 0000000..904dc7f --- /dev/null +++ b/utils/vmpi/IThreadedTCPSocket.h @@ -0,0 +1,173 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#ifndef ITHREADEDTCPSOCKET_H +#define ITHREADEDTCPSOCKET_H +#ifdef _WIN32 +#pragma once +#endif + + +#include "iphelpers.h" + + +class IThreadedTCPSocket; + + +class CTCPPacket +{ +public: + // Access the contents of the packet. + const char* GetData() const; + int GetLen() const; + + // You can attach some user data to the packet. + int GetUserData() const; + void SetUserData( int userData ); + + // Free resources associated with the packet. + void Release(); + +public: + friend class CThreadedTCPSocket; + ~CTCPPacket(); // Use Release(), not delete. + + int m_UserData; + int m_Len; + char m_Data[1]; +}; + + +inline const char* CTCPPacket::GetData() const +{ + return m_Data; +} + + +inline int CTCPPacket::GetLen() const +{ + return m_Len; +} + + +// The application implements this to handle packets that are received. +// Note that the implementation must be thread-safe because these functions can be called +// from various threads. +class ITCPSocketHandler +{ +public: + + enum + { + SocketError=0, + ConnectionTimedOut + }; + + // This is called right when the socket becomes ready to have data sent through it and + // before OnPacketReceive is ever called. + virtual void Init( IThreadedTCPSocket *pSocket ) = 0; + + // This is called when a packet arrives. NOTE: you are responsible for freeing the packet + // by calling CTCPPacket::Release() on it. + virtual void OnPacketReceived( CTCPPacket *pPacket ) = 0; + + // Handle errors inside the socket. After this is called, the socket is no longer alive. + // Note: this might be called from ANY thread (the main thread, the send thread, or the receive thread). + // + // errorCode is one of the enums above (SocketError, ConnectionTimedOut, etc). + virtual void OnError( int errorCode, const char *pErrorString ) = 0; +}; + + +// +// This is the main threaded TCP socket class. +// The way these work is that they have a thread for sending and a thread for receiving data. +// +// The send thread is continually pushing your data out the door. +// +// The receive thread is continually receiving data. When it receives data, it calls your HandlePacketFn +// to allow the user to handle it. Be very careful in your HandlePacketFn, since it is in another thread. +// Anything it accesses should be protected by mutexes and the like. +// +class IThreadedTCPSocket +{ +public: + // Cleanup everything and exit. + // Note: if the receive thread is inside your HandlePacketFn returns, this function blocks until that function returns. + virtual void Release() = 0; + + // Returns the address of whoever you are connected to. + virtual CIPAddr GetRemoteAddr() const = 0; + + // Returns true if the socket is connected and ready to go. If this returns false, then the socket won't + // send or receive data any more. It also means that your ITCPSocketHandler's OnError function has been called. + virtual bool IsValid() = 0; + + // Send data. Any thread can call these functions, and they don't block. They make a copy of the data, then + // enqueue it for sending. + virtual bool Send( const void *pData, int len ) = 0; + virtual bool SendChunks( void const * const *pChunks, const int *pChunkLengths, int nChunks ) = 0; +}; + + + +// Use these to get incoming connections. +class ITCPConnectSocket +{ +public: + // Call this to stop listening for connections and delete the object. + virtual void Release() = 0; + + // Keep calling this as long as you want to wait for connections. + // + // If it returns true and pSocket is NULL, it means it hasn't connected yet. + // If it returns true and pSocket is non-NULL, then it has connected. + // If it returns false, then the connection attempt failed and all further Update() calls will return false. + virtual bool Update( IThreadedTCPSocket **pSocket, unsigned long milliseconds=0 ) = 0; +}; + + +// This class is implemented by the app and passed into CreateListener. When the listener makes +// a new connection, it calls CreateNewHandler() to have the app create something that will handle +// the received packets and errors for the new socket. +class IHandlerCreator +{ +public: + // This function must return a valid value. + virtual ITCPSocketHandler* CreateNewHandler() = 0; +}; + + +// Use this to listen for TCP connections. The ITCPConnectSocket will keep returning connections +// until you call Release(). +ITCPConnectSocket* ThreadedTCP_CreateListener( + IHandlerCreator *pHandlerCreator, // This handles messages from the socket. + const unsigned short port, // Listen on this port. + int nQueueLength = 5 // How many connections + ); + + +// Use this to connect to a remote process. After Update() returns a non-NULL value, you should +// call Release() on the ITCPConnectSocket because it won't ever return another connection. +ITCPConnectSocket* ThreadedTCP_CreateConnector( + const CIPAddr &addr, // Who to connect to. + const CIPAddr &localAddr, // Local address to bind to. Leave uninitialized (pass in CIPAddr()) and it will + // an interface and a port for you. You can also just fill in the port, and it will + // use that port and choose an interface for you. + IHandlerCreator *pHandlerCreator// If it connects, it asks this thing to make a handler for the connection. + ); + + +// Enable or disable timeouts. +void ThreadedTCP_EnableTimeouts( bool bEnable ); + +// This should be called at init time. If set to true, it'll set the send and recv threads to low priority. +// (Default is true). +void ThreadedTCP_SetTCPSocketThreadPriorities( bool bSetTCPSocketThreadPriorities ); + + +#endif // ITHREADEDTCPSOCKET_H diff --git a/utils/vmpi/ThreadedTCPSocket.cpp b/utils/vmpi/ThreadedTCPSocket.cpp new file mode 100644 index 0000000..444e22b --- /dev/null +++ b/utils/vmpi/ThreadedTCPSocket.cpp @@ -0,0 +1,1085 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// ThreadedTCPSocket.cpp : Defines the entry point for the console application. +// + +#include <winsock2.h> +#include <mswsock.h> +#include "IThreadedTCPSocket.h" +#include "utllinkedlist.h" +#include "threadhelpers.h" +#include "iphelpers.h" +#include "tier1/strtools.h" + + +#define SEND_KEEPALIVE_INTERVAL 3000 +#define KEEPALIVE_TIMEOUT 25000 // The sockets timeout after this long. + +#define KEEPALIVE_SENTINEL -12345 // When first 4 bytes of a packet = this, then it's just a keepalive. + + +static int g_KeepaliveSentinel = KEEPALIVE_SENTINEL; +bool g_bHandleTimeouts = true; + +// If true, it'll set the socket thread priorities lower than normal. +bool g_bSetTCPSocketThreadPriorities = true; + +// We get crashes at runtime if they don't link in the multithreaded runtime libraries, +// so raise a ruckus if they're using singlethreaded libraries. +#ifndef _MT + #pragma message( "**** WARNING **** ThreadedTCPSocket requires multithreaded runtime libraries to be used.\n" ) + class MTChecker + { + public: + MTChecker() { Assert( false ); } + } g_MTChecker; +#endif + + + +// ------------------------------------------------------------------------------------------------ // +// Static helpers. +// ------------------------------------------------------------------------------------------------ // +static SOCKET TCPBind( const CIPAddr *pAddr ) +{ + // Create a socket to send and receive through. + SOCKET sock = WSASocket( AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED ); + if ( sock == INVALID_SOCKET ) + { + Assert( false ); + return INVALID_SOCKET; + } + + // bind to it! + sockaddr_in addr; + IPAddrToSockAddr( pAddr, &addr ); + + int status = bind( sock, (sockaddr*)&addr, sizeof(addr) ); + if ( status == 0 ) + { + return sock; + } + else + { + closesocket( sock ); + return INVALID_SOCKET; + } +} + + + +// ------------------------------------------------------------------------------------------------ // +// CTCPPacket. +// ------------------------------------------------------------------------------------------------ // + +int CTCPPacket::GetUserData() const +{ + return m_UserData; +} + +void CTCPPacket::SetUserData( int userData ) +{ + m_UserData = userData; +} + +void CTCPPacket::Release() +{ + free( this ); +} + + +// ------------------------------------------------------------------------------------------------ // +// CThreadedTCPSocket. +// ------------------------------------------------------------------------------------------------ // +class CThreadedTCPSocket : public IThreadedTCPSocket +{ +public: + + static IThreadedTCPSocket* Create( SOCKET iSocket, CIPAddr remoteAddr, ITCPSocketHandler *pHandler ) + { + CThreadedTCPSocket *pRet = new CThreadedTCPSocket; + if ( pRet->Init( iSocket, remoteAddr, pHandler ) ) + { + return pRet; + } + else + { + pRet->Release(); + return NULL; + } + } + + +// IThreadedTCPSocket implementation. +public: + + virtual void Release() + { + delete this; + } + + virtual CIPAddr GetRemoteAddr() const + { + return m_RemoteAddr; + } + + virtual bool IsValid() + { + return !CheckErrorSignal(); + } + + virtual bool Send( const void *pData, int len ) + { + const void *pChunks[1] = { pData }; + return SendChunks( pChunks, &len, 1 ); + } + + virtual bool SendChunks( void const * const *pChunks, const int *pChunkLengths, int nChunks ) + { + if ( CheckErrorSignal() ) + return false; + + return InternalSend( pChunks, pChunkLengths, nChunks, true ); + } + + +// Initialization. +private: + + CThreadedTCPSocket() + { + m_Socket = INVALID_SOCKET; + m_pHandler = NULL; + memset( &m_SendOverlapped, 0, sizeof( m_SendOverlapped ) ); + memset( &m_RecvOverlapped, 0, sizeof( m_RecvOverlapped ) ); + m_bWaitingForSendCompletion = false; + m_nBytesToReceive = -1; + m_bWaitingForSize = false; + m_bErrorSignal = false; + m_pRecvBuffer = NULL; + } + + virtual ~CThreadedTCPSocket() + { + Term(); + } + + bool Init( SOCKET iSocket, CIPAddr remoteAddr, ITCPSocketHandler *pHandler ) + { + m_Socket = iSocket; + m_RemoteAddr = remoteAddr; + m_pHandler = pHandler; + + SetInitialSocketOptions(); + + // Create all the event objects we'll use to communicate. + m_hExitThreadsEvent.Init( true, false ); + m_hSendCompletionEvent.Init( false, false ); + m_hReadyToSendEvent.Init( false, false ); + m_hRecvEvent.Init( false, false ); + + m_SendOverlapped.hEvent = m_hSendCompletionEvent.GetEventHandle(); + m_RecvOverlapped.hEvent = m_hRecvEvent.GetEventHandle(); + + // Create our threads. + DWORD dwSendThreadID, dwRecvThreadID; + m_hSendThread = CreateThread( NULL, 0, &CThreadedTCPSocket::StaticSendThreadFn, this, CREATE_SUSPENDED, &dwSendThreadID ); + m_hRecvThread = CreateThread( NULL, 0, &CThreadedTCPSocket::StaticRecvThreadFn, this, CREATE_SUSPENDED, &dwRecvThreadID ); + if ( !m_hSendThread || !m_hRecvThread ) + { + return false; + } + + if ( g_bSetTCPSocketThreadPriorities ) + { + SetThreadPriority( m_hSendThread, THREAD_PRIORITY_LOWEST ); + SetThreadPriority( m_hRecvThread, THREAD_PRIORITY_LOWEST ); + } + + ThreadSetDebugName( (ThreadId_t)dwSendThreadID, "TCPSend" ); + ThreadSetDebugName( (ThreadId_t)dwRecvThreadID, "TCPRecv" ); + + // Make sure to init the handler before the threads actually run, so it isn't handed data before initializing. + m_pHandler->Init( this ); + + ResumeThread( m_hSendThread ); + ResumeThread( m_hRecvThread ); + + return true; + } + + void Term() + { + // Signal our threads to exit. + m_hExitThreadsEvent.SetEvent(); + if ( m_hSendThread ) + { + WaitForSingleObject( m_hSendThread, INFINITE ); + CloseHandle( m_hSendThread ); + m_hSendThread = NULL; + } + + if ( m_hRecvThread ) + { + WaitForSingleObject( m_hRecvThread, INFINITE ); + CloseHandle( m_hRecvThread ); + m_hRecvThread = NULL; + } + m_hExitThreadsEvent.ResetEvent(); + + + if ( m_Socket != INVALID_SOCKET ) + { + closesocket( m_Socket ); + m_Socket = INVALID_SOCKET; + } + } + + // Set the initial socket options that we want. + void SetInitialSocketOptions() + { + // Set nodelay to improve latency. + BOOL val = TRUE; + setsockopt( m_Socket, IPPROTO_TCP, TCP_NODELAY, (const char FAR *)&val, sizeof(BOOL) ); + + // Make it linger for 3 seconds when it exits. + LINGER linger; + linger.l_onoff = 1; + linger.l_linger = 3; + setsockopt( m_Socket, SOL_SOCKET, SO_LINGER, (char*)&linger, sizeof( linger ) ); + } + + +// Send thread functionality. +private: + + // This function copies off the payload and adds a SendChunk_t to the list of chunks to be sent. + // It also fires the ReadyToSend event so the thread will pick it up. + bool InternalSend( void const * const *pChunks, const int *pChunkLengths, int nChunks, bool bPrependLength ) + { + int totalLength = 0; + for ( int i=0; i < nChunks; i++ ) + totalLength += pChunkLengths[i]; + + if ( bPrependLength ) + { + if ( totalLength == 0 ) + return true; + + totalLength += 4; + } + + // Copy all the data into a SendData_t. + SendData_t *pSendData = (SendData_t*)malloc( sizeof( SendData_t ) - 1 + totalLength ); + pSendData->m_Len = totalLength; + + char *pOut = pSendData->m_Payload; + if ( bPrependLength ) + { + *((int*)pOut) = totalLength - 4; // The length we prepend is the size of the data, not data size + integer for length. + pOut += 4; + } + for ( int i=0; i < nChunks; i++ ) + { + memcpy( pOut, pChunks[i], pChunkLengths[i] ); + pOut += pChunkLengths[i]; + } + + CCriticalSectionLock csLock( &m_SendCS ); + csLock.Lock(); + + m_SendDatas.AddToTail( pSendData ); + m_hReadyToSendEvent.SetEvent(); // Notify the thread that there is data to send. + + csLock.Unlock(); + + return true; + } + + void SendThread_HandleTimeout() + { + // Timeout.. send a keepalive. + // But only if we're not already sending something. + CCriticalSectionLock csLock( &m_SendCS ); + csLock.Lock(); + int count = m_SendDatas.Count(); + csLock.Unlock(); + + if ( count == 0 ) + { + void *pBuf[1] = { &g_KeepaliveSentinel }; + int len[1] = { sizeof( g_KeepaliveSentinel ) }; + InternalSend( pBuf, len, 1, false ); + } + } + + bool SendThread_HandleSendCompletionEvent() + { + Assert( m_bWaitingForSendCompletion ); + m_bWaitingForSendCompletion = false; + + // A send operation just completed. Now do the next one. + DWORD cbTransfer, flags; + if ( !WSAGetOverlappedResult( m_Socket, &m_SendOverlapped, &cbTransfer, TRUE, &flags ) ) + { + HandleError( WSAGetLastError() ); + return false; + } + + if ( cbTransfer != m_nBytesToTransfer ) + { + char str[512]; + Q_snprintf( str, sizeof( str ), "Invalid # bytes transferred (%d) in send thread (should be %d)", cbTransfer, m_nBytesToTransfer ); + HandleError( ITCPSocketHandler::SocketError, str ); + return false; + } + + // Remove the block we just sent. + CCriticalSectionLock csLock( &m_SendCS ); + csLock.Lock(); + + SendData_t *pSendData = m_SendDatas[ m_SendDatas.Head() ]; + free( pSendData ); + m_SendDatas.Remove( m_SendDatas.Head() ); + + m_bWaitingForSendCompletion = false; + + // Set our send event if there's anything else to send. + if ( m_SendDatas.Count() > 0 ) + m_hReadyToSendEvent.SetEvent(); + + csLock.Unlock(); + return true; + } + + bool SendThread_HandleReadyToSendEvent() + { + // We've got at least one buffer that's ready to be sent. + // NOTE: don't send anything until our current send is completed. + CCriticalSectionLock csLock( &m_SendCS ); + csLock.Lock(); + + Assert( !m_bWaitingForSendCompletion ); + + // Send it off! + SendData_t *pSendData = m_SendDatas[ m_SendDatas.Head() ]; + WSABUF buf = { pSendData->m_Len, pSendData->m_Payload }; + + m_nBytesToTransfer = pSendData->m_Len; + m_bWaitingForSendCompletion = true; + + csLock.Unlock(); + + DWORD dwNumBytesSent = 0; + DWORD ret = WSASend( m_Socket, &buf, 1, &dwNumBytesSent, 0, &m_SendOverlapped, NULL ); + DWORD err = WSAGetLastError(); + if ( ret == 0 || ( ret == SOCKET_ERROR && err == WSA_IO_PENDING ) ) + { + // Either way, the operation completed successfully, and m_hSendCompletionEvent is now set. + return true; + } + else + { + HandleError( err ); + return false; + } + + return true; + } + + DWORD SendThreadFn() + { + while ( 1 ) + { + HANDLE handles[] = + { + m_hExitThreadsEvent.GetEventHandle(), + m_hSendCompletionEvent.GetEventHandle(), + m_hReadyToSendEvent.GetEventHandle() + }; + int nHandles = ARRAYSIZE( handles ); + + // While waiting for send completion, don't handle "ready to send" events. + if ( m_bWaitingForSendCompletion ) + --nHandles; + + DWORD waitValue = WaitForMultipleObjects( nHandles, handles, FALSE, SEND_KEEPALIVE_INTERVAL ); + switch ( waitValue ) + { + case WAIT_TIMEOUT: + { + if ( g_bHandleTimeouts ) + { + // We haven't sent anything in a bit. Send out a keepalive. + SendThread_HandleTimeout(); + } + } + break; + + case WAIT_OBJECT_0: + { + // The main thread is signaling us to exit. + return 0; + } + + case WAIT_OBJECT_0 + 1: + { + if ( !SendThread_HandleSendCompletionEvent() ) + return 1; + } + break; + + case WAIT_OBJECT_0 + 2: + { + if ( !SendThread_HandleReadyToSendEvent() ) + return 1; + } + break; + + case WAIT_FAILED: + { + // Uh oh. We're dead. Cleanup and signal an error. + HandleError( GetLastError() ); + return 1; + } + + default: + { + char str[512]; + Q_snprintf( str, sizeof( str ), "Unknown return value (%lu) from WaitForMultipleObjects", waitValue ); + HandleError( ITCPSocketHandler::SocketError, str ); + return 0; + } + } + } + + return 0; + } + + static DWORD WINAPI StaticSendThreadFn( LPVOID pParameter ) + { + return ((CThreadedTCPSocket*)pParameter)->SendThreadFn(); + } + + +// Receive thread functionality. +private: + + bool RecvThread_WaitToReceiveSize() + { + return RecvThread_InternalRecv( &m_NextPacketLen, sizeof( m_NextPacketLen ), false, true ); + } + + + bool RecvThread_InternalHandleRecvCompletion( DWORD dwTransfer ) + { + int cbTransfer = (int)dwTransfer; + int nBytesWanted = m_nBytesToReceive - m_nBytesReceivedSoFar; + if ( cbTransfer > nBytesWanted ) + { + char str[512]; + Q_snprintf( str, sizeof( str ), "Invalid # bytes received (%d) in recv thread (should be %d)", cbTransfer, m_nBytesToReceive ); + HandleError( ITCPSocketHandler::SocketError, str ); + return false; + } + else if ( cbTransfer < nBytesWanted ) + { + // We have to reissue the receive command because it didn't receive all the data. + m_nBytesReceivedSoFar += cbTransfer; + + char *pDest = (char*)&m_NextPacketLen; + if ( !m_bWaitingForSize ) + { + Assert( m_pRecvBuffer ); + pDest = m_pRecvBuffer->m_Data; + } + + return RecvThread_InternalRecv( &pDest[m_nBytesReceivedSoFar], m_nBytesToReceive - m_nBytesReceivedSoFar, true ); + } + + if ( m_bWaitingForSize ) + { + // If we were waiting for size, now wait for the data. + if ( m_NextPacketLen == KEEPALIVE_SENTINEL ) + { + // Ok, it was just a keepalive. Wait for size again. + return RecvThread_WaitToReceiveSize(); + } + else + { + if ( m_NextPacketLen < 1 || m_NextPacketLen > 1024*1024*75 ) + { + char str[512]; + Q_snprintf( str, sizeof( str ), "Invalid packet size in RecvThread (size = %d)", m_NextPacketLen ); + HandleError( ITCPSocketHandler::SocketError, str ); + return false; + } + else + { + Assert( !m_pRecvBuffer ); + m_pRecvBuffer = (CTCPPacket*)malloc( sizeof( CTCPPacket ) - 1 + m_NextPacketLen ); + m_pRecvBuffer->m_UserData = 0; + m_pRecvBuffer->m_Len = m_NextPacketLen; + + return RecvThread_InternalRecv( m_pRecvBuffer->m_Data, m_pRecvBuffer->m_Len, false, false ); + } + } + } + else + { + // Got a packet! Give it to the app. + m_pHandler->OnPacketReceived( m_pRecvBuffer ); + m_pRecvBuffer = NULL; + + return RecvThread_WaitToReceiveSize(); + } + } + + bool RecvThread_HandleRecvCompletionEvent() + { + // A send operation just completed. Now do the next one. + DWORD cbTransfer, flags; + if ( !WSAGetOverlappedResult( m_Socket, &m_RecvOverlapped, &cbTransfer, TRUE, &flags ) ) + { + HandleError( WSAGetLastError() ); + return false; + } + + return RecvThread_InternalHandleRecvCompletion( cbTransfer ); + } + + bool RecvThread_InternalRecv( void *pDest, int destSize, bool bContinuation, bool bWaitingForSize = false ) + { + WSABUF buf = { destSize, (char*)pDest }; + + if ( !bContinuation ) + { + // If this is not a continuation of whatever we were receiving before, then + m_bWaitingForSize = bWaitingForSize; + m_nBytesToReceive = destSize; + m_nBytesReceivedSoFar = 0; + } + + DWORD dwFlags = 0; + DWORD nBytesReceived = 0; + DWORD ret = WSARecv( m_Socket, &buf, 1, &nBytesReceived, &dwFlags, &m_RecvOverlapped, NULL ); + DWORD dwLastError = WSAGetLastError(); + if ( ret == 0 || ( ret == SOCKET_ERROR && dwLastError == WSA_IO_PENDING ) ) + { + // Note: m_hRecvEvent is in a signaled state, so the RecvThread will pick up the results next time around. + return true; + } + else + { + HandleError( dwLastError ); + return false; + } + } + + + + DWORD RecvThreadFn() + { + // Start us off by setting up to receive the first packet size. + if ( !RecvThread_WaitToReceiveSize() ) + return 1; + + HANDLE handles[] = + { + m_hExitThreadsEvent.GetEventHandle(), + m_hRecvEvent.GetEventHandle() + }; + + while ( 1 ) + { + DWORD waitValue = WaitForMultipleObjects( ARRAYSIZE( handles ), handles, FALSE, KEEPALIVE_TIMEOUT ); + switch ( waitValue ) + { + case WAIT_TIMEOUT: + { + if ( g_bHandleTimeouts ) + { + HandleError( ITCPSocketHandler::ConnectionTimedOut, "Connection timed out" ); + return 1; + } + } + break; + + case WAIT_OBJECT_0: + { + // We're being told to exit. + return 0; + } + + case WAIT_OBJECT_0 + 1: + { + // Just finished receiving something. + if ( !RecvThread_HandleRecvCompletionEvent() ) + return 1; + } + break; + + case WAIT_FAILED: + { + // Uh oh. We're dead. Cleanup and signal an error. + HandleError( GetLastError() ); + return 1; + } + + default: + { + char str[512]; + Q_snprintf( str, sizeof( str ), "Unknown return value (%lu) from WaitForMultipleObjects", waitValue ); + HandleError( ITCPSocketHandler::SocketError, str ); + return 1; + } + } + } + + return 0; + } + + static DWORD WINAPI StaticRecvThreadFn( LPVOID pParameter ) + { + return ((CThreadedTCPSocket*)pParameter)->RecvThreadFn(); + } + + + +// Error handling. +private: + + // This checks to see if either thread has signaled an error. If so, it shuts down the socket and returns true. + bool CheckErrorSignal() + { + return m_bErrorSignal; + } + + // This is called from any of the threads and signals that something went awry. It shuts down the object + // and makes it return false from all of its functions. + void HandleError( DWORD errorValue ) + { + char *lpMsgBuf; + + FormatMessage( + FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + GetLastError(), + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language + (char*)&lpMsgBuf, + 0, + NULL + ); + + // Windows likes to stick a carriage return in there and we don't want it so get rid of it. + int len = strlen( lpMsgBuf ); + while ( len > 0 && ( lpMsgBuf[len-1] == '\n' || lpMsgBuf[len-1] == '\r' ) ) + { + --len; + lpMsgBuf[len] = 0; + } + + HandleError( ITCPSocketHandler::SocketError, lpMsgBuf ); + + LocalFree( lpMsgBuf ); + } + + + void HandleError( int errorCode, const char *pErrorString ) + { + //Assert( false ); + + // Tell the app. + m_pHandler->OnError( errorCode, pErrorString ); + + // Tell the threads to exit. + m_hExitThreadsEvent.SetEvent(); + + // Notify the main thread so it can call Term() when it gets a chance. + m_bErrorSignal = true; + } + + +private: + + // Data for the send thread. + typedef struct + { + //WSAOVERLAPPED m_Overlapped; + int m_Len; + char m_Payload[1]; + } SendData_t; + + HANDLE m_hSendThread; + WSAOVERLAPPED m_SendOverlapped; + CEvent m_hReadyToSendEvent; + CEvent m_hSendCompletionEvent; + + CCriticalSection m_SendCS; + DWORD m_nBytesToTransfer; + bool m_bWaitingForSendCompletion; + CUtlLinkedList<SendData_t*, int> m_SendDatas; // Added to the tail, popped off the head for sending. + + + // Data for the recv thread. + HANDLE m_hRecvThread; + int m_nBytesToReceive; // This stores how many bytes we want to receive for the next packet. + int m_nBytesReceivedSoFar; // This stores how many bytes we've received so far. + bool m_bWaitingForSize; // This tells if we're trying to receive the next packet length or the next packet's data. + + int m_NextPacketLen; // Data is received INTO here before it receives each packet. This + // holds the length of each incoming packet. + + WSAOVERLAPPED m_RecvOverlapped; + CEvent m_hRecvEvent; + CTCPPacket *m_pRecvBuffer; // This is allocated for each packet we're receiving and given to the + // app when the packet is done being received. + + + volatile bool m_bErrorSignal; + + + CEvent m_hExitThreadsEvent; + + ITCPSocketHandler *m_pHandler; + + SOCKET m_Socket; + CIPAddr m_RemoteAddr; +}; + + +// ------------------------------------------------------------------------------------------------ // +// CTCPConnectSocket_Listener +// ------------------------------------------------------------------------------------------------ // +class CTCPConnectSocket_Listener : public ITCPConnectSocket +{ +public: + CTCPConnectSocket_Listener() + { + m_Socket = INVALID_SOCKET; + } + + + virtual ~CTCPConnectSocket_Listener() + { + if ( m_Socket != INVALID_SOCKET ) + { + closesocket( m_Socket ); + } + } + + + // The main function to create one of these suckers. + static ITCPConnectSocket* Create( + IHandlerCreator *pHandlerCreator, + const unsigned short port, + int nQueueLength + ) + { + CTCPConnectSocket_Listener *pRet = new CTCPConnectSocket_Listener; + if ( !pRet ) + return NULL; + + if ( nQueueLength < 0 ) + { + Error( "CTCPConnectSocket_Listener::Create - SOMAXCONN not allowed - causes some XP SP2 systems to stop receiving any network data (systemwide)." ); + } + + // Bind it to a socket and start listening. + CIPAddr addr( 0, 0, 0, 0, port ); // INADDR_ANY + pRet->m_Socket = TCPBind( &addr ); + if ( pRet->m_Socket == INVALID_SOCKET || + listen( pRet->m_Socket, nQueueLength == -1 ? SOMAXCONN : nQueueLength ) != 0 ) + { + pRet->Release(); + return false; + } + + pRet->m_pHandler = pHandlerCreator; + return pRet; + } + + +// ITCPConnectSocket implementation. +public: + + virtual void Release() + { + delete this; + } + + virtual bool Update( IThreadedTCPSocket **pSocket, unsigned long milliseconds ) + { + *pSocket = NULL; + if ( m_Socket == INVALID_SOCKET ) + return false; + + // We're still ok.. just wait until the socket becomes writable (is connected) or we timeout. + fd_set readSet; + readSet.fd_count = 1; + readSet.fd_array[0] = m_Socket; + TIMEVAL timeVal = {0, milliseconds*1000}; + + // Wait until it connects. + int status = select( 0, &readSet, NULL, NULL, &timeVal ); + if ( status > 0 ) + { + sockaddr_in addr; + int addrSize = sizeof( addr ); + + // Now accept the final connection. + SOCKET newSock = accept( m_Socket, (struct sockaddr*)&addr, &addrSize ); + if ( newSock == INVALID_SOCKET ) + { + Assert( false ); + return true; + } + else + { + CIPAddr connectedAddr; + SockAddrToIPAddr( &addr, &connectedAddr ); + + IThreadedTCPSocket *pRet = CThreadedTCPSocket::Create( newSock, connectedAddr, m_pHandler->CreateNewHandler() ); + if ( !pRet ) + { + Assert( false ); + closesocket( m_Socket ); + m_Socket = INVALID_SOCKET; + return false; + } + + *pSocket = pRet; + return true; + } + } + else if ( status == SOCKET_ERROR ) + { + closesocket( m_Socket ); + m_Socket = INVALID_SOCKET; + return false; + } + else + { + return true; + } + } + + +private: + SOCKET m_Socket; + + IHandlerCreator *m_pHandler; +}; + + + +ITCPConnectSocket* ThreadedTCP_CreateListener( + IHandlerCreator *pHandlerCreator, + const unsigned short port, + int nQueueLength + ) +{ + return CTCPConnectSocket_Listener::Create( pHandlerCreator, port, nQueueLength ); +} + + + +// ------------------------------------------------------------------------------------------------ // +// CTCPConnectSocket_Connector +// ------------------------------------------------------------------------------------------------ // +class CTCPConnectSocket_Connector : public ITCPConnectSocket +{ +public: + + CTCPConnectSocket_Connector() + { + m_bConnected = false; + m_Socket = INVALID_SOCKET; + m_bError = false; + } + + virtual ~CTCPConnectSocket_Connector() + { + if ( m_Socket != INVALID_SOCKET ) + { + closesocket( m_Socket ); + } + } + + static ITCPConnectSocket* Create( + const CIPAddr &connectAddr, + const CIPAddr &localAddr, + IHandlerCreator *pHandlerCreator + ) + { + CTCPConnectSocket_Connector *pRet = new CTCPConnectSocket_Connector; + + pRet->m_Socket = TCPBind( &localAddr ); + if ( pRet->m_Socket == INVALID_SOCKET ) + { + pRet->Release(); + return NULL; + } + + sockaddr_in addr; + IPAddrToSockAddr( &connectAddr, &addr ); + + // We don't want the connect() call to block. + DWORD val = 1; + int status = ioctlsocket( pRet->m_Socket, FIONBIO, &val ); + if ( status != 0 ) + { + Assert( false ); + pRet->Release(); + return NULL; + } + + pRet->m_RemoteAddr = connectAddr; + pRet->m_pHandlerCreator = pHandlerCreator; + + int ret = connect( pRet->m_Socket, (struct sockaddr*)&addr, sizeof( addr ) ); + if ( ret == 0 ) + { + pRet->m_bConnected = true; + return pRet; + } + else if ( ret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK ) + { + return pRet; + } + else + { + Assert( false ); + pRet->Release(); + return NULL; + } + } + + +// ITCPConnectSocket implementation. +public: + + virtual void Release() + { + delete this; + } + + + virtual bool Update( IThreadedTCPSocket **pSocket, unsigned long milliseconds ) + { + *pSocket = NULL; + + // If we got an error previously, keep returning false. + if ( m_bError ) + return false; + + // If this condition holds, then we already returned a valid socket and we're just waiting to be released. + if ( m_Socket == INVALID_SOCKET ) + return true; + + // Ok, see if we're connected now. + if ( !m_bConnected ) + { + TIMEVAL timeVal = { 0, milliseconds*1000 }; + + fd_set writeSet; + writeSet.fd_count = 1; + writeSet.fd_array[0] = m_Socket; + + int ret = select( 0, NULL, &writeSet, NULL, &timeVal ); + if ( ret > 0 ) + { + m_bConnected = true; + } + else if ( ret == SOCKET_ERROR ) + { + return EnterErrorMode(); + } + } + + if ( m_bConnected ) + { + // Ok, return a connected socket for them. + + // Make our socket blocking again. + DWORD val = 0; + int status = ioctlsocket( m_Socket, FIONBIO, &val ); + if ( status != 0 ) + { + Assert( false ); + m_bError = true; + closesocket( m_Socket ); + m_Socket = INVALID_SOCKET; + return false; + } + + IThreadedTCPSocket *pRet = CThreadedTCPSocket::Create( m_Socket, m_RemoteAddr, m_pHandlerCreator->CreateNewHandler() ); + if ( pRet ) + { + m_Socket = INVALID_SOCKET; + *pSocket = pRet; + return true; + } + else + { + return EnterErrorMode(); + } + } + else + { + // Still waiting.. + return true; + } + } + + // Shutdown the socket and start returning false from Update(). + bool EnterErrorMode() + { + Assert( false ); + m_bError = true; + closesocket( m_Socket ); + m_Socket = INVALID_SOCKET; + return false; + } + + +private: + + bool m_bError; + bool m_bConnected; + + SOCKET m_Socket; + CIPAddr m_RemoteAddr; + + IHandlerCreator *m_pHandlerCreator; +}; + + +ITCPConnectSocket* ThreadedTCP_CreateConnector( + const CIPAddr &addr, + const CIPAddr &localAddr, + IHandlerCreator *pHandlerCreator + ) +{ + return CTCPConnectSocket_Connector::Create( addr, localAddr, pHandlerCreator ); +} + + +void ThreadedTCP_EnableTimeouts( bool bEnable ) +{ + g_bHandleTimeouts = bEnable; +} + + +void ThreadedTCP_SetTCPSocketThreadPriorities( bool bSetTCPSocketThreadPriorities ) +{ + g_bSetTCPSocketThreadPriorities = bSetTCPSocketThreadPriorities; +} + diff --git a/utils/vmpi/ThreadedTCPSocketEmu.cpp b/utils/vmpi/ThreadedTCPSocketEmu.cpp new file mode 100644 index 0000000..f8257a5 --- /dev/null +++ b/utils/vmpi/ThreadedTCPSocketEmu.cpp @@ -0,0 +1,344 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#include <windows.h> +#include "tcpsocket.h" +#include "IThreadedTCPSocket.h" +#include "ThreadedTCPSocketEmu.h" +#include "ThreadHelpers.h" + + + +// ---------------------------------------------------------------------------------------- // +// CThreadedTCPSocketEmu. This uses IThreadedTCPSocket to emulate the polling-type interface +// in ITCPSocket. +// ---------------------------------------------------------------------------------------- // + +// This class uses the IThreadedTCPSocket interface to emulate the old ITCPSocket. +class CThreadedTCPSocketEmu : public ITCPSocket, public ITCPSocketHandler, public IHandlerCreator +{ +public: + + CThreadedTCPSocketEmu() + { + m_pSocket = NULL; + m_LocalPort = 0xFFFF; + m_pConnectSocket = NULL; + m_RecvPacketsEvent.Init( false, false ); + m_bError = false; + } + + virtual ~CThreadedTCPSocketEmu() + { + Term(); + } + + void Init( IThreadedTCPSocket *pSocket ) + { + m_pSocket = pSocket; + } + + void Term() + { + if ( m_pSocket ) + { + m_pSocket->Release(); + m_pSocket = NULL; + } + + if ( m_pConnectSocket ) + { + m_pConnectSocket->Release(); + m_pConnectSocket = NULL; + } + } + + +// ITCPSocketHandler implementation. +private: + + + virtual void OnPacketReceived( CTCPPacket *pPacket ) + { + CCriticalSectionLock csLock( &m_RecvPacketsCS ); + csLock.Lock(); + + m_RecvPackets.AddToTail( pPacket ); + m_RecvPacketsEvent.SetEvent(); + } + + + virtual void OnError( int errorCode, const char *pErrorString ) + { + CCriticalSectionLock csLock( &m_ErrorStringCS ); + csLock.Lock(); + + m_ErrorString.CopyArray( pErrorString, strlen( pErrorString ) + 1 ); + m_bError = true; + } + + +// IHandlerCreator implementation. +public: + + // This is used for connecting. + virtual ITCPSocketHandler* CreateNewHandler() + { + return this; + } + + +// ITCPSocket implementation. +public: + + virtual void Release() + { + delete this; + } + + virtual bool BindToAny( const unsigned short port ) + { + m_LocalPort = port; + return true; + } + + virtual bool BeginConnect( const CIPAddr &addr ) + { + // They should have "bound" to a port before trying to connect. + Assert( m_LocalPort != 0xFFFF ); + + if ( m_pConnectSocket ) + m_pConnectSocket->Release(); + + m_pConnectSocket = ThreadedTCP_CreateConnector( + addr, + CIPAddr( 0, 0, 0, 0, m_LocalPort ), + this ); + + return m_pConnectSocket != 0; + } + + virtual bool UpdateConnect() + { + Assert( !m_pSocket ); + if ( !m_pConnectSocket ) + return false; + + if ( m_pConnectSocket->Update( &m_pSocket ) ) + { + if ( m_pSocket ) + { + // Ok, we're connected now. + m_pConnectSocket->Release(); + m_pConnectSocket = NULL; + return true; + } + else + { + return false; + } + } + else + { + Assert( false ); + m_pConnectSocket->Release(); + m_pConnectSocket = NULL; + return false; + } + } + + virtual bool IsConnected() + { + if ( m_bError ) + { + Term(); + return false; + } + else + { + return m_pSocket != NULL; + } + } + + virtual void GetDisconnectReason( CUtlVector<char> &reason ) + { + CCriticalSectionLock csLock( &m_ErrorStringCS ); + csLock.Lock(); + + reason = m_ErrorString; + } + + virtual bool Send( const void *pData, int size ) + { + Assert( m_pSocket ); + if ( !m_pSocket ) + return false; + + return m_pSocket->Send( pData, size ); + } + + virtual bool SendChunks( void const * const *pChunks, const int *pChunkLengths, int nChunks ) + { + Assert( m_pSocket ); + if ( !m_pSocket || !m_pSocket->IsValid() ) + return false; + + return m_pSocket->SendChunks( pChunks, pChunkLengths, nChunks ); + } + + virtual bool Recv( CUtlVector<unsigned char> &data, double flTimeout ) + { + // Use our m_RecvPacketsEvent event to determine if there is data to receive yet. + DWORD nMilliseconds = (DWORD)( flTimeout * 1000.0f ); + DWORD ret = WaitForSingleObject( m_RecvPacketsEvent.GetEventHandle(), nMilliseconds ); + if ( ret == WAIT_OBJECT_0 ) + { + // Ok, there's a packet. + CCriticalSectionLock csLock( &m_RecvPacketsCS ); + csLock.Lock(); + + Assert( m_RecvPackets.Count() > 0 ); + + int iHead = m_RecvPackets.Head(); + CTCPPacket *pPacket = m_RecvPackets[ iHead ]; + + data.CopyArray( (const unsigned char*)pPacket->GetData(), pPacket->GetLen() ); + + pPacket->Release(); + m_RecvPackets.Remove( iHead ); + + // Re-set the event if there are more packets left to receive. + if ( m_RecvPackets.Count() > 0 ) + { + m_RecvPacketsEvent.SetEvent(); + } + + return true; + } + else + { + return false; + } + } + + +private: + + IThreadedTCPSocket *m_pSocket; + + unsigned short m_LocalPort; // The port we bind to when we want to connect. + ITCPConnectSocket *m_pConnectSocket; + + + // All the received data is stored in here. + CEvent m_RecvPacketsEvent; + CCriticalSection m_RecvPacketsCS; + CUtlLinkedList<CTCPPacket*, int> m_RecvPackets; + + CCriticalSection m_ErrorStringCS; + CUtlVector<char> m_ErrorString; + bool m_bError; // Set to true when there's an error. Next chance we get in the main thread, we'll close the socket. +}; + + +ITCPSocket* CreateTCPSocketEmu() +{ + return new CThreadedTCPSocketEmu; +} + + +// ---------------------------------------------------------------------------------------- // +// CThreadedTCPListenSocketEmu implementation. +// ---------------------------------------------------------------------------------------- // + +class CThreadedTCPListenSocketEmu : public ITCPListenSocket, public IHandlerCreator +{ +public: + CThreadedTCPListenSocketEmu() + { + m_pListener = NULL; + m_pLastCreatedSocket = NULL; + } + + virtual ~CThreadedTCPListenSocketEmu() + { + if ( m_pListener ) + m_pListener->Release(); + } + + bool StartListening( const unsigned short port, int nQueueLength ) + { + m_pListener = ThreadedTCP_CreateListener( + this, + port, + nQueueLength ); + + return m_pListener != 0; + } + + +// ITCPListenSocket implementation. +private: + + virtual void Release() + { + delete this; + } + + virtual ITCPSocket* UpdateListen( CIPAddr *pAddr ) + { + if ( !m_pListener ) + return NULL; + + IThreadedTCPSocket *pSocket; + if ( m_pListener->Update( &pSocket ) && pSocket ) + { + *pAddr = pSocket->GetRemoteAddr(); + + // This is pretty hacky, but this stuff is just around for test code. + CThreadedTCPSocketEmu *pLast = m_pLastCreatedSocket; + pLast->Init( pSocket ); + m_pLastCreatedSocket = NULL; + return pLast; + } + else + { + return NULL; + } + } + + +// IHandlerCreator implementation. +private: + + virtual ITCPSocketHandler* CreateNewHandler() + { + m_pLastCreatedSocket = new CThreadedTCPSocketEmu; + return m_pLastCreatedSocket; + } + + +private: + + ITCPConnectSocket *m_pListener; + CThreadedTCPSocketEmu *m_pLastCreatedSocket; +}; + +ITCPListenSocket* CreateTCPListenSocketEmu( const unsigned short port, int nQueueLength ) +{ + CThreadedTCPListenSocketEmu *pSocket = new CThreadedTCPListenSocketEmu; + if ( pSocket->StartListening( port, nQueueLength ) ) + { + return pSocket; + } + else + { + delete pSocket; + return NULL; + } +} + diff --git a/utils/vmpi/ThreadedTCPSocketEmu.h b/utils/vmpi/ThreadedTCPSocketEmu.h new file mode 100644 index 0000000..1ed1380 --- /dev/null +++ b/utils/vmpi/ThreadedTCPSocketEmu.h @@ -0,0 +1,26 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#ifndef THREADEDTCPSOCKETEMU_H +#define THREADEDTCPSOCKETEMU_H +#ifdef _WIN32 +#pragma once +#endif + + +#include "tcpsocket.h" + + +// This creates a class that's based on IThreadedTCPSocket, but emulates the old ITCPSocket interface. +// This is used for stress-testing IThreadedTCPSocket. +ITCPSocket* CreateTCPSocketEmu(); + + +ITCPListenSocket* CreateTCPListenSocketEmu( const unsigned short port, int nQueueLength = -1 ); + + +#endif // THREADEDTCPSOCKETEMU_H diff --git a/utils/vmpi/WaitAndRestart/StdAfx.cpp b/utils/vmpi/WaitAndRestart/StdAfx.cpp new file mode 100644 index 0000000..bac634d --- /dev/null +++ b/utils/vmpi/WaitAndRestart/StdAfx.cpp @@ -0,0 +1,15 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// stdafx.cpp : source file that includes just the standard includes +// WaitAndRestart.pch will be the pre-compiled header +// stdafx.obj will contain the pre-compiled type information + +#include "stdafx.h" + +// TODO: reference any additional headers you need in STDAFX.H +// and not in this file diff --git a/utils/vmpi/WaitAndRestart/StdAfx.h b/utils/vmpi/WaitAndRestart/StdAfx.h new file mode 100644 index 0000000..954e1f8 --- /dev/null +++ b/utils/vmpi/WaitAndRestart/StdAfx.h @@ -0,0 +1,32 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, but +// are changed infrequently +// + +#if !defined(AFX_STDAFX_H__6E874DA8_5D18_47D5_B557_3E07B6171907__INCLUDED_) +#define AFX_STDAFX_H__6E874DA8_5D18_47D5_B557_3E07B6171907__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers + +#include <windows.h> +#include <stdio.h> +#include <stdlib.h> +#include <conio.h> + +// TODO: reference additional headers your program requires here + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_STDAFX_H__6E874DA8_5D18_47D5_B557_3E07B6171907__INCLUDED_) diff --git a/utils/vmpi/WaitAndRestart/WaitAndRestart.cpp b/utils/vmpi/WaitAndRestart/WaitAndRestart.cpp new file mode 100644 index 0000000..c9ef1e0 --- /dev/null +++ b/utils/vmpi/WaitAndRestart/WaitAndRestart.cpp @@ -0,0 +1,166 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// WaitAndRestart.cpp : Defines the entry point for the console application. +// + +#include "stdafx.h" +#include "tier1/strtools.h" +#include "vmpi_defs.h" + + +void PrintLog( const char *pMsg, ... ) +{ +#ifdef VMPI_SERVICE_LOGS + char str[4096]; + va_list marker; + + va_start( marker, pMsg ); + _vsnprintf( str, sizeof( str ), pMsg, marker ); + va_end( marker ); + + printf( "%s", str ); + + static FILE *fp = fopen( "c:\\vmpi_WaitAndRestart.log", "wt" ); + if ( fp ) + { + fprintf( fp, "%s", str ); + fflush( fp ); + } +#endif +} + + +char* GetLastErrorString() +{ + static char err[2048]; + + LPVOID lpMsgBuf; + FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpMsgBuf, 0, NULL ); + strncpy( err, (char*)lpMsgBuf, sizeof( err ) ); + LocalFree( lpMsgBuf ); + + err[ sizeof( err ) - 1 ] = 0; + return err; +} + + +int main( int argc, char* argv[] ) +{ +Sleep(5000); + if ( argc < 4 ) + { + PrintLog( "WaitAndRestart <seconds to wait> <working directory> command line...\n" ); + return 1; + } + + PrintLog( "WaitAndRestart <seconds to wait> <working directory> command line...\n" ); + + + const char *pTimeToWait = argv[1]; + const char *pWorkingDir = argv[2]; + + // If a * precedes the time-to-wait arg, then it's a process ID and we wait for that process to exit. + if ( pTimeToWait[0] == '*' ) + { + ++pTimeToWait; + DWORD dwProcessId; + sscanf( pTimeToWait, "%lu", &dwProcessId ); + + PrintLog( "Waiting for process %lu to exit. Press a key to cancel...\n", dwProcessId ); + + HANDLE hProcess = OpenProcess( PROCESS_QUERY_INFORMATION | SYNCHRONIZE, false, dwProcessId ); + if ( hProcess ) + { + while ( 1 ) + { + DWORD val = WaitForSingleObject( hProcess, 100 ); + if ( val == WAIT_OBJECT_0 ) + { + break; + } + else if ( val == WAIT_ABANDONED ) + { + PrintLog( "Got WAIT_ABANDONED (error). Waiting 5 seconds, then continuing.\n" ); + Sleep( 5000 ); + break; + } + + if ( kbhit() ) + return 2; + } + PrintLog( "Process %lu terminated. Continuing.\n", dwProcessId ); + } + else + { + PrintLog( "Process %lu not running. Continuing.\n", dwProcessId ); + } + + CloseHandle( hProcess ); + } + else + { + DWORD timeToWait = (DWORD)atoi( argv[1] ); + + PrintLog( "\n\nWaiting for %d seconds to launch ' ", timeToWait ); + PrintLog( "%s> ", pWorkingDir ); + for ( int i=3; i < argc; i++ ) + { + PrintLog( "%s ", argv[i] ); + } + PrintLog( "'\n\nPress a key to cancel... " ); + + DWORD startTime = GetTickCount(); + while ( GetTickCount() - startTime < (timeToWait*1000) ) + { + if ( kbhit() ) + return 2; + + Sleep( 100 ); + } + } + + // Ok, launch it! + char commandLine[1024] = {0}; + for ( int i=3; i < argc; i++ ) + { + Q_strncat( commandLine, "\"", sizeof( commandLine ), COPY_ALL_CHARACTERS ); + Q_strncat( commandLine, argv[i], sizeof( commandLine ), COPY_ALL_CHARACTERS ); + Q_strncat( commandLine, "\" ", sizeof( commandLine ), COPY_ALL_CHARACTERS ); + } + + STARTUPINFO si; + memset( &si, 0, sizeof( si ) ); + si.cb = sizeof( si ); + + PROCESS_INFORMATION pi; + memset( &pi, 0, sizeof( pi ) ); + + if ( CreateProcess( + NULL, + commandLine, + NULL, // security + NULL, + FALSE, + 0, // flags + NULL, // environment + pWorkingDir, // current directory + &si, + &pi ) ) + { + PrintLog( "Process started.\n" ); + CloseHandle( pi.hThread ); // We don't care what the process does. + CloseHandle( pi.hProcess ); + } + else + { + PrintLog( "CreateProcess error!\n%s", GetLastErrorString() ); + } + + return 0; +} + diff --git a/utils/vmpi/WaitAndRestart/waitandrestart.vpc b/utils/vmpi/WaitAndRestart/waitandrestart.vpc new file mode 100644 index 0000000..8bf43ba --- /dev/null +++ b/utils/vmpi/WaitAndRestart/waitandrestart.vpc @@ -0,0 +1,32 @@ +//----------------------------------------------------------------------------- +// WAITANDRESTART.VPC +// +// Project Script +//----------------------------------------------------------------------------- + +$Macro SRCDIR "..\..\.." +$Macro OUTBINDIR "$SRCDIR\..\game\bin" +$Macro OUTBINNAME "WaitAndRestart" + +$Include "$SRCDIR\vpc_scripts\source_exe_con_win32_base.vpc" + +$Configuration +{ + $Compiler + { + $AdditionalIncludeDirectories "$BASE,..\" + $PreprocessorDefinitions "$BASE;PROTECTED_THINGS_DISABLE" + } +} + +$Project "WaitAndRestart" +{ + $Folder "Source Files" + { + $File "WaitAndRestart.cpp" + } + + $Folder "Header Files" + { + } +} diff --git a/utils/vmpi/ZLib.lib b/utils/vmpi/ZLib.lib Binary files differnew file mode 100644 index 0000000..23c3dfd --- /dev/null +++ b/utils/vmpi/ZLib.lib diff --git a/utils/vmpi/ZLib/deflate.h b/utils/vmpi/ZLib/deflate.h new file mode 100644 index 0000000..962676d --- /dev/null +++ b/utils/vmpi/ZLib/deflate.h @@ -0,0 +1,318 @@ +/* deflate.h -- internal compression state + * Copyright (C) 1995-1998 Jean-loup Gailly + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + +/* @(#) $Id$ */ + +#ifndef _DEFLATE_H +#define _DEFLATE_H + +#include "zutil.h" + +/* =========================================================================== + * Internal compression state. + */ + +#define LENGTH_CODES 29 +/* number of length codes, not counting the special END_BLOCK code */ + +#define LITERALS 256 +/* number of literal bytes 0..255 */ + +#define L_CODES (LITERALS+1+LENGTH_CODES) +/* number of Literal or Length codes, including the END_BLOCK code */ + +#define D_CODES 30 +/* number of distance codes */ + +#define BL_CODES 19 +/* number of codes used to transfer the bit lengths */ + +#define HEAP_SIZE (2*L_CODES+1) +/* maximum heap size */ + +#define MAX_BITS 15 +/* All codes must not exceed MAX_BITS bits */ + +#define INIT_STATE 42 +#define BUSY_STATE 113 +#define FINISH_STATE 666 +/* Stream status */ + + +/* Data structure describing a single value and its code string. */ +typedef struct ct_data_s { + union { + ush freq; /* frequency count */ + ush code; /* bit string */ + } fc; + union { + ush dad; /* father node in Huffman tree */ + ush len; /* length of bit string */ + } dl; +} FAR ct_data; + +#define Freq fc.freq +#define Code fc.code +#define Dad dl.dad +#define Len dl.len + +typedef struct static_tree_desc_s static_tree_desc; + +typedef struct tree_desc_s { + ct_data *dyn_tree; /* the dynamic tree */ + int max_code; /* largest code with non zero frequency */ + static_tree_desc *stat_desc; /* the corresponding static tree */ +} FAR tree_desc; + +typedef ush Pos; +typedef Pos FAR Posf; +typedef unsigned IPos; + +/* A Pos is an index in the character window. We use short instead of int to + * save space in the various tables. IPos is used only for parameter passing. + */ + +typedef struct internal_state { + z_streamp strm; /* pointer back to this zlib stream */ + int status; /* as the name implies */ + Bytef *pending_buf; /* output still pending */ + ulg pending_buf_size; /* size of pending_buf */ + Bytef *pending_out; /* next pending byte to output to the stream */ + int pending; /* nb of bytes in the pending buffer */ + int noheader; /* suppress zlib header and adler32 */ + Byte data_type; /* UNKNOWN, BINARY or ASCII */ + Byte method; /* STORED (for zip only) or DEFLATED */ + int last_flush; /* value of flush param for previous deflate call */ + + /* used by deflate.c: */ + + uInt w_size; /* LZ77 window size (32K by default) */ + uInt w_bits; /* log2(w_size) (8..16) */ + uInt w_mask; /* w_size - 1 */ + + Bytef *window; + /* Sliding window. Input bytes are read into the second half of the window, + * and move to the first half later to keep a dictionary of at least wSize + * bytes. With this organization, matches are limited to a distance of + * wSize-MAX_MATCH bytes, but this ensures that IO is always + * performed with a length multiple of the block size. Also, it limits + * the window size to 64K, which is quite useful on MSDOS. + * To do: use the user input buffer as sliding window. + */ + + ulg window_size; + /* Actual size of window: 2*wSize, except when the user input buffer + * is directly used as sliding window. + */ + + Posf *prev; + /* Link to older string with same hash index. To limit the size of this + * array to 64K, this link is maintained only for the last 32K strings. + * An index in this array is thus a window index modulo 32K. + */ + + Posf *head; /* Heads of the hash chains or NIL. */ + + uInt ins_h; /* hash index of string to be inserted */ + uInt hash_size; /* number of elements in hash table */ + uInt hash_bits; /* log2(hash_size) */ + uInt hash_mask; /* hash_size-1 */ + + uInt hash_shift; + /* Number of bits by which ins_h must be shifted at each input + * step. It must be such that after MIN_MATCH steps, the oldest + * byte no longer takes part in the hash key, that is: + * hash_shift * MIN_MATCH >= hash_bits + */ + + long block_start; + /* Window position at the beginning of the current output block. Gets + * negative when the window is moved backwards. + */ + + uInt match_length; /* length of best match */ + IPos prev_match; /* previous match */ + int match_available; /* set if previous match exists */ + uInt strstart; /* start of string to insert */ + uInt match_start; /* start of matching string */ + uInt lookahead; /* number of valid bytes ahead in window */ + + uInt prev_length; + /* Length of the best match at previous step. Matches not greater than this + * are discarded. This is used in the lazy match evaluation. + */ + + uInt max_chain_length; + /* To speed up deflation, hash chains are never searched beyond this + * length. A higher limit improves compression ratio but degrades the + * speed. + */ + + uInt max_lazy_match; + /* Attempt to find a better match only when the current match is strictly + * smaller than this value. This mechanism is used only for compression + * levels >= 4. + */ +# define max_insert_length max_lazy_match + /* Insert new strings in the hash table only if the match length is not + * greater than this length. This saves time but degrades compression. + * max_insert_length is used only for compression levels <= 3. + */ + + int level; /* compression level (1..9) */ + int strategy; /* favor or force Huffman coding*/ + + uInt good_match; + /* Use a faster search when the previous match is longer than this */ + + int nice_match; /* Stop searching when current match exceeds this */ + + /* used by trees.c: */ + /* Didn't use ct_data typedef below to supress compiler warning */ + struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */ + struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */ + struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */ + + struct tree_desc_s l_desc; /* desc. for literal tree */ + struct tree_desc_s d_desc; /* desc. for distance tree */ + struct tree_desc_s bl_desc; /* desc. for bit length tree */ + + ush bl_count[MAX_BITS+1]; + /* number of codes at each bit length for an optimal tree */ + + int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */ + int heap_len; /* number of elements in the heap */ + int heap_max; /* element of largest frequency */ + /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used. + * The same heap array is used to build all trees. + */ + + uch depth[2*L_CODES+1]; + /* Depth of each subtree used as tie breaker for trees of equal frequency + */ + + uchf *l_buf; /* buffer for literals or lengths */ + + uInt lit_bufsize; + /* Size of match buffer for literals/lengths. There are 4 reasons for + * limiting lit_bufsize to 64K: + * - frequencies can be kept in 16 bit counters + * - if compression is not successful for the first block, all input + * data is still in the window so we can still emit a stored block even + * when input comes from standard input. (This can also be done for + * all blocks if lit_bufsize is not greater than 32K.) + * - if compression is not successful for a file smaller than 64K, we can + * even emit a stored file instead of a stored block (saving 5 bytes). + * This is applicable only for zip (not gzip or zlib). + * - creating new Huffman trees less frequently may not provide fast + * adaptation to changes in the input data statistics. (Take for + * example a binary file with poorly compressible code followed by + * a highly compressible string table.) Smaller buffer sizes give + * fast adaptation but have of course the overhead of transmitting + * trees more frequently. + * - I can't count above 4 + */ + + uInt last_lit; /* running index in l_buf */ + + ushf *d_buf; + /* Buffer for distances. To simplify the code, d_buf and l_buf have + * the same number of elements. To use different lengths, an extra flag + * array would be necessary. + */ + + ulg opt_len; /* bit length of current block with optimal trees */ + ulg static_len; /* bit length of current block with static trees */ + uInt matches; /* number of string matches in current block */ + int last_eob_len; /* bit length of EOB code for last block */ + +#ifdef DEBUG + ulg compressed_len; /* total bit length of compressed file mod 2^32 */ + ulg bits_sent; /* bit length of compressed data sent mod 2^32 */ +#endif + + ush bi_buf; + /* Output buffer. bits are inserted starting at the bottom (least + * significant bits). + */ + int bi_valid; + /* Number of valid bits in bi_buf. All bits above the last valid bit + * are always zero. + */ + +} FAR deflate_state; + +/* Output a byte on the stream. + * IN assertion: there is enough room in pending_buf. + */ +#define put_byte(s, c) {s->pending_buf[s->pending++] = (c);} + + +#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1) +/* Minimum amount of lookahead, except at the end of the input file. + * See deflate.c for comments about the MIN_MATCH+1. + */ + +#define MAX_DIST(s) ((s)->w_size-MIN_LOOKAHEAD) +/* In order to simplify the code, particularly on 16 bit machines, match + * distances are limited to MAX_DIST instead of WSIZE. + */ + + /* in trees.c */ +void _tr_init OF((deflate_state *s)); +int _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc)); +void _tr_flush_block OF((deflate_state *s, charf *buf, ulg stored_len, + int eof)); +void _tr_align OF((deflate_state *s)); +void _tr_stored_block OF((deflate_state *s, charf *buf, ulg stored_len, + int eof)); + +#define d_code(dist) \ + ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)]) +/* Mapping from a distance to a distance code. dist is the distance - 1 and + * must not have side effects. _dist_code[256] and _dist_code[257] are never + * used. + */ + +#ifndef DEBUG +/* Inline versions of _tr_tally for speed: */ + +#if defined(GEN_TREES_H) || !defined(STDC) + extern uch _length_code[]; + extern uch _dist_code[]; +#else + extern const uch _length_code[]; + extern const uch _dist_code[]; +#endif + +# define _tr_tally_lit(s, c, flush) \ + { uch cc = (c); \ + s->d_buf[s->last_lit] = 0; \ + s->l_buf[s->last_lit++] = cc; \ + s->dyn_ltree[cc].Freq++; \ + flush = (s->last_lit == s->lit_bufsize-1); \ + } +# define _tr_tally_dist(s, distance, length, flush) \ + { uch len = (length); \ + ush dist = (distance); \ + s->d_buf[s->last_lit] = dist; \ + s->l_buf[s->last_lit++] = len; \ + dist--; \ + s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \ + s->dyn_dtree[d_code(dist)].Freq++; \ + flush = (s->last_lit == s->lit_bufsize-1); \ + } +#else +# define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c) +# define _tr_tally_dist(s, distance, length, flush) \ + flush = _tr_tally(s, distance, length) +#endif + +#endif diff --git a/utils/vmpi/ZLib/infblock.h b/utils/vmpi/ZLib/infblock.h new file mode 100644 index 0000000..bd25c80 --- /dev/null +++ b/utils/vmpi/ZLib/infblock.h @@ -0,0 +1,39 @@ +/* infblock.h -- header to use infblock.c + * Copyright (C) 1995-1998 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + +struct inflate_blocks_state; +typedef struct inflate_blocks_state FAR inflate_blocks_statef; + +extern inflate_blocks_statef * inflate_blocks_new OF(( + z_streamp z, + check_func c, /* check function */ + uInt w)); /* window size */ + +extern int inflate_blocks OF(( + inflate_blocks_statef *, + z_streamp , + int)); /* initial return code */ + +extern void inflate_blocks_reset OF(( + inflate_blocks_statef *, + z_streamp , + uLongf *)); /* check value on output */ + +extern int inflate_blocks_free OF(( + inflate_blocks_statef *, + z_streamp)); + +extern void inflate_set_dictionary OF(( + inflate_blocks_statef *s, + const Bytef *d, /* dictionary */ + uInt n)); /* dictionary length */ + +extern int inflate_blocks_sync_point OF(( + inflate_blocks_statef *s)); diff --git a/utils/vmpi/ZLib/infcodes.h b/utils/vmpi/ZLib/infcodes.h new file mode 100644 index 0000000..6c750d8 --- /dev/null +++ b/utils/vmpi/ZLib/infcodes.h @@ -0,0 +1,27 @@ +/* infcodes.h -- header to use infcodes.c + * Copyright (C) 1995-1998 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + +struct inflate_codes_state; +typedef struct inflate_codes_state FAR inflate_codes_statef; + +extern inflate_codes_statef *inflate_codes_new OF(( + uInt, uInt, + inflate_huft *, inflate_huft *, + z_streamp )); + +extern int inflate_codes OF(( + inflate_blocks_statef *, + z_streamp , + int)); + +extern void inflate_codes_free OF(( + inflate_codes_statef *, + z_streamp )); + diff --git a/utils/vmpi/ZLib/inffast.h b/utils/vmpi/ZLib/inffast.h new file mode 100644 index 0000000..8facec5 --- /dev/null +++ b/utils/vmpi/ZLib/inffast.h @@ -0,0 +1,17 @@ +/* inffast.h -- header to use inffast.c + * Copyright (C) 1995-1998 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + +extern int inflate_fast OF(( + uInt, + uInt, + inflate_huft *, + inflate_huft *, + inflate_blocks_statef *, + z_streamp )); diff --git a/utils/vmpi/ZLib/inffixed.h b/utils/vmpi/ZLib/inffixed.h new file mode 100644 index 0000000..77f7e76 --- /dev/null +++ b/utils/vmpi/ZLib/inffixed.h @@ -0,0 +1,151 @@ +/* inffixed.h -- table for decoding fixed codes + * Generated automatically by the maketree.c program + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + +local uInt fixed_bl = 9; +local uInt fixed_bd = 5; +local inflate_huft fixed_tl[] = { + {{{96,7}},256}, {{{0,8}},80}, {{{0,8}},16}, {{{84,8}},115}, + {{{82,7}},31}, {{{0,8}},112}, {{{0,8}},48}, {{{0,9}},192}, + {{{80,7}},10}, {{{0,8}},96}, {{{0,8}},32}, {{{0,9}},160}, + {{{0,8}},0}, {{{0,8}},128}, {{{0,8}},64}, {{{0,9}},224}, + {{{80,7}},6}, {{{0,8}},88}, {{{0,8}},24}, {{{0,9}},144}, + {{{83,7}},59}, {{{0,8}},120}, {{{0,8}},56}, {{{0,9}},208}, + {{{81,7}},17}, {{{0,8}},104}, {{{0,8}},40}, {{{0,9}},176}, + {{{0,8}},8}, {{{0,8}},136}, {{{0,8}},72}, {{{0,9}},240}, + {{{80,7}},4}, {{{0,8}},84}, {{{0,8}},20}, {{{85,8}},227}, + {{{83,7}},43}, {{{0,8}},116}, {{{0,8}},52}, {{{0,9}},200}, + {{{81,7}},13}, {{{0,8}},100}, {{{0,8}},36}, {{{0,9}},168}, + {{{0,8}},4}, {{{0,8}},132}, {{{0,8}},68}, {{{0,9}},232}, + {{{80,7}},8}, {{{0,8}},92}, {{{0,8}},28}, {{{0,9}},152}, + {{{84,7}},83}, {{{0,8}},124}, {{{0,8}},60}, {{{0,9}},216}, + {{{82,7}},23}, {{{0,8}},108}, {{{0,8}},44}, {{{0,9}},184}, + {{{0,8}},12}, {{{0,8}},140}, {{{0,8}},76}, {{{0,9}},248}, + {{{80,7}},3}, {{{0,8}},82}, {{{0,8}},18}, {{{85,8}},163}, + {{{83,7}},35}, {{{0,8}},114}, {{{0,8}},50}, {{{0,9}},196}, + {{{81,7}},11}, {{{0,8}},98}, {{{0,8}},34}, {{{0,9}},164}, + {{{0,8}},2}, {{{0,8}},130}, {{{0,8}},66}, {{{0,9}},228}, + {{{80,7}},7}, {{{0,8}},90}, {{{0,8}},26}, {{{0,9}},148}, + {{{84,7}},67}, {{{0,8}},122}, {{{0,8}},58}, {{{0,9}},212}, + {{{82,7}},19}, {{{0,8}},106}, {{{0,8}},42}, {{{0,9}},180}, + {{{0,8}},10}, {{{0,8}},138}, {{{0,8}},74}, {{{0,9}},244}, + {{{80,7}},5}, {{{0,8}},86}, {{{0,8}},22}, {{{192,8}},0}, + {{{83,7}},51}, {{{0,8}},118}, {{{0,8}},54}, {{{0,9}},204}, + {{{81,7}},15}, {{{0,8}},102}, {{{0,8}},38}, {{{0,9}},172}, + {{{0,8}},6}, {{{0,8}},134}, {{{0,8}},70}, {{{0,9}},236}, + {{{80,7}},9}, {{{0,8}},94}, {{{0,8}},30}, {{{0,9}},156}, + {{{84,7}},99}, {{{0,8}},126}, {{{0,8}},62}, {{{0,9}},220}, + {{{82,7}},27}, {{{0,8}},110}, {{{0,8}},46}, {{{0,9}},188}, + {{{0,8}},14}, {{{0,8}},142}, {{{0,8}},78}, {{{0,9}},252}, + {{{96,7}},256}, {{{0,8}},81}, {{{0,8}},17}, {{{85,8}},131}, + {{{82,7}},31}, {{{0,8}},113}, {{{0,8}},49}, {{{0,9}},194}, + {{{80,7}},10}, {{{0,8}},97}, {{{0,8}},33}, {{{0,9}},162}, + {{{0,8}},1}, {{{0,8}},129}, {{{0,8}},65}, {{{0,9}},226}, + {{{80,7}},6}, {{{0,8}},89}, {{{0,8}},25}, {{{0,9}},146}, + {{{83,7}},59}, {{{0,8}},121}, {{{0,8}},57}, {{{0,9}},210}, + {{{81,7}},17}, {{{0,8}},105}, {{{0,8}},41}, {{{0,9}},178}, + {{{0,8}},9}, {{{0,8}},137}, {{{0,8}},73}, {{{0,9}},242}, + {{{80,7}},4}, {{{0,8}},85}, {{{0,8}},21}, {{{80,8}},258}, + {{{83,7}},43}, {{{0,8}},117}, {{{0,8}},53}, {{{0,9}},202}, + {{{81,7}},13}, {{{0,8}},101}, {{{0,8}},37}, {{{0,9}},170}, + {{{0,8}},5}, {{{0,8}},133}, {{{0,8}},69}, {{{0,9}},234}, + {{{80,7}},8}, {{{0,8}},93}, {{{0,8}},29}, {{{0,9}},154}, + {{{84,7}},83}, {{{0,8}},125}, {{{0,8}},61}, {{{0,9}},218}, + {{{82,7}},23}, {{{0,8}},109}, {{{0,8}},45}, {{{0,9}},186}, + {{{0,8}},13}, {{{0,8}},141}, {{{0,8}},77}, {{{0,9}},250}, + {{{80,7}},3}, {{{0,8}},83}, {{{0,8}},19}, {{{85,8}},195}, + {{{83,7}},35}, {{{0,8}},115}, {{{0,8}},51}, {{{0,9}},198}, + {{{81,7}},11}, {{{0,8}},99}, {{{0,8}},35}, {{{0,9}},166}, + {{{0,8}},3}, {{{0,8}},131}, {{{0,8}},67}, {{{0,9}},230}, + {{{80,7}},7}, {{{0,8}},91}, {{{0,8}},27}, {{{0,9}},150}, + {{{84,7}},67}, {{{0,8}},123}, {{{0,8}},59}, {{{0,9}},214}, + {{{82,7}},19}, {{{0,8}},107}, {{{0,8}},43}, {{{0,9}},182}, + {{{0,8}},11}, {{{0,8}},139}, {{{0,8}},75}, {{{0,9}},246}, + {{{80,7}},5}, {{{0,8}},87}, {{{0,8}},23}, {{{192,8}},0}, + {{{83,7}},51}, {{{0,8}},119}, {{{0,8}},55}, {{{0,9}},206}, + {{{81,7}},15}, {{{0,8}},103}, {{{0,8}},39}, {{{0,9}},174}, + {{{0,8}},7}, {{{0,8}},135}, {{{0,8}},71}, {{{0,9}},238}, + {{{80,7}},9}, {{{0,8}},95}, {{{0,8}},31}, {{{0,9}},158}, + {{{84,7}},99}, {{{0,8}},127}, {{{0,8}},63}, {{{0,9}},222}, + {{{82,7}},27}, {{{0,8}},111}, {{{0,8}},47}, {{{0,9}},190}, + {{{0,8}},15}, {{{0,8}},143}, {{{0,8}},79}, {{{0,9}},254}, + {{{96,7}},256}, {{{0,8}},80}, {{{0,8}},16}, {{{84,8}},115}, + {{{82,7}},31}, {{{0,8}},112}, {{{0,8}},48}, {{{0,9}},193}, + {{{80,7}},10}, {{{0,8}},96}, {{{0,8}},32}, {{{0,9}},161}, + {{{0,8}},0}, {{{0,8}},128}, {{{0,8}},64}, {{{0,9}},225}, + {{{80,7}},6}, {{{0,8}},88}, {{{0,8}},24}, {{{0,9}},145}, + {{{83,7}},59}, {{{0,8}},120}, {{{0,8}},56}, {{{0,9}},209}, + {{{81,7}},17}, {{{0,8}},104}, {{{0,8}},40}, {{{0,9}},177}, + {{{0,8}},8}, {{{0,8}},136}, {{{0,8}},72}, {{{0,9}},241}, + {{{80,7}},4}, {{{0,8}},84}, {{{0,8}},20}, {{{85,8}},227}, + {{{83,7}},43}, {{{0,8}},116}, {{{0,8}},52}, {{{0,9}},201}, + {{{81,7}},13}, {{{0,8}},100}, {{{0,8}},36}, {{{0,9}},169}, + {{{0,8}},4}, {{{0,8}},132}, {{{0,8}},68}, {{{0,9}},233}, + {{{80,7}},8}, {{{0,8}},92}, {{{0,8}},28}, {{{0,9}},153}, + {{{84,7}},83}, {{{0,8}},124}, {{{0,8}},60}, {{{0,9}},217}, + {{{82,7}},23}, {{{0,8}},108}, {{{0,8}},44}, {{{0,9}},185}, + {{{0,8}},12}, {{{0,8}},140}, {{{0,8}},76}, {{{0,9}},249}, + {{{80,7}},3}, {{{0,8}},82}, {{{0,8}},18}, {{{85,8}},163}, + {{{83,7}},35}, {{{0,8}},114}, {{{0,8}},50}, {{{0,9}},197}, + {{{81,7}},11}, {{{0,8}},98}, {{{0,8}},34}, {{{0,9}},165}, + {{{0,8}},2}, {{{0,8}},130}, {{{0,8}},66}, {{{0,9}},229}, + {{{80,7}},7}, {{{0,8}},90}, {{{0,8}},26}, {{{0,9}},149}, + {{{84,7}},67}, {{{0,8}},122}, {{{0,8}},58}, {{{0,9}},213}, + {{{82,7}},19}, {{{0,8}},106}, {{{0,8}},42}, {{{0,9}},181}, + {{{0,8}},10}, {{{0,8}},138}, {{{0,8}},74}, {{{0,9}},245}, + {{{80,7}},5}, {{{0,8}},86}, {{{0,8}},22}, {{{192,8}},0}, + {{{83,7}},51}, {{{0,8}},118}, {{{0,8}},54}, {{{0,9}},205}, + {{{81,7}},15}, {{{0,8}},102}, {{{0,8}},38}, {{{0,9}},173}, + {{{0,8}},6}, {{{0,8}},134}, {{{0,8}},70}, {{{0,9}},237}, + {{{80,7}},9}, {{{0,8}},94}, {{{0,8}},30}, {{{0,9}},157}, + {{{84,7}},99}, {{{0,8}},126}, {{{0,8}},62}, {{{0,9}},221}, + {{{82,7}},27}, {{{0,8}},110}, {{{0,8}},46}, {{{0,9}},189}, + {{{0,8}},14}, {{{0,8}},142}, {{{0,8}},78}, {{{0,9}},253}, + {{{96,7}},256}, {{{0,8}},81}, {{{0,8}},17}, {{{85,8}},131}, + {{{82,7}},31}, {{{0,8}},113}, {{{0,8}},49}, {{{0,9}},195}, + {{{80,7}},10}, {{{0,8}},97}, {{{0,8}},33}, {{{0,9}},163}, + {{{0,8}},1}, {{{0,8}},129}, {{{0,8}},65}, {{{0,9}},227}, + {{{80,7}},6}, {{{0,8}},89}, {{{0,8}},25}, {{{0,9}},147}, + {{{83,7}},59}, {{{0,8}},121}, {{{0,8}},57}, {{{0,9}},211}, + {{{81,7}},17}, {{{0,8}},105}, {{{0,8}},41}, {{{0,9}},179}, + {{{0,8}},9}, {{{0,8}},137}, {{{0,8}},73}, {{{0,9}},243}, + {{{80,7}},4}, {{{0,8}},85}, {{{0,8}},21}, {{{80,8}},258}, + {{{83,7}},43}, {{{0,8}},117}, {{{0,8}},53}, {{{0,9}},203}, + {{{81,7}},13}, {{{0,8}},101}, {{{0,8}},37}, {{{0,9}},171}, + {{{0,8}},5}, {{{0,8}},133}, {{{0,8}},69}, {{{0,9}},235}, + {{{80,7}},8}, {{{0,8}},93}, {{{0,8}},29}, {{{0,9}},155}, + {{{84,7}},83}, {{{0,8}},125}, {{{0,8}},61}, {{{0,9}},219}, + {{{82,7}},23}, {{{0,8}},109}, {{{0,8}},45}, {{{0,9}},187}, + {{{0,8}},13}, {{{0,8}},141}, {{{0,8}},77}, {{{0,9}},251}, + {{{80,7}},3}, {{{0,8}},83}, {{{0,8}},19}, {{{85,8}},195}, + {{{83,7}},35}, {{{0,8}},115}, {{{0,8}},51}, {{{0,9}},199}, + {{{81,7}},11}, {{{0,8}},99}, {{{0,8}},35}, {{{0,9}},167}, + {{{0,8}},3}, {{{0,8}},131}, {{{0,8}},67}, {{{0,9}},231}, + {{{80,7}},7}, {{{0,8}},91}, {{{0,8}},27}, {{{0,9}},151}, + {{{84,7}},67}, {{{0,8}},123}, {{{0,8}},59}, {{{0,9}},215}, + {{{82,7}},19}, {{{0,8}},107}, {{{0,8}},43}, {{{0,9}},183}, + {{{0,8}},11}, {{{0,8}},139}, {{{0,8}},75}, {{{0,9}},247}, + {{{80,7}},5}, {{{0,8}},87}, {{{0,8}},23}, {{{192,8}},0}, + {{{83,7}},51}, {{{0,8}},119}, {{{0,8}},55}, {{{0,9}},207}, + {{{81,7}},15}, {{{0,8}},103}, {{{0,8}},39}, {{{0,9}},175}, + {{{0,8}},7}, {{{0,8}},135}, {{{0,8}},71}, {{{0,9}},239}, + {{{80,7}},9}, {{{0,8}},95}, {{{0,8}},31}, {{{0,9}},159}, + {{{84,7}},99}, {{{0,8}},127}, {{{0,8}},63}, {{{0,9}},223}, + {{{82,7}},27}, {{{0,8}},111}, {{{0,8}},47}, {{{0,9}},191}, + {{{0,8}},15}, {{{0,8}},143}, {{{0,8}},79}, {{{0,9}},255} + }; +local inflate_huft fixed_td[] = { + {{{80,5}},1}, {{{87,5}},257}, {{{83,5}},17}, {{{91,5}},4097}, + {{{81,5}},5}, {{{89,5}},1025}, {{{85,5}},65}, {{{93,5}},16385}, + {{{80,5}},3}, {{{88,5}},513}, {{{84,5}},33}, {{{92,5}},8193}, + {{{82,5}},9}, {{{90,5}},2049}, {{{86,5}},129}, {{{192,5}},24577}, + {{{80,5}},2}, {{{87,5}},385}, {{{83,5}},25}, {{{91,5}},6145}, + {{{81,5}},7}, {{{89,5}},1537}, {{{85,5}},97}, {{{93,5}},24577}, + {{{80,5}},4}, {{{88,5}},769}, {{{84,5}},49}, {{{92,5}},12289}, + {{{82,5}},13}, {{{90,5}},3073}, {{{86,5}},193}, {{{192,5}},24577} + }; diff --git a/utils/vmpi/ZLib/inftrees.h b/utils/vmpi/ZLib/inftrees.h new file mode 100644 index 0000000..85853e0 --- /dev/null +++ b/utils/vmpi/ZLib/inftrees.h @@ -0,0 +1,58 @@ +/* inftrees.h -- header to use inftrees.c + * Copyright (C) 1995-1998 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + +/* Huffman code lookup table entry--this entry is four bytes for machines + that have 16-bit pointers (e.g. PC's in the small or medium model). */ + +typedef struct inflate_huft_s FAR inflate_huft; + +struct inflate_huft_s { + union { + struct { + Byte Exop; /* number of extra bits or operation */ + Byte Bits; /* number of bits in this code or subcode */ + } what; + uInt pad; /* pad structure to a power of 2 (4 bytes for */ + } word; /* 16-bit, 8 bytes for 32-bit int's) */ + uInt base; /* literal, length base, distance base, + or table offset */ +}; + +/* Maximum size of dynamic tree. The maximum found in a long but non- + exhaustive search was 1004 huft structures (850 for length/literals + and 154 for distances, the latter actually the result of an + exhaustive search). The actual maximum is not known, but the + value below is more than safe. */ +#define MANY 1440 + +extern int inflate_trees_bits OF(( + uIntf *, /* 19 code lengths */ + uIntf *, /* bits tree desired/actual depth */ + inflate_huft * FAR *, /* bits tree result */ + inflate_huft *, /* space for trees */ + z_streamp)); /* for messages */ + +extern int inflate_trees_dynamic OF(( + uInt, /* number of literal/length codes */ + uInt, /* number of distance codes */ + uIntf *, /* that many (total) code lengths */ + uIntf *, /* literal desired/actual bit depth */ + uIntf *, /* distance desired/actual bit depth */ + inflate_huft * FAR *, /* literal/length tree result */ + inflate_huft * FAR *, /* distance tree result */ + inflate_huft *, /* space for trees */ + z_streamp)); /* for messages */ + +extern int inflate_trees_fixed OF(( + uIntf *, /* literal desired/actual bit depth */ + uIntf *, /* distance desired/actual bit depth */ + inflate_huft * FAR *, /* literal/length tree result */ + inflate_huft * FAR *, /* distance tree result */ + z_streamp)); /* for memory allocation */ diff --git a/utils/vmpi/ZLib/infutil.h b/utils/vmpi/ZLib/infutil.h new file mode 100644 index 0000000..99d1135 --- /dev/null +++ b/utils/vmpi/ZLib/infutil.h @@ -0,0 +1,98 @@ +/* infutil.h -- types and macros common to blocks and codes + * Copyright (C) 1995-1998 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + +#ifndef _INFUTIL_H +#define _INFUTIL_H + +typedef enum { + TYPE, /* get type bits (3, including end bit) */ + LENS, /* get lengths for stored */ + STORED, /* processing stored block */ + TABLE, /* get table lengths */ + BTREE, /* get bit lengths tree for a dynamic block */ + DTREE, /* get length, distance trees for a dynamic block */ + CODES, /* processing fixed or dynamic block */ + DRY, /* output remaining window bytes */ + DONE, /* finished last block, done */ + BAD} /* got a data error--stuck here */ +inflate_block_mode; + +/* inflate blocks semi-private state */ +struct inflate_blocks_state { + + /* mode */ + inflate_block_mode mode; /* current inflate_block mode */ + + /* mode dependent information */ + union { + uInt left; /* if STORED, bytes left to copy */ + struct { + uInt table; /* table lengths (14 bits) */ + uInt index; /* index into blens (or border) */ + uIntf *blens; /* bit lengths of codes */ + uInt bb; /* bit length tree depth */ + inflate_huft *tb; /* bit length decoding tree */ + } trees; /* if DTREE, decoding info for trees */ + struct { + inflate_codes_statef + *codes; + } decode; /* if CODES, current state */ + } sub; /* submode */ + uInt last; /* true if this block is the last block */ + + /* mode independent information */ + uInt bitk; /* bits in bit buffer */ + uLong bitb; /* bit buffer */ + inflate_huft *hufts; /* single malloc for tree space */ + Bytef *window; /* sliding window */ + Bytef *end; /* one byte after sliding window */ + Bytef *read; /* window read pointer */ + Bytef *write; /* window write pointer */ + check_func checkfn; /* check function */ + uLong check; /* check on output */ + +}; + + +/* defines for inflate input/output */ +/* update pointers and return */ +#define UPDBITS {s->bitb=b;s->bitk=k;} +#define UPDIN {z->avail_in=n;z->total_in+=p-z->next_in;z->next_in=p;} +#define UPDOUT {s->write=q;} +#define UPDATE {UPDBITS UPDIN UPDOUT} +#define LEAVE {UPDATE return inflate_flush(s,z,r);} +/* get bytes and bits */ +#define LOADIN {p=z->next_in;n=z->avail_in;b=s->bitb;k=s->bitk;} +#define NEEDBYTE {if(n)r=Z_OK;else LEAVE} +#define NEXTBYTE (n--,*p++) +#define NEEDBITS(j) {while(k<(j)){NEEDBYTE;b|=((uLong)NEXTBYTE)<<k;k+=8;}} +#define DUMPBITS(j) {b>>=(j);k-=(j);} +/* output bytes */ +#define WAVAIL (uInt)(q<s->read?s->read-q-1:s->end-q) +#define LOADOUT {q=s->write;m=(uInt)WAVAIL;} +#define WRAP {if(q==s->end&&s->read!=s->window){q=s->window;m=(uInt)WAVAIL;}} +#define FLUSH {UPDOUT r=inflate_flush(s,z,r); LOADOUT} +#define NEEDOUT {if(m==0){WRAP if(m==0){FLUSH WRAP if(m==0) LEAVE}}r=Z_OK;} +#define OUTBYTE(a) {*q++=(Byte)(a);m--;} +/* load local pointers */ +#define LOAD {LOADIN LOADOUT} + +/* masks for lower bits (size given to avoid silly warnings with Visual C++) */ +extern uInt inflate_mask[17]; + +/* copy as much as possible from the sliding window to the output area */ +extern int inflate_flush OF(( + inflate_blocks_statef *, + z_streamp , + int)); + +struct internal_state {int dummy;}; /* for buggy compilers */ + +#endif diff --git a/utils/vmpi/ZLib/trees.h b/utils/vmpi/ZLib/trees.h new file mode 100644 index 0000000..72facf9 --- /dev/null +++ b/utils/vmpi/ZLib/trees.h @@ -0,0 +1,128 @@ +/* header created automatically with -DGEN_TREES_H */ + +local const ct_data static_ltree[L_CODES+2] = { +{{ 12},{ 8}}, {{140},{ 8}}, {{ 76},{ 8}}, {{204},{ 8}}, {{ 44},{ 8}}, +{{172},{ 8}}, {{108},{ 8}}, {{236},{ 8}}, {{ 28},{ 8}}, {{156},{ 8}}, +{{ 92},{ 8}}, {{220},{ 8}}, {{ 60},{ 8}}, {{188},{ 8}}, {{124},{ 8}}, +{{252},{ 8}}, {{ 2},{ 8}}, {{130},{ 8}}, {{ 66},{ 8}}, {{194},{ 8}}, +{{ 34},{ 8}}, {{162},{ 8}}, {{ 98},{ 8}}, {{226},{ 8}}, {{ 18},{ 8}}, +{{146},{ 8}}, {{ 82},{ 8}}, {{210},{ 8}}, {{ 50},{ 8}}, {{178},{ 8}}, +{{114},{ 8}}, {{242},{ 8}}, {{ 10},{ 8}}, {{138},{ 8}}, {{ 74},{ 8}}, +{{202},{ 8}}, {{ 42},{ 8}}, {{170},{ 8}}, {{106},{ 8}}, {{234},{ 8}}, +{{ 26},{ 8}}, {{154},{ 8}}, {{ 90},{ 8}}, {{218},{ 8}}, {{ 58},{ 8}}, +{{186},{ 8}}, {{122},{ 8}}, {{250},{ 8}}, {{ 6},{ 8}}, {{134},{ 8}}, +{{ 70},{ 8}}, {{198},{ 8}}, {{ 38},{ 8}}, {{166},{ 8}}, {{102},{ 8}}, +{{230},{ 8}}, {{ 22},{ 8}}, {{150},{ 8}}, {{ 86},{ 8}}, {{214},{ 8}}, +{{ 54},{ 8}}, {{182},{ 8}}, {{118},{ 8}}, {{246},{ 8}}, {{ 14},{ 8}}, +{{142},{ 8}}, {{ 78},{ 8}}, {{206},{ 8}}, {{ 46},{ 8}}, {{174},{ 8}}, +{{110},{ 8}}, {{238},{ 8}}, {{ 30},{ 8}}, {{158},{ 8}}, {{ 94},{ 8}}, +{{222},{ 8}}, {{ 62},{ 8}}, {{190},{ 8}}, {{126},{ 8}}, {{254},{ 8}}, +{{ 1},{ 8}}, {{129},{ 8}}, {{ 65},{ 8}}, {{193},{ 8}}, {{ 33},{ 8}}, +{{161},{ 8}}, {{ 97},{ 8}}, {{225},{ 8}}, {{ 17},{ 8}}, {{145},{ 8}}, +{{ 81},{ 8}}, {{209},{ 8}}, {{ 49},{ 8}}, {{177},{ 8}}, {{113},{ 8}}, +{{241},{ 8}}, {{ 9},{ 8}}, {{137},{ 8}}, {{ 73},{ 8}}, {{201},{ 8}}, +{{ 41},{ 8}}, {{169},{ 8}}, {{105},{ 8}}, {{233},{ 8}}, {{ 25},{ 8}}, +{{153},{ 8}}, {{ 89},{ 8}}, {{217},{ 8}}, {{ 57},{ 8}}, {{185},{ 8}}, +{{121},{ 8}}, {{249},{ 8}}, {{ 5},{ 8}}, {{133},{ 8}}, {{ 69},{ 8}}, +{{197},{ 8}}, {{ 37},{ 8}}, {{165},{ 8}}, {{101},{ 8}}, {{229},{ 8}}, +{{ 21},{ 8}}, {{149},{ 8}}, {{ 85},{ 8}}, {{213},{ 8}}, {{ 53},{ 8}}, +{{181},{ 8}}, {{117},{ 8}}, {{245},{ 8}}, {{ 13},{ 8}}, {{141},{ 8}}, +{{ 77},{ 8}}, {{205},{ 8}}, {{ 45},{ 8}}, {{173},{ 8}}, {{109},{ 8}}, +{{237},{ 8}}, {{ 29},{ 8}}, {{157},{ 8}}, {{ 93},{ 8}}, {{221},{ 8}}, +{{ 61},{ 8}}, {{189},{ 8}}, {{125},{ 8}}, {{253},{ 8}}, {{ 19},{ 9}}, +{{275},{ 9}}, {{147},{ 9}}, {{403},{ 9}}, {{ 83},{ 9}}, {{339},{ 9}}, +{{211},{ 9}}, {{467},{ 9}}, {{ 51},{ 9}}, {{307},{ 9}}, {{179},{ 9}}, +{{435},{ 9}}, {{115},{ 9}}, {{371},{ 9}}, {{243},{ 9}}, {{499},{ 9}}, +{{ 11},{ 9}}, {{267},{ 9}}, {{139},{ 9}}, {{395},{ 9}}, {{ 75},{ 9}}, +{{331},{ 9}}, {{203},{ 9}}, {{459},{ 9}}, {{ 43},{ 9}}, {{299},{ 9}}, +{{171},{ 9}}, {{427},{ 9}}, {{107},{ 9}}, {{363},{ 9}}, {{235},{ 9}}, +{{491},{ 9}}, {{ 27},{ 9}}, {{283},{ 9}}, {{155},{ 9}}, {{411},{ 9}}, +{{ 91},{ 9}}, {{347},{ 9}}, {{219},{ 9}}, {{475},{ 9}}, {{ 59},{ 9}}, +{{315},{ 9}}, {{187},{ 9}}, {{443},{ 9}}, {{123},{ 9}}, {{379},{ 9}}, +{{251},{ 9}}, {{507},{ 9}}, {{ 7},{ 9}}, {{263},{ 9}}, {{135},{ 9}}, +{{391},{ 9}}, {{ 71},{ 9}}, {{327},{ 9}}, {{199},{ 9}}, {{455},{ 9}}, +{{ 39},{ 9}}, {{295},{ 9}}, {{167},{ 9}}, {{423},{ 9}}, {{103},{ 9}}, +{{359},{ 9}}, {{231},{ 9}}, {{487},{ 9}}, {{ 23},{ 9}}, {{279},{ 9}}, +{{151},{ 9}}, {{407},{ 9}}, {{ 87},{ 9}}, {{343},{ 9}}, {{215},{ 9}}, +{{471},{ 9}}, {{ 55},{ 9}}, {{311},{ 9}}, {{183},{ 9}}, {{439},{ 9}}, +{{119},{ 9}}, {{375},{ 9}}, {{247},{ 9}}, {{503},{ 9}}, {{ 15},{ 9}}, +{{271},{ 9}}, {{143},{ 9}}, {{399},{ 9}}, {{ 79},{ 9}}, {{335},{ 9}}, +{{207},{ 9}}, {{463},{ 9}}, {{ 47},{ 9}}, {{303},{ 9}}, {{175},{ 9}}, +{{431},{ 9}}, {{111},{ 9}}, {{367},{ 9}}, {{239},{ 9}}, {{495},{ 9}}, +{{ 31},{ 9}}, {{287},{ 9}}, {{159},{ 9}}, {{415},{ 9}}, {{ 95},{ 9}}, +{{351},{ 9}}, {{223},{ 9}}, {{479},{ 9}}, {{ 63},{ 9}}, {{319},{ 9}}, +{{191},{ 9}}, {{447},{ 9}}, {{127},{ 9}}, {{383},{ 9}}, {{255},{ 9}}, +{{511},{ 9}}, {{ 0},{ 7}}, {{ 64},{ 7}}, {{ 32},{ 7}}, {{ 96},{ 7}}, +{{ 16},{ 7}}, {{ 80},{ 7}}, {{ 48},{ 7}}, {{112},{ 7}}, {{ 8},{ 7}}, +{{ 72},{ 7}}, {{ 40},{ 7}}, {{104},{ 7}}, {{ 24},{ 7}}, {{ 88},{ 7}}, +{{ 56},{ 7}}, {{120},{ 7}}, {{ 4},{ 7}}, {{ 68},{ 7}}, {{ 36},{ 7}}, +{{100},{ 7}}, {{ 20},{ 7}}, {{ 84},{ 7}}, {{ 52},{ 7}}, {{116},{ 7}}, +{{ 3},{ 8}}, {{131},{ 8}}, {{ 67},{ 8}}, {{195},{ 8}}, {{ 35},{ 8}}, +{{163},{ 8}}, {{ 99},{ 8}}, {{227},{ 8}} +}; + +local const ct_data static_dtree[D_CODES] = { +{{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}}, +{{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}}, +{{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}}, +{{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}}, +{{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}}, +{{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}} +}; + +const uch _dist_code[DIST_CODE_LEN] = { + 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, + 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, +10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, +11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, +12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, +13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, +13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, +15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, +15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, +15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 16, 17, +18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, +23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, +27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, +29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, +29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, +29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29 +}; + +const uch _length_code[MAX_MATCH-MIN_MATCH+1]= { + 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 12, +13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, +17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, +19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, +21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, +22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, +23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, +25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28 +}; + +local const int base_length[LENGTH_CODES] = { +0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56, +64, 80, 96, 112, 128, 160, 192, 224, 0 +}; + +local const int base_dist[D_CODES] = { + 0, 1, 2, 3, 4, 6, 8, 12, 16, 24, + 32, 48, 64, 96, 128, 192, 256, 384, 512, 768, + 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576 +}; + diff --git a/utils/vmpi/ZLib/zconf.h b/utils/vmpi/ZLib/zconf.h new file mode 100644 index 0000000..6d450fc --- /dev/null +++ b/utils/vmpi/ZLib/zconf.h @@ -0,0 +1,279 @@ +/* zconf.h -- configuration of the zlib compression library + * Copyright (C) 1995-1998 Jean-loup Gailly. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* @(#) $Id$ */ + +#ifndef _ZCONF_H +#define _ZCONF_H + +/* + * If you *really* need a unique prefix for all types and library functions, + * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. + */ +#ifdef Z_PREFIX +# define deflateInit_ z_deflateInit_ +# define deflate z_deflate +# define deflateEnd z_deflateEnd +# define inflateInit_ z_inflateInit_ +# define inflate z_inflate +# define inflateEnd z_inflateEnd +# define deflateInit2_ z_deflateInit2_ +# define deflateSetDictionary z_deflateSetDictionary +# define deflateCopy z_deflateCopy +# define deflateReset z_deflateReset +# define deflateParams z_deflateParams +# define inflateInit2_ z_inflateInit2_ +# define inflateSetDictionary z_inflateSetDictionary +# define inflateSync z_inflateSync +# define inflateSyncPoint z_inflateSyncPoint +# define inflateReset z_inflateReset +# define compress z_compress +# define compress2 z_compress2 +# define uncompress z_uncompress +# define adler32 z_adler32 +# define crc32 z_crc32 +# define get_crc_table z_get_crc_table + +# define Byte z_Byte +# define uInt z_uInt +# define uLong z_uLong +# define Bytef z_Bytef +# define charf z_charf +# define intf z_intf +# define uIntf z_uIntf +# define uLongf z_uLongf +# define voidpf z_voidpf +# define voidp z_voidp +#endif + +#if (defined(_WIN32) || defined(__WIN32__)) && !defined(WIN32) +# define WIN32 +#endif +#if defined(__GNUC__) || defined(WIN32) || defined(__386__) || defined(i386) +# ifndef __32BIT__ +# define __32BIT__ +# endif +#endif +#if defined(__MSDOS__) && !defined(MSDOS) +# define MSDOS +#endif + +/* + * Compile with -DMAXSEG_64K if the alloc function cannot allocate more + * than 64k bytes at a time (needed on systems with 16-bit int). + */ +#if defined(MSDOS) && !defined(__32BIT__) +# define MAXSEG_64K +#endif +#ifdef MSDOS +# define UNALIGNED_OK +#endif + +#if (defined(MSDOS) || defined(_WINDOWS) || defined(WIN32)) && !defined(STDC) +# define STDC +#endif +#if defined(__STDC__) || defined(__cplusplus) || defined(__OS2__) +# ifndef STDC +# define STDC +# endif +#endif + +#ifndef STDC +# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ +# define const +# endif +#endif + +/* Some Mac compilers merge all .h files incorrectly: */ +#if defined(__MWERKS__) || defined(applec) ||defined(THINK_C) ||defined(__SC__) +# define NO_DUMMY_DECL +#endif + +/* Old Borland C incorrectly complains about missing returns: */ +#if defined(__BORLANDC__) && (__BORLANDC__ < 0x500) +# define NEED_DUMMY_RETURN +#endif + + +/* Maximum value for memLevel in deflateInit2 */ +#ifndef MAX_MEM_LEVEL +# ifdef MAXSEG_64K +# define MAX_MEM_LEVEL 8 +# else +# define MAX_MEM_LEVEL 9 +# endif +#endif + +/* Maximum value for windowBits in deflateInit2 and inflateInit2. + * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files + * created by gzip. (Files created by minigzip can still be extracted by + * gzip.) + */ +#ifndef MAX_WBITS +# define MAX_WBITS 15 /* 32K LZ77 window */ +#endif + +/* The memory requirements for deflate are (in bytes): + (1 << (windowBits+2)) + (1 << (memLevel+9)) + that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) + plus a few kilobytes for small objects. For example, if you want to reduce + the default memory requirements from 256K to 128K, compile with + make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" + Of course this will generally degrade compression (there's no free lunch). + + The memory requirements for inflate are (in bytes) 1 << windowBits + that is, 32K for windowBits=15 (default value) plus a few kilobytes + for small objects. +*/ + + /* Type declarations */ + +#ifndef OF /* function prototypes */ +# ifdef STDC +# define OF(args) args +# else +# define OF(args) () +# endif +#endif + +/* The following definitions for FAR are needed only for MSDOS mixed + * model programming (small or medium model with some far allocations). + * This was tested only with MSC; for other MSDOS compilers you may have + * to define NO_MEMCPY in zutil.h. If you don't need the mixed model, + * just define FAR to be empty. + */ +#if (defined(M_I86SM) || defined(M_I86MM)) && !defined(__32BIT__) + /* MSC small or medium model */ +# define SMALL_MEDIUM +# ifdef _MSC_VER +# define FAR _far +# else +# define FAR far +# endif +#endif +#if defined(__BORLANDC__) && (defined(__SMALL__) || defined(__MEDIUM__)) +# ifndef __32BIT__ +# define SMALL_MEDIUM +# define FAR _far +# endif +#endif + +/* Compile with -DZLIB_DLL for Windows DLL support */ +#if defined(ZLIB_DLL) +# if defined(_WINDOWS) || defined(WINDOWS) +# ifdef FAR +# undef FAR +# endif +# include <windows.h> +# define ZEXPORT WINAPI +# ifdef WIN32 +# define ZEXPORTVA WINAPIV +# else +# define ZEXPORTVA FAR _cdecl _export +# endif +# endif +# if defined (__BORLANDC__) +# if (__BORLANDC__ >= 0x0500) && defined (WIN32) +# include <windows.h> +# define ZEXPORT __declspec(dllexport) WINAPI +# define ZEXPORTRVA __declspec(dllexport) WINAPIV +# else +# if defined (_Windows) && defined (__DLL__) +# define ZEXPORT _export +# define ZEXPORTVA _export +# endif +# endif +# endif +#endif + +#if defined (__BEOS__) +# if defined (ZLIB_DLL) +# define ZEXTERN extern __declspec(dllexport) +# else +# define ZEXTERN extern __declspec(dllimport) +# endif +#endif + +#ifndef ZEXPORT +# define ZEXPORT +#endif +#ifndef ZEXPORTVA +# define ZEXPORTVA +#endif +#ifndef ZEXTERN +# define ZEXTERN extern +#endif + +#ifndef FAR +# define FAR +#endif + +#if !defined(MACOS) && !defined(TARGET_OS_MAC) +typedef unsigned char Byte; /* 8 bits */ +#endif +typedef unsigned int uInt; /* 16 bits or more */ +typedef unsigned long uLong; /* 32 bits or more */ + +#ifdef SMALL_MEDIUM + /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ +# define Bytef Byte FAR +#else + typedef Byte FAR Bytef; +#endif +typedef char FAR charf; +typedef int FAR intf; +typedef uInt FAR uIntf; +typedef uLong FAR uLongf; + +#ifdef STDC + typedef void FAR *voidpf; + typedef void *voidp; +#else + typedef Byte FAR *voidpf; + typedef Byte *voidp; +#endif + +#ifdef HAVE_UNISTD_H +# include <sys/types.h> /* for off_t */ +# include <unistd.h> /* for SEEK_* and off_t */ +# define z_off_t off_t +#endif +#ifndef SEEK_SET +# define SEEK_SET 0 /* Seek from beginning of file. */ +# define SEEK_CUR 1 /* Seek from current position. */ +# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ +#endif +#ifndef z_off_t +# define z_off_t long +#endif + +/* MVS linker does not support external names larger than 8 bytes */ +#if defined(__MVS__) +# pragma map(deflateInit_,"DEIN") +# pragma map(deflateInit2_,"DEIN2") +# pragma map(deflateEnd,"DEEND") +# pragma map(inflateInit_,"ININ") +# pragma map(inflateInit2_,"ININ2") +# pragma map(inflateEnd,"INEND") +# pragma map(inflateSync,"INSY") +# pragma map(inflateSetDictionary,"INSEDI") +# pragma map(inflate_blocks,"INBL") +# pragma map(inflate_blocks_new,"INBLNE") +# pragma map(inflate_blocks_free,"INBLFR") +# pragma map(inflate_blocks_reset,"INBLRE") +# pragma map(inflate_codes_free,"INCOFR") +# pragma map(inflate_codes,"INCO") +# pragma map(inflate_fast,"INFA") +# pragma map(inflate_flush,"INFLU") +# pragma map(inflate_mask,"INMA") +# pragma map(inflate_set_dictionary,"INSEDI2") +# pragma map(inflate_copyright,"INCOPY") +# pragma map(inflate_trees_bits,"INTRBI") +# pragma map(inflate_trees_dynamic,"INTRDY") +# pragma map(inflate_trees_fixed,"INTRFI") +# pragma map(inflate_trees_free,"INTRFR") +#endif + +#endif /* _ZCONF_H */ diff --git a/utils/vmpi/ZLib/zlib.h b/utils/vmpi/ZLib/zlib.h new file mode 100644 index 0000000..49f56b4 --- /dev/null +++ b/utils/vmpi/ZLib/zlib.h @@ -0,0 +1,893 @@ +/* zlib.h -- interface of the 'zlib' general purpose compression library + version 1.1.3, July 9th, 1998 + + Copyright (C) 1995-1998 Jean-loup Gailly and Mark Adler + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + Jean-loup Gailly Mark Adler + + + The data format used by the zlib library is described by RFCs (Request for + Comments) 1950 to 1952 in the files ftp://ds.internic.net/rfc/rfc1950.txt + (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format). +*/ + +#ifndef _ZLIB_H +#define _ZLIB_H + +#include "zconf.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define ZLIB_VERSION "1.1.3" + +/* + The 'zlib' compression library provides in-memory compression and + decompression functions, including integrity checks of the uncompressed + data. This version of the library supports only one compression method + (deflation) but other algorithms will be added later and will have the same + stream interface. + + Compression can be done in a single step if the buffers are large + enough (for example if an input file is mmap'ed), or can be done by + repeated calls of the compression function. In the latter case, the + application must provide more input and/or consume the output + (providing more output space) before each call. + + The library also supports reading and writing files in gzip (.gz) format + with an interface similar to that of stdio. + + The library does not install any signal handler. The decoder checks + the consistency of the compressed data, so the library should never + crash even in case of corrupted input. +*/ + +typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); +typedef void (*free_func) OF((voidpf opaque, voidpf address)); + +struct internal_state; + +typedef struct z_stream_s { + Bytef *next_in; /* next input byte */ + uInt avail_in; /* number of bytes available at next_in */ + uLong total_in; /* total nb of input bytes read so far */ + + Bytef *next_out; /* next output byte should be put there */ + uInt avail_out; /* remaining free space at next_out */ + uLong total_out; /* total nb of bytes output so far */ + + char *msg; /* last error message, NULL if no error */ + struct internal_state FAR *state; /* not visible by applications */ + + alloc_func zalloc; /* used to allocate the internal state */ + free_func zfree; /* used to free the internal state */ + voidpf opaque; /* private data object passed to zalloc and zfree */ + + int data_type; /* best guess about the data type: ascii or binary */ + uLong adler; /* adler32 value of the uncompressed data */ + uLong reserved; /* reserved for future use */ +} z_stream; + +typedef z_stream FAR *z_streamp; + +/* + The application must update next_in and avail_in when avail_in has + dropped to zero. It must update next_out and avail_out when avail_out + has dropped to zero. The application must initialize zalloc, zfree and + opaque before calling the init function. All other fields are set by the + compression library and must not be updated by the application. + + The opaque value provided by the application will be passed as the first + parameter for calls of zalloc and zfree. This can be useful for custom + memory management. The compression library attaches no meaning to the + opaque value. + + zalloc must return Z_NULL if there is not enough memory for the object. + If zlib is used in a multi-threaded application, zalloc and zfree must be + thread safe. + + On 16-bit systems, the functions zalloc and zfree must be able to allocate + exactly 65536 bytes, but will not be required to allocate more than this + if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS, + pointers returned by zalloc for objects of exactly 65536 bytes *must* + have their offset normalized to zero. The default allocation function + provided by this library ensures this (see zutil.c). To reduce memory + requirements and avoid any allocation of 64K objects, at the expense of + compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h). + + The fields total_in and total_out can be used for statistics or + progress reports. After compression, total_in holds the total size of + the uncompressed data and may be saved for use in the decompressor + (particularly if the decompressor wants to decompress everything in + a single step). +*/ + + /* constants */ + +#define Z_NO_FLUSH 0 +#define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */ +#define Z_SYNC_FLUSH 2 +#define Z_FULL_FLUSH 3 +#define Z_FINISH 4 +/* Allowed flush values; see deflate() below for details */ + +#define Z_OK 0 +#define Z_STREAM_END 1 +#define Z_NEED_DICT 2 +#define Z_ERRNO (-1) +#define Z_STREAM_ERROR (-2) +#define Z_DATA_ERROR (-3) +#define Z_MEM_ERROR (-4) +#define Z_BUF_ERROR (-5) +#define Z_VERSION_ERROR (-6) +/* Return codes for the compression/decompression functions. Negative + * values are errors, positive values are used for special but normal events. + */ + +#define Z_NO_COMPRESSION 0 +#define Z_BEST_SPEED 1 +#define Z_BEST_COMPRESSION 9 +#define Z_DEFAULT_COMPRESSION (-1) +/* compression levels */ + +#define Z_FILTERED 1 +#define Z_HUFFMAN_ONLY 2 +#define Z_DEFAULT_STRATEGY 0 +/* compression strategy; see deflateInit2() below for details */ + +#define Z_BINARY 0 +#define Z_ASCII 1 +#define Z_UNKNOWN 2 +/* Possible values of the data_type field */ + +#define Z_DEFLATED 8 +/* The deflate compression method (the only one supported in this version) */ + +#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ + +#define zlib_version zlibVersion() +/* for compatibility with versions < 1.0.2 */ + + /* basic functions */ + +ZEXTERN const char * ZEXPORT zlibVersion OF((void)); +/* The application can compare zlibVersion and ZLIB_VERSION for consistency. + If the first character differs, the library code actually used is + not compatible with the zlib.h header file used by the application. + This check is automatically made by deflateInit and inflateInit. + */ + +/* +ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); + + Initializes the internal stream state for compression. The fields + zalloc, zfree and opaque must be initialized before by the caller. + If zalloc and zfree are set to Z_NULL, deflateInit updates them to + use default allocation functions. + + The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9: + 1 gives best speed, 9 gives best compression, 0 gives no compression at + all (the input data is simply copied a block at a time). + Z_DEFAULT_COMPRESSION requests a default compromise between speed and + compression (currently equivalent to level 6). + + deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_STREAM_ERROR if level is not a valid compression level, + Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible + with the version assumed by the caller (ZLIB_VERSION). + msg is set to null if there is no error message. deflateInit does not + perform any compression: this will be done by deflate(). +*/ + + +ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); +/* + deflate compresses as much data as possible, and stops when the input + buffer becomes empty or the output buffer becomes full. It may introduce some + output latency (reading input without producing any output) except when + forced to flush. + + The detailed semantics are as follows. deflate performs one or both of the + following actions: + + - Compress more input starting at next_in and update next_in and avail_in + accordingly. If not all input can be processed (because there is not + enough room in the output buffer), next_in and avail_in are updated and + processing will resume at this point for the next call of deflate(). + + - Provide more output starting at next_out and update next_out and avail_out + accordingly. This action is forced if the parameter flush is non zero. + Forcing flush frequently degrades the compression ratio, so this parameter + should be set only when necessary (in interactive applications). + Some output may be provided even if flush is not set. + + Before the call of deflate(), the application should ensure that at least + one of the actions is possible, by providing more input and/or consuming + more output, and updating avail_in or avail_out accordingly; avail_out + should never be zero before the call. The application can consume the + compressed output when it wants, for example when the output buffer is full + (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK + and with zero avail_out, it must be called again after making room in the + output buffer because there might be more output pending. + + If the parameter flush is set to Z_SYNC_FLUSH, all pending output is + flushed to the output buffer and the output is aligned on a byte boundary, so + that the decompressor can get all input data available so far. (In particular + avail_in is zero after the call if enough output space has been provided + before the call.) Flushing may degrade compression for some compression + algorithms and so it should be used only when necessary. + + If flush is set to Z_FULL_FLUSH, all output is flushed as with + Z_SYNC_FLUSH, and the compression state is reset so that decompression can + restart from this point if previous compressed data has been damaged or if + random access is desired. Using Z_FULL_FLUSH too often can seriously degrade + the compression. + + If deflate returns with avail_out == 0, this function must be called again + with the same value of the flush parameter and more output space (updated + avail_out), until the flush is complete (deflate returns with non-zero + avail_out). + + If the parameter flush is set to Z_FINISH, pending input is processed, + pending output is flushed and deflate returns with Z_STREAM_END if there + was enough output space; if deflate returns with Z_OK, this function must be + called again with Z_FINISH and more output space (updated avail_out) but no + more input data, until it returns with Z_STREAM_END or an error. After + deflate has returned Z_STREAM_END, the only possible operations on the + stream are deflateReset or deflateEnd. + + Z_FINISH can be used immediately after deflateInit if all the compression + is to be done in a single step. In this case, avail_out must be at least + 0.1% larger than avail_in plus 12 bytes. If deflate does not return + Z_STREAM_END, then it must be called again as described above. + + deflate() sets strm->adler to the adler32 checksum of all input read + so far (that is, total_in bytes). + + deflate() may update data_type if it can make a good guess about + the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered + binary. This field is only for information purposes and does not affect + the compression algorithm in any manner. + + deflate() returns Z_OK if some progress has been made (more input + processed or more output produced), Z_STREAM_END if all input has been + consumed and all output has been produced (only when flush is set to + Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example + if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible + (for example avail_in or avail_out was zero). +*/ + + +ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); +/* + All dynamically allocated data structures for this stream are freed. + This function discards any unprocessed input and does not flush any + pending output. + + deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the + stream state was inconsistent, Z_DATA_ERROR if the stream was freed + prematurely (some input or output was discarded). In the error case, + msg may be set but then points to a static string (which must not be + deallocated). +*/ + + +/* +ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); + + Initializes the internal stream state for decompression. The fields + next_in, avail_in, zalloc, zfree and opaque must be initialized before by + the caller. If next_in is not Z_NULL and avail_in is large enough (the exact + value depends on the compression method), inflateInit determines the + compression method from the zlib header and allocates all data structures + accordingly; otherwise the allocation will be deferred to the first call of + inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to + use default allocation functions. + + inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_VERSION_ERROR if the zlib library version is incompatible with the + version assumed by the caller. msg is set to null if there is no error + message. inflateInit does not perform any decompression apart from reading + the zlib header if present: this will be done by inflate(). (So next_in and + avail_in may be modified, but next_out and avail_out are unchanged.) +*/ + + +ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); +/* + inflate decompresses as much data as possible, and stops when the input + buffer becomes empty or the output buffer becomes full. It may some + introduce some output latency (reading input without producing any output) + except when forced to flush. + + The detailed semantics are as follows. inflate performs one or both of the + following actions: + + - Decompress more input starting at next_in and update next_in and avail_in + accordingly. If not all input can be processed (because there is not + enough room in the output buffer), next_in is updated and processing + will resume at this point for the next call of inflate(). + + - Provide more output starting at next_out and update next_out and avail_out + accordingly. inflate() provides as much output as possible, until there + is no more input data or no more space in the output buffer (see below + about the flush parameter). + + Before the call of inflate(), the application should ensure that at least + one of the actions is possible, by providing more input and/or consuming + more output, and updating the next_* and avail_* values accordingly. + The application can consume the uncompressed output when it wants, for + example when the output buffer is full (avail_out == 0), or after each + call of inflate(). If inflate returns Z_OK and with zero avail_out, it + must be called again after making room in the output buffer because there + might be more output pending. + + If the parameter flush is set to Z_SYNC_FLUSH, inflate flushes as much + output as possible to the output buffer. The flushing behavior of inflate is + not specified for values of the flush parameter other than Z_SYNC_FLUSH + and Z_FINISH, but the current implementation actually flushes as much output + as possible anyway. + + inflate() should normally be called until it returns Z_STREAM_END or an + error. However if all decompression is to be performed in a single step + (a single call of inflate), the parameter flush should be set to + Z_FINISH. In this case all pending input is processed and all pending + output is flushed; avail_out must be large enough to hold all the + uncompressed data. (The size of the uncompressed data may have been saved + by the compressor for this purpose.) The next operation on this stream must + be inflateEnd to deallocate the decompression state. The use of Z_FINISH + is never required, but can be used to inform inflate that a faster routine + may be used for the single inflate() call. + + If a preset dictionary is needed at this point (see inflateSetDictionary + below), inflate sets strm-adler to the adler32 checksum of the + dictionary chosen by the compressor and returns Z_NEED_DICT; otherwise + it sets strm->adler to the adler32 checksum of all output produced + so far (that is, total_out bytes) and returns Z_OK, Z_STREAM_END or + an error code as described below. At the end of the stream, inflate() + checks that its computed adler32 checksum is equal to that saved by the + compressor and returns Z_STREAM_END only if the checksum is correct. + + inflate() returns Z_OK if some progress has been made (more input processed + or more output produced), Z_STREAM_END if the end of the compressed data has + been reached and all uncompressed output has been produced, Z_NEED_DICT if a + preset dictionary is needed at this point, Z_DATA_ERROR if the input data was + corrupted (input stream not conforming to the zlib format or incorrect + adler32 checksum), Z_STREAM_ERROR if the stream structure was inconsistent + (for example if next_in or next_out was NULL), Z_MEM_ERROR if there was not + enough memory, Z_BUF_ERROR if no progress is possible or if there was not + enough room in the output buffer when Z_FINISH is used. In the Z_DATA_ERROR + case, the application may then call inflateSync to look for a good + compression block. +*/ + + +ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); +/* + All dynamically allocated data structures for this stream are freed. + This function discards any unprocessed input and does not flush any + pending output. + + inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state + was inconsistent. In the error case, msg may be set but then points to a + static string (which must not be deallocated). +*/ + + /* Advanced functions */ + +/* + The following functions are needed only in some special applications. +*/ + +/* +ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, + int level, + int method, + int windowBits, + int memLevel, + int strategy)); + + This is another version of deflateInit with more compression options. The + fields next_in, zalloc, zfree and opaque must be initialized before by + the caller. + + The method parameter is the compression method. It must be Z_DEFLATED in + this version of the library. + + The windowBits parameter is the base two logarithm of the window size + (the size of the history buffer). It should be in the range 8..15 for this + version of the library. Larger values of this parameter result in better + compression at the expense of memory usage. The default value is 15 if + deflateInit is used instead. + + The memLevel parameter specifies how much memory should be allocated + for the internal compression state. memLevel=1 uses minimum memory but + is slow and reduces compression ratio; memLevel=9 uses maximum memory + for optimal speed. The default value is 8. See zconf.h for total memory + usage as a function of windowBits and memLevel. + + The strategy parameter is used to tune the compression algorithm. Use the + value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a + filter (or predictor), or Z_HUFFMAN_ONLY to force Huffman encoding only (no + string match). Filtered data consists mostly of small values with a + somewhat random distribution. In this case, the compression algorithm is + tuned to compress them better. The effect of Z_FILTERED is to force more + Huffman coding and less string matching; it is somewhat intermediate + between Z_DEFAULT and Z_HUFFMAN_ONLY. The strategy parameter only affects + the compression ratio but not the correctness of the compressed output even + if it is not set appropriately. + + deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid + method). msg is set to null if there is no error message. deflateInit2 does + not perform any compression: this will be done by deflate(). +*/ + +ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, + const Bytef *dictionary, + uInt dictLength)); +/* + Initializes the compression dictionary from the given byte sequence + without producing any compressed output. This function must be called + immediately after deflateInit, deflateInit2 or deflateReset, before any + call of deflate. The compressor and decompressor must use exactly the same + dictionary (see inflateSetDictionary). + + The dictionary should consist of strings (byte sequences) that are likely + to be encountered later in the data to be compressed, with the most commonly + used strings preferably put towards the end of the dictionary. Using a + dictionary is most useful when the data to be compressed is short and can be + predicted with good accuracy; the data can then be compressed better than + with the default empty dictionary. + + Depending on the size of the compression data structures selected by + deflateInit or deflateInit2, a part of the dictionary may in effect be + discarded, for example if the dictionary is larger than the window size in + deflate or deflate2. Thus the strings most likely to be useful should be + put at the end of the dictionary, not at the front. + + Upon return of this function, strm->adler is set to the Adler32 value + of the dictionary; the decompressor may later use this value to determine + which dictionary has been used by the compressor. (The Adler32 value + applies to the whole dictionary even if only a subset of the dictionary is + actually used by the compressor.) + + deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a + parameter is invalid (such as NULL dictionary) or the stream state is + inconsistent (for example if deflate has already been called for this stream + or if the compression method is bsort). deflateSetDictionary does not + perform any compression: this will be done by deflate(). +*/ + +ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, + z_streamp source)); +/* + Sets the destination stream as a complete copy of the source stream. + + This function can be useful when several compression strategies will be + tried, for example when there are several ways of pre-processing the input + data with a filter. The streams that will be discarded should then be freed + by calling deflateEnd. Note that deflateCopy duplicates the internal + compression state which can be quite large, so this strategy is slow and + can consume lots of memory. + + deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_STREAM_ERROR if the source stream state was inconsistent + (such as zalloc being NULL). msg is left unchanged in both source and + destination. +*/ + +ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); +/* + This function is equivalent to deflateEnd followed by deflateInit, + but does not free and reallocate all the internal compression state. + The stream will keep the same compression level and any other attributes + that may have been set by deflateInit2. + + deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being NULL). +*/ + +ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, + int level, + int strategy)); +/* + Dynamically update the compression level and compression strategy. The + interpretation of level and strategy is as in deflateInit2. This can be + used to switch between compression and straight copy of the input data, or + to switch to a different kind of input data requiring a different + strategy. If the compression level is changed, the input available so far + is compressed with the old level (and may be flushed); the new level will + take effect only at the next call of deflate(). + + Before the call of deflateParams, the stream state must be set as for + a call of deflate(), since the currently available input may have to + be compressed and flushed. In particular, strm->avail_out must be non-zero. + + deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source + stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR + if strm->avail_out was zero. +*/ + +/* +ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, + int windowBits)); + + This is another version of inflateInit with an extra parameter. The + fields next_in, avail_in, zalloc, zfree and opaque must be initialized + before by the caller. + + The windowBits parameter is the base two logarithm of the maximum window + size (the size of the history buffer). It should be in the range 8..15 for + this version of the library. The default value is 15 if inflateInit is used + instead. If a compressed stream with a larger window size is given as + input, inflate() will return with the error code Z_DATA_ERROR instead of + trying to allocate a larger window. + + inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_STREAM_ERROR if a parameter is invalid (such as a negative + memLevel). msg is set to null if there is no error message. inflateInit2 + does not perform any decompression apart from reading the zlib header if + present: this will be done by inflate(). (So next_in and avail_in may be + modified, but next_out and avail_out are unchanged.) +*/ + +ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, + const Bytef *dictionary, + uInt dictLength)); +/* + Initializes the decompression dictionary from the given uncompressed byte + sequence. This function must be called immediately after a call of inflate + if this call returned Z_NEED_DICT. The dictionary chosen by the compressor + can be determined from the Adler32 value returned by this call of + inflate. The compressor and decompressor must use exactly the same + dictionary (see deflateSetDictionary). + + inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a + parameter is invalid (such as NULL dictionary) or the stream state is + inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the + expected one (incorrect Adler32 value). inflateSetDictionary does not + perform any decompression: this will be done by subsequent calls of + inflate(). +*/ + +ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); +/* + Skips invalid compressed data until a full flush point (see above the + description of deflate with Z_FULL_FLUSH) can be found, or until all + available input is skipped. No output is provided. + + inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR + if no more input was provided, Z_DATA_ERROR if no flush point has been found, + or Z_STREAM_ERROR if the stream structure was inconsistent. In the success + case, the application may save the current current value of total_in which + indicates where valid compressed data was found. In the error case, the + application may repeatedly call inflateSync, providing more input each time, + until success or end of the input data. +*/ + +ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); +/* + This function is equivalent to inflateEnd followed by inflateInit, + but does not free and reallocate all the internal decompression state. + The stream will keep attributes that may have been set by inflateInit2. + + inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being NULL). +*/ + + + /* utility functions */ + +/* + The following utility functions are implemented on top of the + basic stream-oriented functions. To simplify the interface, some + default options are assumed (compression level and memory usage, + standard memory allocation functions). The source code of these + utility functions can easily be modified if you need special options. +*/ + +ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen)); +/* + Compresses the source buffer into the destination buffer. sourceLen is + the byte length of the source buffer. Upon entry, destLen is the total + size of the destination buffer, which must be at least 0.1% larger than + sourceLen plus 12 bytes. Upon exit, destLen is the actual size of the + compressed buffer. + This function can be used to compress a whole file at once if the + input file is mmap'ed. + compress returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_BUF_ERROR if there was not enough room in the output + buffer. +*/ + +ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen, + int level)); +/* + Compresses the source buffer into the destination buffer. The level + parameter has the same meaning as in deflateInit. sourceLen is the byte + length of the source buffer. Upon entry, destLen is the total size of the + destination buffer, which must be at least 0.1% larger than sourceLen plus + 12 bytes. Upon exit, destLen is the actual size of the compressed buffer. + + compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_BUF_ERROR if there was not enough room in the output buffer, + Z_STREAM_ERROR if the level parameter is invalid. +*/ + +ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen)); +/* + Decompresses the source buffer into the destination buffer. sourceLen is + the byte length of the source buffer. Upon entry, destLen is the total + size of the destination buffer, which must be large enough to hold the + entire uncompressed data. (The size of the uncompressed data must have + been saved previously by the compressor and transmitted to the decompressor + by some mechanism outside the scope of this compression library.) + Upon exit, destLen is the actual size of the compressed buffer. + This function can be used to decompress a whole file at once if the + input file is mmap'ed. + + uncompress returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_BUF_ERROR if there was not enough room in the output + buffer, or Z_DATA_ERROR if the input data was corrupted. +*/ + + +typedef voidp gzFile; + +ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); +/* + Opens a gzip (.gz) file for reading or writing. The mode parameter + is as in fopen ("rb" or "wb") but can also include a compression level + ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for + Huffman only compression as in "wb1h". (See the description + of deflateInit2 for more information about the strategy parameter.) + + gzopen can be used to read a file which is not in gzip format; in this + case gzread will directly read from the file without decompression. + + gzopen returns NULL if the file could not be opened or if there was + insufficient memory to allocate the (de)compression state; errno + can be checked to distinguish the two cases (if errno is zero, the + zlib error is Z_MEM_ERROR). */ + +ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); +/* + gzdopen() associates a gzFile with the file descriptor fd. File + descriptors are obtained from calls like open, dup, creat, pipe or + fileno (in the file has been previously opened with fopen). + The mode parameter is as in gzopen. + The next call of gzclose on the returned gzFile will also close the + file descriptor fd, just like fclose(fdopen(fd), mode) closes the file + descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode). + gzdopen returns NULL if there was insufficient memory to allocate + the (de)compression state. +*/ + +ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); +/* + Dynamically update the compression level or strategy. See the description + of deflateInit2 for the meaning of these parameters. + gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not + opened for writing. +*/ + +ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); +/* + Reads the given number of uncompressed bytes from the compressed file. + If the input file was not in gzip format, gzread copies the given number + of bytes into the buffer. + gzread returns the number of uncompressed bytes actually read (0 for + end of file, -1 for error). */ + +ZEXTERN int ZEXPORT gzwrite OF((gzFile file, + const voidp buf, unsigned len)); +/* + Writes the given number of uncompressed bytes into the compressed file. + gzwrite returns the number of uncompressed bytes actually written + (0 in case of error). +*/ + +ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...)); +/* + Converts, formats, and writes the args to the compressed file under + control of the format string, as in fprintf. gzprintf returns the number of + uncompressed bytes actually written (0 in case of error). +*/ + +ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); +/* + Writes the given null-terminated string to the compressed file, excluding + the terminating null character. + gzputs returns the number of characters written, or -1 in case of error. +*/ + +ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); +/* + Reads bytes from the compressed file until len-1 characters are read, or + a newline character is read and transferred to buf, or an end-of-file + condition is encountered. The string is then terminated with a null + character. + gzgets returns buf, or Z_NULL in case of error. +*/ + +ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); +/* + Writes c, converted to an unsigned char, into the compressed file. + gzputc returns the value that was written, or -1 in case of error. +*/ + +ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); +/* + Reads one byte from the compressed file. gzgetc returns this byte + or -1 in case of end of file or error. +*/ + +ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); +/* + Flushes all pending output into the compressed file. The parameter + flush is as in the deflate() function. The return value is the zlib + error number (see function gzerror below). gzflush returns Z_OK if + the flush parameter is Z_FINISH and all output could be flushed. + gzflush should be called only when strictly necessary because it can + degrade compression. +*/ + +ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, + z_off_t offset, int whence)); +/* + Sets the starting position for the next gzread or gzwrite on the + given compressed file. The offset represents a number of bytes in the + uncompressed data stream. The whence parameter is defined as in lseek(2); + the value SEEK_END is not supported. + If the file is opened for reading, this function is emulated but can be + extremely slow. If the file is opened for writing, only forward seeks are + supported; gzseek then compresses a sequence of zeroes up to the new + starting position. + + gzseek returns the resulting offset location as measured in bytes from + the beginning of the uncompressed stream, or -1 in case of error, in + particular if the file is opened for writing and the new starting position + would be before the current position. +*/ + +ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); +/* + Rewinds the given file. This function is supported only for reading. + + gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET) +*/ + +ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); +/* + Returns the starting position for the next gzread or gzwrite on the + given compressed file. This position represents a number of bytes in the + uncompressed data stream. + + gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) +*/ + +ZEXTERN int ZEXPORT gzeof OF((gzFile file)); +/* + Returns 1 when EOF has previously been detected reading the given + input stream, otherwise zero. +*/ + +ZEXTERN int ZEXPORT gzclose OF((gzFile file)); +/* + Flushes all pending output if necessary, closes the compressed file + and deallocates all the (de)compression state. The return value is the zlib + error number (see function gzerror below). +*/ + +ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); +/* + Returns the error message for the last error which occurred on the + given compressed file. errnum is set to zlib error number. If an + error occurred in the file system and not in the compression library, + errnum is set to Z_ERRNO and the application may consult errno + to get the exact error code. +*/ + + /* checksum functions */ + +/* + These functions are not related to compression but are exported + anyway because they might be useful in applications using the + compression library. +*/ + +ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); + +/* + Update a running Adler-32 checksum with the bytes buf[0..len-1] and + return the updated checksum. If buf is NULL, this function returns + the required initial value for the checksum. + An Adler-32 checksum is almost as reliable as a CRC32 but can be computed + much faster. Usage example: + + uLong adler = adler32(0L, Z_NULL, 0); + + while (read_buffer(buffer, length) != EOF) { + adler = adler32(adler, buffer, length); + } + if (adler != original_adler) error(); +*/ + +ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); +/* + Update a running crc with the bytes buf[0..len-1] and return the updated + crc. If buf is NULL, this function returns the required initial value + for the crc. Pre- and post-conditioning (one's complement) is performed + within this function so it shouldn't be done by the application. + Usage example: + + uLong crc = crc32(0L, Z_NULL, 0); + + while (read_buffer(buffer, length) != EOF) { + crc = crc32(crc, buffer, length); + } + if (crc != original_crc) error(); +*/ + + + /* various hacks, don't look :) */ + +/* deflateInit and inflateInit are macros to allow checking the zlib version + * and the compiler's view of z_stream: + */ +ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, + int windowBits, int memLevel, + int strategy, const char *version, + int stream_size)); +ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, + const char *version, int stream_size)); +#define deflateInit(strm, level) \ + deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream)) +#define inflateInit(strm) \ + inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream)) +#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ + deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ + (strategy), ZLIB_VERSION, sizeof(z_stream)) +#define inflateInit2(strm, windowBits) \ + inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream)) + + +#if !defined(_Z_UTIL_H) && !defined(NO_DUMMY_DECL) + struct internal_state {int dummy;}; /* hack for buggy compilers */ +#endif + +ZEXTERN const char * ZEXPORT zError OF((int err)); +ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp z)); +ZEXTERN const uLongf * ZEXPORT get_crc_table OF((void)); + +#ifdef __cplusplus +} +#endif + +#endif /* _ZLIB_H */ diff --git a/utils/vmpi/ZLib/zutil.h b/utils/vmpi/ZLib/zutil.h new file mode 100644 index 0000000..6f2cb97 --- /dev/null +++ b/utils/vmpi/ZLib/zutil.h @@ -0,0 +1,220 @@ +/* zutil.h -- internal interface and configuration of the compression library + * Copyright (C) 1995-1998 Jean-loup Gailly. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + +/* @(#) $Id$ */ + +#ifndef _Z_UTIL_H +#define _Z_UTIL_H + +#include "zlib.h" + +#ifdef STDC +# include <stddef.h> +# include <string.h> +# include <stdlib.h> +#endif +#ifdef NO_ERRNO_H + extern int errno; +#else +# include <errno.h> +#endif + +#ifndef local +# define local static +#endif +/* compile with -Dlocal if your debugger can't find static symbols */ + +typedef unsigned char uch; +typedef uch FAR uchf; +typedef unsigned short ush; +typedef ush FAR ushf; +typedef unsigned long ulg; + +extern const char *z_errmsg[10]; /* indexed by 2-zlib_error */ +/* (size given to avoid silly warnings with Visual C++) */ + +#define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)] + +#define ERR_RETURN(strm,err) \ + return (strm->msg = (char*)ERR_MSG(err), (err)) +/* To be used only when the state is known to be valid */ + + /* common constants */ + +#ifndef DEF_WBITS +# define DEF_WBITS MAX_WBITS +#endif +/* default windowBits for decompression. MAX_WBITS is for compression only */ + +#if MAX_MEM_LEVEL >= 8 +# define DEF_MEM_LEVEL 8 +#else +# define DEF_MEM_LEVEL MAX_MEM_LEVEL +#endif +/* default memLevel */ + +#define STORED_BLOCK 0 +#define STATIC_TREES 1 +#define DYN_TREES 2 +/* The three kinds of block type */ + +#define MIN_MATCH 3 +#define MAX_MATCH 258 +/* The minimum and maximum match lengths */ + +#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */ + + /* target dependencies */ + +#ifdef MSDOS +# define OS_CODE 0x00 +# if defined(__TURBOC__) || defined(__BORLANDC__) +# if(__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__)) + /* Allow compilation with ANSI keywords only enabled */ + void _Cdecl farfree( void *block ); + void *_Cdecl farmalloc( unsigned long nbytes ); +# else +# include <alloc.h> +# endif +# else /* MSC or DJGPP */ +# include <malloc.h> +# endif +#endif + +#ifdef OS2 +# define OS_CODE 0x06 +#endif + +#ifdef WIN32 /* Window 95 & Windows NT */ +# define OS_CODE 0x0b +#endif + +#if defined(VAXC) || defined(VMS) +# define OS_CODE 0x02 +# define F_OPEN(name, mode) \ + fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512") +#endif + +#ifdef AMIGA +# define OS_CODE 0x01 +#endif + +#if defined(ATARI) || defined(atarist) +# define OS_CODE 0x05 +#endif + +#if defined(MACOS) || defined(TARGET_OS_MAC) +# define OS_CODE 0x07 +# if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os +# include <unix.h> /* for fdopen */ +# else +# ifndef fdopen +# define fdopen(fd,mode) NULL /* No fdopen() */ +# endif +# endif +#endif + +#ifdef __50SERIES /* Prime/PRIMOS */ +# define OS_CODE 0x0F +#endif + +#ifdef TOPS20 +# define OS_CODE 0x0a +#endif + +#if defined(_BEOS_) || defined(RISCOS) +# define fdopen(fd,mode) NULL /* No fdopen() */ +#endif + +#if (defined(_MSC_VER) && (_MSC_VER > 600)) +# define fdopen(fd,type) _fdopen(fd,type) +#endif + + + /* Common defaults */ + +#ifndef OS_CODE +# define OS_CODE 0x03 /* assume Unix */ +#endif + +#ifndef F_OPEN +# define F_OPEN(name, mode) fopen((name), (mode)) +#endif + + /* functions */ + +#ifdef HAVE_STRERROR + extern char *strerror OF((int)); +# define zstrerror(errnum) strerror(errnum) +#else +# define zstrerror(errnum) "" +#endif + +#if defined(pyr) +# define NO_MEMCPY +#endif +#if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__) + /* Use our own functions for small and medium model with MSC <= 5.0. + * You may have to use the same strategy for Borland C (untested). + * The __SC__ check is for Symantec. + */ +# define NO_MEMCPY +#endif +#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY) +# define HAVE_MEMCPY +#endif +#ifdef HAVE_MEMCPY +# ifdef SMALL_MEDIUM /* MSDOS small or medium model */ +# define zmemcpy _fmemcpy +# define zmemcmp _fmemcmp +# define zmemzero(dest, len) _fmemset(dest, 0, len) +# else +# define zmemcpy memcpy +# define zmemcmp memcmp +# define zmemzero(dest, len) memset(dest, 0, len) +# endif +#else + extern void zmemcpy OF((Bytef* dest, const Bytef* source, uInt len)); + extern int zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len)); + extern void zmemzero OF((Bytef* dest, uInt len)); +#endif + +/* Diagnostic functions */ +#ifdef DEBUG +# include <stdio.h> + extern int z_verbose; + extern void z_error OF((char *m)); +# define Assert(cond,msg) {if(!(cond)) z_error(msg);} +# define Trace(x) {if (z_verbose>=0) fprintf x ;} +# define Tracev(x) {if (z_verbose>0) fprintf x ;} +# define Tracevv(x) {if (z_verbose>1) fprintf x ;} +# define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;} +# define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;} +#else +# define Assert(cond,msg) +# define Trace(x) +# define Tracev(x) +# define Tracevv(x) +# define Tracec(c,x) +# define Tracecv(c,x) +#endif + + +typedef uLong (ZEXPORT *check_func) OF((uLong check, const Bytef *buf, + uInt len)); +voidpf zcalloc OF((voidpf opaque, unsigned items, unsigned size)); +void zcfree OF((voidpf opaque, voidpf ptr)); + +#define ZALLOC(strm, items, size) \ + (*((strm)->zalloc))((strm)->opaque, (items), (size)) +#define ZFREE(strm, addr) (*((strm)->zfree))((strm)->opaque, (voidpf)(addr)) +#define TRY_FREE(s, p) {if (p) ZFREE(s, p);} + +#endif /* _Z_UTIL_H */ diff --git a/utils/vmpi/ichannel.h b/utils/vmpi/ichannel.h new file mode 100644 index 0000000..a26f034 --- /dev/null +++ b/utils/vmpi/ichannel.h @@ -0,0 +1,49 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#ifndef ICHANNEL_H +#define ICHANNEL_H +#ifdef _WIN32 +#pragma once +#endif + + +#include "tier1/utlvector.h" + + +class IChannel +{ +public: + // Note: this also releases any channels contained inside. So if you make a reliable + // channel that contains an unreliable channel and release the reliable one, + // it will automatically release the unreliable one it contains. + virtual void Release() = 0; + + // Send data to the destination. + virtual bool Send( const void *pData, int len ) = 0; + + // This version puts all the chunks into one packet and ships it off. + virtual bool SendChunks( void const * const *pChunks, const int *pChunkLengths, int nChunks ) = 0; + + // Check for any packets coming in from the destination. + // Returns false if no packet was received. + // + // flTimeout can be used to make it wait for data. + // + // Note: this is most efficient if you keep the buffer around between calls so it only + // reallocates it when it needs more space. + virtual bool Recv( CUtlVector<unsigned char> &data, double flTimeout=0 ) = 0; + + // Returns false if the connection has been broken. + virtual bool IsConnected() = 0; + + // If IsConnected returns false, you can call this to find out why the socket got disconnected. + virtual void GetDisconnectReason( CUtlVector<char> &reason ) = 0; +}; + + +#endif // ICHANNEL_H diff --git a/utils/vmpi/idle_dialog.cpp b/utils/vmpi/idle_dialog.cpp new file mode 100644 index 0000000..5518fff --- /dev/null +++ b/utils/vmpi/idle_dialog.cpp @@ -0,0 +1,46 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#include "stdafx.h" +#include "idle_dialog.h" + + +#define WM_STARTIDLE (WM_USER + 565) + + +BEGIN_MESSAGE_MAP(CIdleDialog, CDialog) + //{{AFX_MSG_MAP(CVMPIBrowserDlg) + ON_MESSAGE(WM_STARTIDLE, OnStartIdle) + //}}AFX_MSG_MAP +END_MESSAGE_MAP() + + +CIdleDialog::CIdleDialog( int id, CWnd *pParent ) + : CDialog( id, pParent ) +{ +} + + +void CIdleDialog::StartIdleProcessing( DWORD msInterval ) +{ + m_cWinIdle.StartIdle( GetSafeHwnd(), WM_STARTIDLE, 0, 0, msInterval ); + m_cWinIdle.NextIdle(); +} + + +LONG CIdleDialog::OnStartIdle( UINT, LONG ) +{ + MSG msg; + + if ( !PeekMessage( &msg, GetSafeHwnd(), 0,0, PM_NOREMOVE ) ) + OnIdle(); + + m_cWinIdle.NextIdle(); + return 0; +} + + diff --git a/utils/vmpi/idle_dialog.h b/utils/vmpi/idle_dialog.h new file mode 100644 index 0000000..5dbe20c --- /dev/null +++ b/utils/vmpi/idle_dialog.h @@ -0,0 +1,48 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#ifndef IDLE_DIALOG_H +#define IDLE_DIALOG_H +#ifdef _WIN32 +#pragma once +#endif + + +#include "win_idle.h" + + +// +// This is a base class that provides in-thread idle processing. +// +// To use it: +// 1. derive from it +// 2. Change your message map to point at this class instead of CDialog +// 3. Call StartIdleProcessing to begin receiving idle calls. +// 4. Override OnIdle(). +// + +class CIdleDialog : public CDialog +{ +public: + + CIdleDialog( int id, CWnd *pParent ); + + // Call this to start the idle processing. + void StartIdleProcessing( DWORD msInterval ); + + virtual void OnIdle() = 0; + + +private: + DECLARE_MESSAGE_MAP() + afx_msg LONG OnStartIdle(UINT, LONG); + + CWinIdle m_cWinIdle; +}; + + +#endif // IDLE_DIALOG_H diff --git a/utils/vmpi/imysqlwrapper.h b/utils/vmpi/imysqlwrapper.h new file mode 100644 index 0000000..2604128 --- /dev/null +++ b/utils/vmpi/imysqlwrapper.h @@ -0,0 +1,115 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#ifndef MYSQL_WRAPPER_H +#define MYSQL_WRAPPER_H +#ifdef _WIN32 +#pragma once +#endif + + +#include "utlvector.h" +#include "interface.h" + + +class IMySQLRowSet; + + +class CColumnValue +{ +public: + + CColumnValue( IMySQLRowSet *pSQL, int iColumn ); + + const char* String(); + long Int32(); + +private: + IMySQLRowSet *m_pSQL; + int m_iColumn; +}; + + + +class IMySQLRowSet +{ +public: + virtual void Release() = 0; + + // Get the number of columns in the data returned from the last query (if it was a select statement). + virtual int NumFields() = 0; + + // Get the name of each column returned by the last query. + virtual const char* GetFieldName( int iColumn ) = 0; + + // Call this in a loop until it returns false to iterate over all rows the query returned. + virtual bool NextRow() = 0; + + // You can call this to start iterating over the result set from the start again. + // Note: after calling this, you have to call NextRow() to actually get the first row's value ready. + virtual bool SeekToFirstRow() = 0; + + virtual CColumnValue GetColumnValue( int iColumn ) = 0; + virtual CColumnValue GetColumnValue( const char *pColumnName ) = 0; + + virtual const char* GetColumnValue_String( int iColumn ) = 0; + virtual long GetColumnValue_Int( int iColumn ) = 0; + + // You can call this to get the index of a column for faster lookups with GetColumnValue( int ). + // Returns -1 if the column can't be found. + virtual int GetColumnIndex( const char *pColumnName ) = 0; +}; + + +class IMySQL : public IMySQLRowSet +{ +public: + virtual bool InitMySQL( const char *pDBName, const char *pHostName="", const char *pUserName="", const char *pPassword="" ) = 0; + virtual void Release() = 0; + + // These execute SQL commands. They return 0 if the query was successful. + virtual int Execute( const char *pString ) = 0; + + // This reads in all of the data in the last row set you queried with Execute and builds a separate + // copy. This is useful in some of the VMPI tools to have a thread repeatedly execute a slow query, then + // store off the results for the main thread to parse. + virtual IMySQLRowSet* DuplicateRowSet() = 0; + + // If you just inserted rows into a table with an AUTO_INCREMENT column, + // then this returns the (unique) value of that column. + virtual unsigned long InsertID() = 0; + + // Returns the last error message, if an error took place + virtual const char * GetLastError() = 0; +}; + + +#define MYSQL_WRAPPER_VERSION_NAME "MySQLWrapper001" + + +// ------------------------------------------------------------------------------------------------ // +// Inlines. +// ------------------------------------------------------------------------------------------------ // + +inline CColumnValue::CColumnValue( IMySQLRowSet *pSQL, int iColumn ) +{ + m_pSQL = pSQL; + m_iColumn = iColumn; +} + +inline const char* CColumnValue::String() +{ + return m_pSQL->GetColumnValue_String( m_iColumn ); +} + +inline long CColumnValue::Int32() +{ + return m_pSQL->GetColumnValue_Int( m_iColumn ); +} + + +#endif // MYSQL_WRAPPER_H diff --git a/utils/vmpi/iphelpers.cpp b/utils/vmpi/iphelpers.cpp new file mode 100644 index 0000000..119bba8 --- /dev/null +++ b/utils/vmpi/iphelpers.cpp @@ -0,0 +1,610 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// + +#pragma warning (disable:4127) +#include <winsock2.h> +#include <ws2tcpip.h> +#pragma warning (default:4127) + +#include "iphelpers.h" +#include "basetypes.h" +#include <assert.h> +#include "utllinkedlist.h" +#include "utlvector.h" +#include "tier1/strtools.h" + + +// This automatically calls WSAStartup for the app at startup. +class CIPStarter +{ +public: + CIPStarter() + { + WSADATA wsaData; + WSAStartup( WINSOCK_VERSION, &wsaData ); + } +}; +static CIPStarter g_Starter; + + +unsigned long SampleMilliseconds() +{ + CCycleCount cnt; + cnt.Sample(); + return cnt.GetMilliseconds(); +} + + +// ------------------------------------------------------------------------------------------ // +// CChunkWalker. +// ------------------------------------------------------------------------------------------ // + +CChunkWalker::CChunkWalker( void const * const *pChunks, const int *pChunkLengths, int nChunks ) +{ + m_TotalLength = 0; + for ( int i=0; i < nChunks; i++ ) + m_TotalLength += pChunkLengths[i]; + + m_iCurChunk = 0; + m_iCurChunkPos = 0; + m_pChunks = pChunks; + m_pChunkLengths = pChunkLengths; + m_nChunks = nChunks; +} + +int CChunkWalker::GetTotalLength() const +{ + return m_TotalLength; +} + +void CChunkWalker::CopyTo( void *pOut, int nBytes ) +{ + unsigned char *pOutPos = (unsigned char*)pOut; + + int nBytesLeft = nBytes; + while ( nBytesLeft > 0 ) + { + int toCopy = nBytesLeft; + int curChunkLen = m_pChunkLengths[m_iCurChunk]; + + int amtLeft = curChunkLen - m_iCurChunkPos; + if ( nBytesLeft > amtLeft ) + { + toCopy = amtLeft; + } + + unsigned char *pCurChunkData = (unsigned char*)m_pChunks[m_iCurChunk]; + memcpy( pOutPos, &pCurChunkData[m_iCurChunkPos], toCopy ); + nBytesLeft -= toCopy; + pOutPos += toCopy; + + // Slide up to the next chunk if we're done with the one we're on. + m_iCurChunkPos += toCopy; + assert( m_iCurChunkPos <= curChunkLen ); + if ( m_iCurChunkPos == curChunkLen ) + { + ++m_iCurChunk; + m_iCurChunkPos = 0; + if ( m_iCurChunk == m_nChunks ) + { + assert( nBytesLeft == 0 ); + } + } + } +} + + +// ------------------------------------------------------------------------------------------ // +// CWaitTimer +// ------------------------------------------------------------------------------------------ // + +bool g_bForceWaitTimers = false; + +CWaitTimer::CWaitTimer( double flSeconds ) +{ + m_StartTime = SampleMilliseconds(); + m_WaitMS = (unsigned long)( flSeconds * 1000.0 ); +} + + +bool CWaitTimer::ShouldKeepWaiting() +{ + if ( m_WaitMS == 0 ) + { + return false; + } + else + { + return ( SampleMilliseconds() - m_StartTime ) <= m_WaitMS || g_bForceWaitTimers; + } +} + + + +// ------------------------------------------------------------------------------------------ // +// CIPAddr. +// ------------------------------------------------------------------------------------------ // + +CIPAddr::CIPAddr() +{ + Init( 0, 0, 0, 0, 0 ); +} + + +CIPAddr::CIPAddr( const int inputIP[4], const int inputPort ) +{ + Init( inputIP[0], inputIP[1], inputIP[2], inputIP[3], inputPort ); +} + + +CIPAddr::CIPAddr( int ip0, int ip1, int ip2, int ip3, int ipPort ) +{ + Init( ip0, ip1, ip2, ip3, ipPort ); +} + + +void CIPAddr::Init( int ip0, int ip1, int ip2, int ip3, int ipPort ) +{ + ip[0] = (unsigned char)ip0; + ip[1] = (unsigned char)ip1; + ip[2] = (unsigned char)ip2; + ip[3] = (unsigned char)ip3; + port = (unsigned short)ipPort; +} + +bool CIPAddr::operator==( const CIPAddr &o ) const +{ + return ip[0] == o.ip[0] && ip[1] == o.ip[1] && ip[2] == o.ip[2] && ip[3] == o.ip[3] && port == o.port; +} + + +bool CIPAddr::operator!=( const CIPAddr &o ) const +{ + return !( *this == o ); +} + + +void CIPAddr::SetupLocal( int inPort ) +{ + ip[0] = 0x7f; + ip[1] = 0; + ip[2] = 0; + ip[3] = 1; + port = inPort; +} + + +// ------------------------------------------------------------------------------------------ // +// Static helpers. +// ------------------------------------------------------------------------------------------ // + +static double IP_FloatTime() +{ + CCycleCount cnt; + cnt.Sample(); + return cnt.GetSeconds(); +} + +TIMEVAL SetupTimeVal( double flTimeout ) +{ + TIMEVAL timeVal; + timeVal.tv_sec = (long)flTimeout; + timeVal.tv_usec = (long)( (flTimeout - (long)flTimeout) * 1000.0 ); + return timeVal; +} + +// Convert a CIPAddr to a sockaddr_in. +void IPAddrToInAddr( const CIPAddr *pIn, in_addr *pOut ) +{ + u_char *p = (u_char*)pOut; + p[0] = pIn->ip[0]; + p[1] = pIn->ip[1]; + p[2] = pIn->ip[2]; + p[3] = pIn->ip[3]; +} + +// Convert a CIPAddr to a sockaddr_in. +void IPAddrToSockAddr( const CIPAddr *pIn, struct sockaddr_in *pOut ) +{ + memset( pOut, 0, sizeof(*pOut) ); + pOut->sin_family = AF_INET; + pOut->sin_port = htons( pIn->port ); + + IPAddrToInAddr( pIn, &pOut->sin_addr ); +} + +// Convert a CIPAddr to a sockaddr_in. +void SockAddrToIPAddr( const struct sockaddr_in *pIn, CIPAddr *pOut ) +{ + const u_char *p = (const u_char*)&pIn->sin_addr; + pOut->ip[0] = p[0]; + pOut->ip[1] = p[1]; + pOut->ip[2] = p[2]; + pOut->ip[3] = p[3]; + pOut->port = ntohs( pIn->sin_port ); +} + + +class CIPSocket : public ISocket +{ +public: + CIPSocket() + { + m_Socket = INVALID_SOCKET; + m_bSetupToBroadcast = false; + } + + virtual ~CIPSocket() + { + Term(); + } + + +// ISocket implementation. +public: + + virtual void Release() + { + delete this; + } + + + virtual bool CreateSocket() + { + // Clear any old socket we had around. + Term(); + + // Create a socket to send and receive through. + SOCKET sock = socket( AF_INET, SOCK_DGRAM, IPPROTO_IP ); + if ( sock == INVALID_SOCKET ) + { + Assert( false ); + return false; + } + + // Nonblocking please.. + int status; + DWORD val = 1; + status = ioctlsocket( sock, FIONBIO, &val ); + if ( status != 0 ) + { + assert( false ); + closesocket( sock ); + return false; + } + + m_Socket = sock; + return true; + } + + + // Called after we have a socket. + virtual bool BindPart2( const CIPAddr *pAddr ) + { + Assert( m_Socket != INVALID_SOCKET ); + + // bind to it! + sockaddr_in addr; + IPAddrToSockAddr( pAddr, &addr ); + + int status = bind( m_Socket, (sockaddr*)&addr, sizeof(addr) ); + if ( status == 0 ) + { + return true; + } + else + { + Term(); + return false; + } + } + + + virtual bool Bind( const CIPAddr *pAddr ) + { + if ( !CreateSocket() ) + return false; + + return BindPart2( pAddr ); + } + + virtual bool BindToAny( const unsigned short port ) + { + // (INADDR_ANY) + CIPAddr addr; + addr.ip[0] = addr.ip[1] = addr.ip[2] = addr.ip[3] = 0; + addr.port = port; + return Bind( &addr ); + } + + virtual bool ListenToMulticastStream( const CIPAddr &addr, const CIPAddr &localInterface ) + { + ip_mreq mr; + IPAddrToInAddr( &addr, &mr.imr_multiaddr ); + IPAddrToInAddr( &localInterface, &mr.imr_interface ); + + // This helps a lot if the stream is sending really fast. + int rcvBuf = 1024*1024*2; + setsockopt( m_Socket, SOL_SOCKET, SO_RCVBUF, (char*)&rcvBuf, sizeof( rcvBuf ) ); + + if ( setsockopt( m_Socket, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char*)&mr, sizeof( mr ) ) == 0 ) + { + // Remember this so we do IP_DEL_MEMBERSHIP on shutdown. + m_bMulticastGroupMembership = true; + m_MulticastGroupMREQ = mr; + return true; + } + else + { + return false; + } + } + + virtual bool Broadcast( const void *pData, const int len, const unsigned short port ) + { + assert( m_Socket != INVALID_SOCKET ); + + // Make sure we're setup to broadcast. + if ( !m_bSetupToBroadcast ) + { + BOOL bBroadcast = true; + if ( setsockopt( m_Socket, SOL_SOCKET, SO_BROADCAST, (char*)&bBroadcast, sizeof( bBroadcast ) ) != 0 ) + { + assert( false ); + return false; + } + + m_bSetupToBroadcast = true; + } + + CIPAddr addr; + addr.ip[0] = addr.ip[1] = addr.ip[2] = addr.ip[3] = 0xFF; + addr.port = port; + return SendTo( &addr, pData, len ); + } + + virtual bool SendTo( const CIPAddr *pAddr, const void *pData, const int len ) + { + return SendChunksTo( pAddr, &pData, &len, 1 ); + } + + virtual bool SendChunksTo( const CIPAddr *pAddr, void const * const *pChunks, const int *pChunkLengths, int nChunks ) + { + WSABUF bufs[32]; + if ( nChunks > 32 ) + { + Error( "CIPSocket::SendChunksTo: too many chunks (%d).", nChunks ); + } + + int nTotalBytes = 0; + for ( int i=0; i < nChunks; i++ ) + { + bufs[i].len = pChunkLengths[i]; + bufs[i].buf = (char*)pChunks[i]; + nTotalBytes += pChunkLengths[i]; + } + + assert( m_Socket != INVALID_SOCKET ); + + // Translate the address. + sockaddr_in addr; + IPAddrToSockAddr( pAddr, &addr ); + + DWORD dwNumBytesSent = 0; + DWORD ret = WSASendTo( + m_Socket, + bufs, + nChunks, + &dwNumBytesSent, + 0, + (sockaddr*)&addr, + sizeof( addr ), + NULL, + NULL + ); + + return ret == 0 && (int)dwNumBytesSent == nTotalBytes; + } + + virtual int RecvFrom( void *pData, int maxDataLen, CIPAddr *pFrom ) + { + assert( m_Socket != INVALID_SOCKET ); + + fd_set readSet; + readSet.fd_count = 1; + readSet.fd_array[0] = m_Socket; + + TIMEVAL timeVal = SetupTimeVal( 0 ); + + // See if it has a packet waiting. + int status = select( 0, &readSet, NULL, NULL, &timeVal ); + if ( status == 0 || status == SOCKET_ERROR ) + return -1; + + // Get the data. + sockaddr_in sender; + int fromSize = sizeof( sockaddr_in ); + status = recvfrom( m_Socket, (char*)pData, maxDataLen, 0, (struct sockaddr*)&sender, &fromSize ); + if ( status == 0 || status == SOCKET_ERROR ) + { + return -1; + } + else + { + if ( pFrom ) + { + SockAddrToIPAddr( &sender, pFrom ); + } + + m_flLastRecvTime = IP_FloatTime(); + return status; + } + } + + virtual double GetRecvTimeout() + { + return IP_FloatTime() - m_flLastRecvTime; + } + + +private: + + void Term() + { + if ( m_Socket != INVALID_SOCKET ) + { + if ( m_bMulticastGroupMembership ) + { + // Undo our multicast group membership. + setsockopt( m_Socket, IPPROTO_IP, IP_DROP_MEMBERSHIP, (char*)&m_MulticastGroupMREQ, sizeof( m_MulticastGroupMREQ ) ); + } + + closesocket( m_Socket ); + m_Socket = INVALID_SOCKET; + } + + m_bSetupToBroadcast = false; + m_bMulticastGroupMembership = false; + } + + +private: + + SOCKET m_Socket; + + bool m_bMulticastGroupMembership; // Did we join a multicast group? + ip_mreq m_MulticastGroupMREQ; + + bool m_bSetupToBroadcast; + double m_flLastRecvTime; + bool m_bListenSocket; +}; + + + +ISocket* CreateIPSocket() +{ + return new CIPSocket; +} + + +ISocket* CreateMulticastListenSocket( + const CIPAddr &addr, + const CIPAddr &localInterface ) +{ + CIPSocket *pSocket = new CIPSocket; + + CIPAddr bindAddr = localInterface; + bindAddr.port = addr.port; + + if ( pSocket->Bind( &bindAddr ) && + pSocket->ListenToMulticastStream( addr, localInterface ) + ) + { + return pSocket; + } + else + { + pSocket->Release(); + return NULL; + } +} + + +bool ConvertStringToIPAddr( const char *pStr, CIPAddr *pOut ) +{ + char ipStr[512]; + + const char *pColon = strchr( pStr, ':' ); + if ( pColon ) + { + int toCopy = pColon - pStr; + if ( toCopy < 2 || toCopy > sizeof(ipStr)-1 ) + { + assert( false ); + return false; + } + + memcpy( ipStr, pStr, toCopy ); + ipStr[toCopy] = 0; + + pOut->port = (unsigned short)atoi( pColon+1 ); + } + else + { + strncpy( ipStr, pStr, sizeof( ipStr ) ); + ipStr[ sizeof(ipStr)-1 ] = 0; + } + + if ( ipStr[0] >= '0' && ipStr[0] <= '9' ) + { + // It's numbers. + int ip[4]; + sscanf( ipStr, "%d.%d.%d.%d", &ip[0], &ip[1], &ip[2], &ip[3] ); + pOut->ip[0] = (unsigned char)ip[0]; + pOut->ip[1] = (unsigned char)ip[1]; + pOut->ip[2] = (unsigned char)ip[2]; + pOut->ip[3] = (unsigned char)ip[3]; + } + else + { + // It's a text string. + struct hostent *pHost = gethostbyname( ipStr ); + if( !pHost ) + return false; + + pOut->ip[0] = pHost->h_addr_list[0][0]; + pOut->ip[1] = pHost->h_addr_list[0][1]; + pOut->ip[2] = pHost->h_addr_list[0][2]; + pOut->ip[3] = pHost->h_addr_list[0][3]; + } + + return true; +} + + +bool ConvertIPAddrToString( const CIPAddr *pIn, char *pOut, int outLen ) +{ + in_addr addr; + addr.S_un.S_un_b.s_b1 = pIn->ip[0]; + addr.S_un.S_un_b.s_b2 = pIn->ip[1]; + addr.S_un.S_un_b.s_b3 = pIn->ip[2]; + addr.S_un.S_un_b.s_b4 = pIn->ip[3]; + + HOSTENT *pEnt = gethostbyaddr( (char*)&addr, sizeof( addr ), AF_INET ); + if ( pEnt ) + { + Q_strncpy( pOut, pEnt->h_name, outLen ); + return true; + } + else + { + return false; + } +} + + +void IP_GetLastErrorString( char *pStr, int maxLen ) +{ + char *lpMsgBuf; + FormatMessage( + FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + GetLastError(), + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language + (LPTSTR) &lpMsgBuf, + 0, + NULL + ); + + Q_strncpy( pStr, lpMsgBuf, maxLen ); + LocalFree( lpMsgBuf ); +} + diff --git a/utils/vmpi/iphelpers.h b/utils/vmpi/iphelpers.h new file mode 100644 index 0000000..acd356a --- /dev/null +++ b/utils/vmpi/iphelpers.h @@ -0,0 +1,162 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// + +#ifndef IPHELPERS_H +#define IPHELPERS_H + + +#include "ichannel.h" + + +// Loops that poll sockets should Sleep for this amount of time between iterations +// so they don't hog all the CPU. +#define LOOP_POLL_INTERVAL 5 + + +// Useful for putting the arguments into a printf statement. +#define EXPAND_ADDR( x ) (x).ip[0], (x).ip[1], (x).ip[2], (x).ip[3], (x).port + + +// This is a simple wrapper layer for UDP sockets. +class CIPAddr +{ +public: + CIPAddr(); + CIPAddr( const int inputIP[4], const int inputPort ); + CIPAddr( int ip0, int ip1, int ip2, int ip3, int ipPort ); + + void Init( int ip0, int ip1, int ip2, int ip3, int ipPort ); + bool operator==( const CIPAddr &o ) const; + bool operator!=( const CIPAddr &o ) const; + + // Setup to send to the local machine on the specified port. + void SetupLocal( int inPort ); + +public: + + unsigned char ip[4]; + unsigned short port; +}; + + + +// The chunk walker provides an easy way to copy data out of the chunks as though it were a +// single contiguous chunk of memory.s +class CChunkWalker +{ +public: + CChunkWalker( void const * const *pChunks, const int *pChunkLengths, int nChunks ); + + int GetTotalLength() const; + void CopyTo( void *pOut, int nBytes ); + +private: + + void const * const *m_pChunks; + const int *m_pChunkLengths; + int m_nChunks; + + int m_iCurChunk; + int m_iCurChunkPos; + + int m_TotalLength; +}; + + +// This class makes loop that wait on something look nicer. ALL loops using this class +// should follow this pattern, or they can wind up with unforeseen delays that add a whole +// lot of lag. +// +// CWaitTimer waitTimer( 5.0 ); +// while ( 1 ) +// { +// do your thing here like Recv() from a socket. +// +// if ( waitTimer.ShouldKeepWaiting() ) +// Sleep() for some time interval like 5ms so you don't hog the CPU +// else +// BREAK HERE +// } +class CWaitTimer +{ +public: + CWaitTimer( double flSeconds ); + + bool ShouldKeepWaiting(); + +private: + unsigned long m_StartTime; + unsigned long m_WaitMS; +}; + + +// Helper function to get time in milliseconds. +unsigned long SampleMilliseconds(); + + +class ISocket +{ +public: + + // Call this when you're done. + virtual void Release() = 0; + + + // Bind the socket so you can send and receive with it. + // If you bind to port 0, then the system will select the port for you. + virtual bool Bind( const CIPAddr *pAddr ) = 0; + virtual bool BindToAny( const unsigned short port ) = 0; + + + // Broadcast some data. + virtual bool Broadcast( const void *pData, const int len, const unsigned short port ) = 0; + + // Send a packet. + virtual bool SendTo( const CIPAddr *pAddr, const void *pData, const int len ) = 0; + virtual bool SendChunksTo( const CIPAddr *pAddr, void const * const *pChunks, const int *pChunkLengths, int nChunks ) = 0; + + // Receive a packet. Returns the length received or -1 if no data came in. + // If pFrom is set, then it is filled in with the sender's IP address. + virtual int RecvFrom( void *pData, int maxDataLen, CIPAddr *pFrom ) = 0; + + // How long has it been since we successfully received a packet? + virtual double GetRecvTimeout() = 0; +}; + +// Create a connectionless socket that you can send packets out of. +ISocket* CreateIPSocket(); + +// This sets up the socket to receive multicast data on the specified group. +// By default, localInterface is INADDR_ANY, but if you want to specify a specific interface +// the data should come in through, you can. +ISocket* CreateMulticastListenSocket( + const CIPAddr &addr, + const CIPAddr &localInterface = CIPAddr() + ); + + +// Setup a CIPAddr from the string. The string can be a dotted IP address or +// a hostname, and it can be followed by a colon and a port number like "1.2.3.4:3443" +// or "myhostname.valvesoftware.com:2342". +// +// Note: if the string does not contain a port, then pOut->port will be left alone. +bool ConvertStringToIPAddr( const char *pStr, CIPAddr *pOut ); + +// Do a DNS lookup on the IP. +// You can optionally get a service name back too. +bool ConvertIPAddrToString( const CIPAddr *pIn, char *pOut, int outLen ); + + +void IP_GetLastErrorString( char *pStr, int maxLen ); + +void SockAddrToIPAddr( const struct sockaddr_in *pIn, CIPAddr *pOut ); +void IPAddrToSockAddr( const CIPAddr *pIn, struct sockaddr_in *pOut ); + + +#endif + diff --git a/utils/vmpi/loopback_channel.cpp b/utils/vmpi/loopback_channel.cpp new file mode 100644 index 0000000..79b2fa6 --- /dev/null +++ b/utils/vmpi/loopback_channel.cpp @@ -0,0 +1,98 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#include "loopback_channel.h" +#include "utllinkedlist.h" +#include "iphelpers.h" + + +// -------------------------------------------------------------------------------- // +// CLoopbackChannel. +// -------------------------------------------------------------------------------- // + +typedef struct +{ + int m_Len; + unsigned char m_Data[1]; +} LoopbackMsg_t; + + +class CLoopbackChannel : public IChannel +{ +public: + + virtual ~CLoopbackChannel() + { + FOR_EACH_LL( m_Messages, i ) + { + free( m_Messages[i] ); + } + m_Messages.Purge(); + } + + virtual void Release() + { + delete this; + } + + virtual bool Send( const void *pData, int len ) + { + const void *pChunks[1] = { pData }; + int chunkLengths[1] = { len }; + return SendChunks( pChunks, chunkLengths, 1 ); + } + + virtual bool SendChunks( void const * const *pChunks, const int *pChunkLengths, int nChunks ) + { + CChunkWalker walker( pChunks, pChunkLengths, nChunks ); + + LoopbackMsg_t *pMsg = (LoopbackMsg_t*)malloc( sizeof( LoopbackMsg_t ) - 1 + walker.GetTotalLength() ); + walker.CopyTo( pMsg->m_Data, walker.GetTotalLength() ); + pMsg->m_Len = walker.GetTotalLength(); + m_Messages.AddToTail( pMsg ); + return true; + } + + virtual bool Recv( CUtlVector<unsigned char> &data, double flTimeout ) + { + int iNext = m_Messages.Head(); + if ( iNext == m_Messages.InvalidIndex() ) + { + return false; + } + else + { + LoopbackMsg_t *pMsg = m_Messages[iNext]; + + data.CopyArray( pMsg->m_Data, pMsg->m_Len ); + + free( pMsg ); + m_Messages.Remove( iNext ); + + return true; + } + } + + virtual bool IsConnected() + { + return true; + } + + virtual void GetDisconnectReason( CUtlVector<char> &reason ) + { + } + +private: + CUtlLinkedList<LoopbackMsg_t*,int> m_Messages; // FIFO for messages we've sent. +}; + + +IChannel* CreateLoopbackChannel() +{ + return new CLoopbackChannel; +} + diff --git a/utils/vmpi/loopback_channel.h b/utils/vmpi/loopback_channel.h new file mode 100644 index 0000000..137efbe --- /dev/null +++ b/utils/vmpi/loopback_channel.h @@ -0,0 +1,22 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#ifndef LOOPBACK_CHANNEL_H +#define LOOPBACK_CHANNEL_H +#ifdef _WIN32 +#pragma once +#endif + + +#include "ichannel.h" + + +// Loopback sockets receive the same data they send. +IChannel* CreateLoopbackChannel(); + + +#endif // LOOPBACK_CHANNEL_H diff --git a/utils/vmpi/messagemgr.cpp b/utils/vmpi/messagemgr.cpp new file mode 100644 index 0000000..35d5e53 --- /dev/null +++ b/utils/vmpi/messagemgr.cpp @@ -0,0 +1,300 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#include <windows.h> +#include "messagemgr.h" +#include "tcpsocket.h" +#include "iphelpers.h" +#include "tier0/platform.h" +#include "threadhelpers.h" + + +#define MSGMGR_LISTEN_PORT_FIRST 22512 +#define MSGMGR_LISTEN_PORT_LAST 22520 + + + +#define BROADCAST_INTERVAL 2 // Broadcast our presence every N seconds. + +#define NUM_QUEUED_MESSAGES 200 + + + +class CMessageMgr : public IMessageMgr +{ +public: + CMessageMgr(); + ~CMessageMgr(); + + bool Init(); + void Term(); + + +// IMessageMgr overrides. +public: + + virtual void Print( const char *pMsg ); + + + +private: + + DWORD ThreadFn(); + static DWORD WINAPI StaticThreadFn( LPVOID pParameter ); + + +private: + + // Only our thread touches this, NOT the main thread. + CUtlLinkedList<ITCPSocket*,int> m_Sockets; + + HANDLE m_hThread; + DWORD m_dwThreadID; + + HANDLE m_hExitObj; // This is signalled when we want the thread to exit. + HANDLE m_hExitResponseObj; // The thread sets this when it exits. + + HANDLE m_hMessageObj; // This signals to the thread that there's a message to send. + HANDLE m_hMessageSentObj; // This signals back to the main thread that the message was sent. + const char *m_pMessageText; // The text to send. + + // This is only touched by the thread. + CUtlLinkedList<char*,int> m_MessageQ; // FIFO of NUM_QUEUED_MESSAGES. + + ITCPListenSocket *m_pListenSocket; + int m_iListenPort; + + ISocket *m_pBroadcastSocket; + double m_flLastBroadcast; + +}; + + + +CMessageMgr::CMessageMgr() +{ + m_pBroadcastSocket = NULL; + m_pListenSocket = NULL; + m_hThread = NULL; + m_hExitObj = m_hExitResponseObj = m_hMessageObj = m_hMessageSentObj = NULL; +} + + +CMessageMgr::~CMessageMgr() +{ + Term(); +} + + +bool CMessageMgr::Init() +{ + m_hExitObj = CreateEvent( NULL, false, false, NULL ); + m_hExitResponseObj = CreateEvent( NULL, false, false, NULL ); + m_hMessageObj = CreateEvent( NULL, false, false, NULL ); + m_hMessageSentObj = CreateEvent( NULL, false, false, NULL ); + if ( !m_hExitObj || !m_hExitResponseObj || !m_hMessageObj || !m_hMessageSentObj ) + return false; + + // Create the broadcast socket. + m_pBroadcastSocket = CreateIPSocket(); + if ( !m_pBroadcastSocket ) + return false; + + if ( !m_pBroadcastSocket->BindToAny( 0 ) ) + return false; + + + // Create the listen socket. + m_pListenSocket = NULL; + for ( m_iListenPort=MSGMGR_LISTEN_PORT_FIRST; m_iListenPort <= MSGMGR_LISTEN_PORT_LAST; m_iListenPort++ ) + { + m_pListenSocket = CreateTCPListenSocket( m_iListenPort ); + if ( m_pListenSocket ) + break; + } + if ( !m_pListenSocket ) + return false; + + + // Create our broadcast/connection thread. + m_flLastBroadcast = 0; + m_hThread = CreateThread( + NULL, + 0, + &CMessageMgr::StaticThreadFn, + this, + 0, + &m_dwThreadID ); + + if ( !m_hThread ) + return false; + + Plat_SetThreadName( m_dwThreadID, "MessageMgr" ); + return true; +} + + +void CMessageMgr::Term() +{ + // Wait for the thread to exit? + if ( m_hThread ) + { + DWORD dwExitCode = 0; + if ( GetExitCodeThread( m_hThread, &dwExitCode ) && dwExitCode == STILL_ACTIVE ) + { + SetEvent( m_hExitObj ); + WaitForSingleObject( m_hExitResponseObj, INFINITE ); + } + + CloseHandle( m_hThread ); + m_hThread = NULL; + } + + CloseHandle( m_hExitObj ); + m_hExitObj = NULL; + + CloseHandle( m_hExitResponseObj ); + m_hExitResponseObj = NULL; + + CloseHandle( m_hMessageObj ); + m_hMessageObj = NULL; + + CloseHandle( m_hMessageSentObj ); + m_hMessageSentObj = NULL; + + if ( m_pListenSocket ) + { + m_pListenSocket->Release(); + m_pListenSocket = NULL; + } + + if ( m_pBroadcastSocket ) + { + m_pBroadcastSocket->Release(); + m_pBroadcastSocket = NULL; + } +} + + +void CMessageMgr::Print( const char *pMsg ) +{ + m_pMessageText = pMsg; + SetEvent( m_hMessageObj ); + WaitForSingleObject( m_hMessageSentObj, INFINITE ); +} + + +DWORD CMessageMgr::ThreadFn() +{ + while ( 1 ) + { + // Broadcast our presence? + double flCurTime = Plat_FloatTime(); + if ( flCurTime - m_flLastBroadcast >= BROADCAST_INTERVAL ) + { + // Broadcast our presence. + char msg[9]; + msg[0] = MSGMGR_PACKETID_ANNOUNCE_PRESENCE; + *((int*)&msg[1]) = MSGMGR_VERSION; + *((int*)&msg[5]) = m_iListenPort; + m_pBroadcastSocket->Broadcast( msg, sizeof( msg ), MSGMGR_BROADCAST_PORT ); + + m_flLastBroadcast = flCurTime; + } + + + // Accept new connections. + CIPAddr addr; + ITCPSocket *pConn = m_pListenSocket->UpdateListen( &addr ); + if ( pConn ) + { + // Send what's in our queue. + FOR_EACH_LL( m_MessageQ, iQ ) + { + char *pMsg = m_MessageQ[iQ]; + int bufLen = strlen( pMsg ) + 1; + + char packetID = MSGMGR_PACKETID_MSG; + const void *data[2] = { &packetID, pMsg }; + int len[2] = { 1, bufLen }; + + // Send it out to our sockets. + pConn->SendChunks( data, len, 2 ); + } + + m_Sockets.AddToTail( pConn ); + } + + + // Should we exit? + HANDLE handles[2] = {m_hExitObj, m_hMessageObj}; + DWORD ret = WaitForMultipleObjects( 2, handles, FALSE, 200 ); + if ( ret == WAIT_OBJECT_0 ) + { + break; + } + else if ( ret == (WAIT_OBJECT_0+1) ) + { + // Add it to the queue. + int index; + if ( m_MessageQ.Count() >= NUM_QUEUED_MESSAGES ) + { + index = m_MessageQ.Tail(); + delete m_MessageQ[index]; + } + else + { + index = m_MessageQ.AddToTail(); + } + int bufLen = strlen( m_pMessageText ) + 1; + m_MessageQ[index] = new char[ bufLen ]; + strcpy( m_MessageQ[index], m_pMessageText ); + + + + // Ok, send out the message. + char packetID = MSGMGR_PACKETID_MSG; + const void *data[2] = { &packetID, m_pMessageText }; + int len[2] = { 1, bufLen }; + + // Send it out to our sockets. + FOR_EACH_LL( m_Sockets, i ) + { + m_Sockets[i]->SendChunks( data, len, 2 ); + } + + // Notify the main thread that we've sent it. + SetEvent( m_hMessageSentObj ); + } + } + + // Cleanup all our sockets (the main thread should never touch them). + FOR_EACH_LL( m_Sockets, i ) + m_Sockets[i]->Release(); + + m_Sockets.Purge(); + + m_MessageQ.PurgeAndDeleteElements(); + + SetEvent( m_hExitResponseObj ); + return 0; +} + + +DWORD CMessageMgr::StaticThreadFn( LPVOID pParameter ) +{ + return ((CMessageMgr*)pParameter)->ThreadFn(); +} + + +static CMessageMgr g_MessageMgr; + +IMessageMgr* GetMessageMgr() +{ + return &g_MessageMgr; +} + diff --git a/utils/vmpi/messagemgr.h b/utils/vmpi/messagemgr.h new file mode 100644 index 0000000..cebbe76 --- /dev/null +++ b/utils/vmpi/messagemgr.h @@ -0,0 +1,39 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#ifndef MESSAGEMGR_H +#define MESSAGEMGR_H +#ifdef _WIN32 +#pragma once +#endif + + +#define MSGMGR_VERSION 52314 +#define MSGMGR_BROADCAST_PORT 22511 + +#define MSGMGR_PACKETID_MSG 0 +#define MSGMGR_PACKETID_ANNOUNCE_PRESENCE 1 // followed by version # and port + + +// IMessageMgr provides a simple interface apps can use to generate output. Apps +// on the network can connect to the messagemgr to get its output and display it. +class IMessageMgr +{ +public: + virtual bool Init() = 0; + virtual void Term() = 0; + + virtual void Print( const char *pMsg ) = 0; +}; + + +// Get the message manager. It's a global singleton so this will always +// return the same value (null if the manager can't initialize). +IMessageMgr* GetMessageMgr(); + + +#endif // MESSAGEMGR_H diff --git a/utils/vmpi/messbuf.cpp b/utils/vmpi/messbuf.cpp new file mode 100644 index 0000000..d0f65eb --- /dev/null +++ b/utils/vmpi/messbuf.cpp @@ -0,0 +1,279 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// +// MessageBuffer - handy for serializing/unserializing +// structures to be sent as messages +// dal - 9/2002 +// +#include <stdlib.h> +#include <string.h> +#include "messbuf.h" +#include "tier1/strtools.h" + + +/////////////////////////// +// +// +// +MessageBuffer::MessageBuffer() +{ + size = DEFAULT_MESSAGE_BUFFER_SIZE; + data = (char *) malloc(size); + len = 0; + offset = 0; +} + +/////////////////////////// +// +// +// +MessageBuffer::MessageBuffer(int minsize) +{ + size = minsize; + data = (char *) malloc(size); + len = 0; + offset = 0; +} + +/////////////////////////// +// +// +// +MessageBuffer::~MessageBuffer() +{ + free(data); +} + + +/////////////////////////// +// +// +// +int +MessageBuffer::getSize() +{ + return size; +} + +/////////////////////////// +// +// +// +int +MessageBuffer::getLen() +{ + return len; +} + +/////////////////////////// +// +// +// +int +MessageBuffer::setLen(int nlen) +{ + if (nlen < 0) return -1; + if (nlen > size) { + resize(nlen); + } + + int res = len; + len = nlen; + + return res; +} + +/////////////////////////// +// +// +// +int +MessageBuffer::getOffset() +{ + return offset; +} + +/////////////////////////// +// +// +// +int +MessageBuffer::setOffset(int noffset) +{ + if (noffset < 0 || noffset > len) return -1; + int res = offset; + offset = noffset; + + return res; +} + + +/////////////////////////// +// +// +// +int +MessageBuffer::write(void const * p, int bytes) +{ + if (bytes + len > size) { + resize(bytes + len); + } + memcpy(data + len, p, bytes); + int res = len; + len += bytes; + + return res; +} + +/////////////////////////// +// +// +// +int +MessageBuffer::update(int loc, void const * p, int bytes) +{ + if (loc + bytes > size) { + resize(loc + bytes); + } + memcpy(data + loc, p, bytes); + + if (len < loc + bytes) { + len = loc + bytes; + } + + return len; +} + +/////////////////////////// +// +// +// +int +MessageBuffer::extract(int loc, void * p, int bytes) +{ + if (loc + bytes > len) return -1; + memcpy(p, data + loc, bytes); + + return loc + bytes; +} + +/////////////////////////// +// +// +// +int +MessageBuffer::read(void * p, int bytes) +{ + if (offset + bytes > len) return -1; + memcpy(p, data + offset, bytes); + + offset += bytes; + return offset; +} + +int MessageBuffer::WriteString( const char *pString ) +{ + return write( pString, V_strlen( pString ) + 1 ); +} + +int MessageBuffer::ReadString( char *pOut, int bufferLength ) +{ + int nChars = 0; + while ( 1 ) + { + char ch; + if ( read( &ch, sizeof( ch ) ) == -1 ) + { + pOut[0] = 0; + return -1; + } + + if ( ch == 0 || nChars >= (bufferLength-1) ) + break; + + pOut[nChars] = ch; + ++nChars; + } + pOut[nChars] = 0; + return nChars + 1; +} + + +/////////////////////////// +// +// +// +void +MessageBuffer::clear() +{ + memset(data, 0, size); + offset = 0; + len = 0; +} + +/////////////////////////// +// +// +// +void +MessageBuffer::clear(int minsize) +{ + if (minsize > size) { + resize(minsize); + } + memset(data, 0, size); + offset = 0; + len = 0; +} + +/////////////////////////// +// +// +// +void +MessageBuffer::reset(int minsize) +{ + if (minsize > size) { + resize(minsize); + } + len = 0; + offset = 0; +} + +/////////////////////////// +// +// +// +void +MessageBuffer::resize(int minsize) +{ + if (minsize < size) return; + + if (size * 2 > minsize) minsize = size * 2; + + char * odata = data; + data = (char *) malloc(minsize); + memcpy(data, odata, len); + size = minsize; + free(odata); +} + + +/////////////////////////// +// +// +void +MessageBuffer::print(FILE * ofile, int num) +{ + fprintf(ofile, "Len: %d Offset: %d Size: %d\n", len, offset, size); + if (num > size) num = size; + for (int i=0; i<num; ++i) { + fprintf(ofile, "%02x ", (unsigned char) data[i]); + } + fprintf(ofile, "\n"); +}
\ No newline at end of file diff --git a/utils/vmpi/messbuf.h b/utils/vmpi/messbuf.h new file mode 100644 index 0000000..976ffa2 --- /dev/null +++ b/utils/vmpi/messbuf.h @@ -0,0 +1,52 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// +// MessageBuffer - handy for packing and upacking +// structures to be sent as messages +// +#ifndef _MESSAGEBUFFER +#define _MESSAGEBUFFER + +#include <stdio.h> +#define DEFAULT_MESSAGE_BUFFER_SIZE 2048 + +class MessageBuffer { + public: + char * data; + + MessageBuffer(); + MessageBuffer(int size); + ~MessageBuffer(); + + int getSize(); + int getLen(); + int setLen(int len); + int getOffset(); + int setOffset(int offset); + + int write(void const * p, int bytes); + int update(int loc, void const * p, int bytes); + int extract(int loc, void * p, int bytes); + int read(void * p, int bytes); + + int WriteString( const char *pString ); + int ReadString( char *pOut, int bufferLength ); + + void clear(); + void clear(int minsize); + void reset(int minsize); + void print(FILE * ofile, int num); + + private: + void resize(int minsize); + int size; + int offset; + int len; +}; + +#endif diff --git a/utils/vmpi/mysql_async.cpp b/utils/vmpi/mysql_async.cpp new file mode 100644 index 0000000..e4721a0 --- /dev/null +++ b/utils/vmpi/mysql_async.cpp @@ -0,0 +1,275 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//=============================================================================// + +#include <windows.h> +#include "imysqlwrapper.h" +#include "mysql_async.h" +#include "utllinkedlist.h" + + +static char* CopyString( const char *pStr ) +{ + char *pRet = new char[ strlen( pStr ) + 1 ]; + strcpy( pRet, pStr ); + return pRet; +} + + +class CMySQLAsync : public IMySQLAsync +{ +public: + + CMySQLAsync() + { + m_hThread = NULL; + m_pSQL = NULL; + + m_hExitEvent = CreateEvent( NULL, true, false, NULL ); // Use manual reset because we want it to cascade out without + // resetting the event if it gets set. + m_hPendingQueryEvent = CreateEvent( NULL, false, false, NULL ); + m_hQueryResultsEvent = CreateEvent( NULL, false, false, NULL ); + + InitializeCriticalSection( &m_ExecuteQueryCS ); + InitializeCriticalSection( &m_PendingQueryCS ); + } + + ~CMySQLAsync() + { + Term(); + + CloseHandle( m_hExitEvent ); + CloseHandle( m_hPendingQueryEvent ); + CloseHandle( m_hQueryResultsEvent ); + + DeleteCriticalSection( &m_ExecuteQueryCS ); + DeleteCriticalSection( &m_PendingQueryCS ); + } + + virtual void Release() + { + delete this; + } + + virtual IMySQLRowSet* ExecuteBlocking( const char *pStr ) + { + IMySQLRowSet *pRet; + + EnterCriticalSection( &m_ExecuteQueryCS ); + m_pSQL->Execute( pStr ); + pRet = m_pSQL->DuplicateRowSet(); + LeaveCriticalSection( &m_ExecuteQueryCS ); + + return pRet; + } + + virtual void Execute( const char *pStr, void *pUserData ) + { + EnterCriticalSection( &m_PendingQueryCS ); + + CPendingQuery query; + query.m_pStr = CopyString( pStr ); + query.m_pUserData = pUserData; + query.m_Timer.Start(); + + m_PendingQueries.AddToTail( query ); + SetEvent( m_hPendingQueryEvent ); + + LeaveCriticalSection( &m_PendingQueryCS ); + } + + virtual bool GetNextResults( CQueryResults &results ) + { + results.m_pResults = NULL; + + if ( WaitForSingleObject( m_hQueryResultsEvent, 0 ) == WAIT_OBJECT_0 ) + { + EnterCriticalSection( &m_PendingQueryCS ); + + Assert( m_QueryResults.Count() > 0 ); + int iHead = m_QueryResults.Head(); + results = m_QueryResults[iHead]; + m_QueryResults.Remove( iHead ); + + if ( m_QueryResults.Count() > 0 ) + SetEvent( m_hQueryResultsEvent ); + + LeaveCriticalSection( &m_PendingQueryCS ); + return true; + } + else + { + return false; + } + } + + bool Init( IMySQL *pSQL ) + { + Term(); + + DWORD dwThreadID; + m_hThread = CreateThread( NULL, 0, &CMySQLAsync::StaticThreadFn, this, 0, &dwThreadID ); + if ( m_hThread ) + { + m_pSQL = pSQL; + return true; + } + else + { + return false; + } + } + + void Term() + { + // Stop the thread. + if ( m_hThread ) + { + // Delete all our queries. + SetEvent( m_hExitEvent ); + WaitForSingleObject( m_hThread, INFINITE ); + CloseHandle( m_hThread ); + m_hThread = NULL; + } + + // Delete leftover queries. + FOR_EACH_LL( m_PendingQueries, iPendingQuery ) + { + delete [] m_PendingQueries[iPendingQuery].m_pStr; + } + m_PendingQueries.Purge(); + + FOR_EACH_LL( m_QueryResults, i ) + { + m_QueryResults[i].m_pResults->Release(); + } + m_QueryResults.Purge(); + + if ( m_pSQL ) + { + m_pSQL->Release(); + m_pSQL = NULL; + } + } + + +private: + + DWORD ThreadFn() + { + HANDLE hEvents[2] = { m_hExitEvent, m_hPendingQueryEvent }; + + // + while ( 1 ) + { + int ret = WaitForMultipleObjects( ARRAYSIZE( hEvents ), hEvents, false, INFINITE ); + if ( ret == WAIT_OBJECT_0 ) + break; + + if ( ret == WAIT_OBJECT_0+1 ) + { + // A new string has been queued up for us to execute. + EnterCriticalSection( &m_PendingQueryCS ); + + Assert( m_PendingQueries.Count() > 0 ); + int iHead = m_PendingQueries.Head(); + + CPendingQuery pending = m_PendingQueries[iHead]; + m_PendingQueries.Remove( iHead ); + + // Set the pending query event if there are more queries waiting to run. + if ( m_PendingQueries.Count() > 0 ) + SetEvent( m_hPendingQueryEvent ); + + LeaveCriticalSection( &m_PendingQueryCS ); + + + // Run the query. + EnterCriticalSection( &m_ExecuteQueryCS ); + + CQueryResults results; + results.m_pResults = NULL; + results.m_pUserData = pending.m_pUserData; + results.m_ExecuteTime.Init(); + pending.m_Timer.End(); + results.m_QueueTime = pending.m_Timer.GetDuration(); + + CFastTimer executeTimer; + executeTimer.Start(); + + if ( m_pSQL->Execute( pending.m_pStr ) == 0 ) + { + executeTimer.End(); + results.m_ExecuteTime = executeTimer.GetDuration(); + results.m_pResults = m_pSQL->DuplicateRowSet(); + } + + delete pending.m_pStr; + + LeaveCriticalSection( &m_ExecuteQueryCS ); + + + // Store the results. + EnterCriticalSection( &m_PendingQueryCS ); + + m_QueryResults.AddToTail( results ); + SetEvent( m_hQueryResultsEvent ); + + LeaveCriticalSection( &m_PendingQueryCS ); + } + } + + return 0; + } + + static DWORD WINAPI StaticThreadFn( LPVOID lpParameter ) + { + return ((CMySQLAsync*)lpParameter)->ThreadFn(); + } + +private: + + HANDLE m_hThread; + HANDLE m_hExitEvent; + HANDLE m_hPendingQueryEvent; // Signaled when a new query is added. + HANDLE m_hQueryResultsEvent; + + IMySQL *m_pSQL; + + CRITICAL_SECTION m_PendingQueryCS; + CRITICAL_SECTION m_ExecuteQueryCS; + + + // Outgoing query results. New ones are added to the tail. + CUtlLinkedList<CQueryResults, int> m_QueryResults; + + + // New ones added to the tail. + class CPendingQuery + { + public: + char *m_pStr; + void *m_pUserData; + CFastTimer m_Timer; // Times how long this query is in the queue. + }; + + CUtlLinkedList<CPendingQuery,int> m_PendingQueries; +}; + + +IMySQLAsync* CreateMySQLAsync( IMySQL *pSQL ) +{ + CMySQLAsync *pRet = new CMySQLAsync; + if ( pRet->Init( pSQL ) ) + { + return pRet; + } + else + { + delete pRet; + return NULL; + } +} + diff --git a/utils/vmpi/mysql_async.h b/utils/vmpi/mysql_async.h new file mode 100644 index 0000000..03844a2 --- /dev/null +++ b/utils/vmpi/mysql_async.h @@ -0,0 +1,56 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//=============================================================================// + +#ifndef MYSQL_ASYNC_H +#define MYSQL_ASYNC_H +#ifdef _WIN32 +#pragma once +#endif + + +#include "tier0/fasttimer.h" + + +class IMySQL; + + +class CQueryResults +{ +public: + IMySQLRowSet *m_pResults; + void *m_pUserData; // This is the value passed to Execute. + CCycleCount m_ExecuteTime; // How long it took to execute this query in MySQL. + CCycleCount m_QueueTime; // How long it spent in the queue. +}; + + +// This provides a way to do asynchronous MySQL queries. They are executed in a thread, +// then you can pop the results off as they arrive. +class IMySQLAsync +{ +public: + + virtual void Release() = 0; + + // After finishing the current query, if there is one, this immediately executes + // the specified query and returns its results. + virtual IMySQLRowSet* ExecuteBlocking( const char *pStr ) = 0; + + // Queue up a query. + virtual void Execute( const char *pStr, void *pUserData ) = 0; + + // Poll this to pick up results from Execute(). + // NOTE: if this returns true, but pResults is set to NULL, then that query had an error. + virtual bool GetNextResults( CQueryResults &results ) = 0; +}; + +// Create an async mysql interface. Note: if this call returns a non-null value, +// then after this call, you do NOT own pSQL anymore and you shouldn't ever call +// a function in it again. +IMySQLAsync* CreateMySQLAsync( IMySQL *pSQL ); + + +#endif // MYSQL_ASYNC_H diff --git a/utils/vmpi/mysql_wrapper.h b/utils/vmpi/mysql_wrapper.h new file mode 100644 index 0000000..01ca9d9 --- /dev/null +++ b/utils/vmpi/mysql_wrapper.h @@ -0,0 +1,104 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#ifndef MYSQL_WRAPPER_H +#define MYSQL_WRAPPER_H +#ifdef _WIN32 +#pragma once +#endif + + +#include "utlvector.h" + + +class IMySQL; + + +// This is a helper class to build queries like the stream IO. +class CMySQLQuery +{ +friend class CMySQL; + +public: + // This is like a sprintf, but it will grow the string as necessary. + void Format( PRINTF_FORMAT_STRING const char *pFormat, ... ); + +private: + CUtlVector<char> m_QueryText; +}; + + +class CColumnValue +{ +public: + + CColumnValue( CMySQL *pSQL, int iColumn ); + + const char* String(); + long Int32(); + unsigned long UInt32(); + +private: + CMySQL *m_pSQL; + int m_iColumn; +}; + + +class IMySQL +{ +public: + virtual void Release() = 0; + + // These execute SQL commands. They return 0 if the query was successful. + virtual int Execute( const char *pString ) = 0; + virtual int Execute( CMySQLQuery &query ) = 0; + + // If you just inserted rows into a table with an AUTO_INCREMENT column, + // then this returns the (unique) value of that column. + virtual unsigned long InsertID() = 0; + + // If you just executed a select statement, then you can use these functions to + // iterate over the result set. + + // Get the number of columns in the data returned from the last query (if it was a select statement). + virtual int NumFields() = 0; + + // Get the name of each column returned by the last query. + virtual const char* GetFieldName( int iColumn ) = 0; + + // Call this in a loop until it returns false to iterate over all rows the query returned. + virtual bool NextRow() = 0; + + // You can call this to start iterating over the result set from the start again. + // Note: after calling this, you have to call NextRow() to actually get the first row's value ready. + virtual bool SeekToFirstRow() = 0; + + virtual CColumnValue GetColumnValue( int iColumn ) = 0; + virtual CColumnValue GetColumnValue( const char *pColumnName ) = 0; + + // You can call this to get the index of a column for faster lookups with GetColumnValue( int ). + // Returns -1 if the column can't be found. + virtual int GetColumnIndex( const char *pColumnName ) = 0; +}; + + +IMySQL* InitMySQL( const char *pDBName, const char *pHostName="", const char *pUserName="", const char *pPassword="" ); + + + +// ------------------------------------------------------------------------------------------------ // +// Inlines. +// ------------------------------------------------------------------------------------------------ // + +inline CColumnValue::CColumnValue( CMySQL *pSQL, int iColumn ) +{ + m_pSQL = pSQL; + m_iColumn = iColumn; +} + + +#endif // MYSQL_WRAPPER_H diff --git a/utils/vmpi/net_view_thread.cpp b/utils/vmpi/net_view_thread.cpp new file mode 100644 index 0000000..19ab38d --- /dev/null +++ b/utils/vmpi/net_view_thread.cpp @@ -0,0 +1,208 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//=============================================================================// + +#include "stdafx.h" +#include "net_view_thread.h" + + +char* CopyAlloc( const char *pStr ) +{ + char *pRet = new char[ strlen( pStr ) + 1]; + strcpy( pRet, pStr ); + return pRet; +} + + +CNetViewThread::CNetViewThread() +{ + m_hThread = NULL; + m_hThreadExitEvent = NULL; + InitializeCriticalSection( &m_ComputerNamesCS ); +} + + +CNetViewThread::~CNetViewThread() +{ + Term(); + DeleteCriticalSection( &m_ComputerNamesCS ); +} + + +void CNetViewThread::Init() +{ + Term(); + + m_hThreadExitEvent = CreateEvent( NULL, false, false, NULL ); + + DWORD dwThreadID = 0; + m_hThread = CreateThread( + NULL, + 0, + &CNetViewThread::StaticThreadFn, + this, + 0, + &dwThreadID ); +} + + +void CNetViewThread::Term() +{ + if ( m_hThread ) + { + SetEvent( m_hThreadExitEvent ); + WaitForSingleObject( m_hThread, INFINITE ); + CloseHandle( m_hThread ); + m_hThread = NULL; + } + + if ( m_hThreadExitEvent ) + { + CloseHandle( m_hThreadExitEvent ); + m_hThreadExitEvent = NULL; + } +} + + +void CNetViewThread::GetComputerNames( CUtlVector<char*> &computerNames ) +{ + EnterCriticalSection( &m_ComputerNamesCS ); + + computerNames.Purge(); + for ( int i=0; i < m_ComputerNames.Count(); i++ ) + { + computerNames.AddToTail( CopyAlloc( m_ComputerNames[i] ) ); + } + + LeaveCriticalSection( &m_ComputerNamesCS ); +} + + +void CNetViewThread::UpdateServicesFromNetView() +{ + HANDLE hChildStdoutRd, hChildStdoutWr; + + // Set the bInheritHandle flag so pipe handles are inherited. + SECURITY_ATTRIBUTES saAttr; + saAttr.nLength = sizeof(SECURITY_ATTRIBUTES); + saAttr.bInheritHandle = TRUE; + saAttr.lpSecurityDescriptor = NULL; + + if( CreatePipe( &hChildStdoutRd, &hChildStdoutWr, &saAttr, 0 ) ) + { + STARTUPINFO si; + memset(&si, 0, sizeof si); + si.cb = sizeof(si); + si.dwFlags = STARTF_USESTDHANDLES; + si.hStdOutput = hChildStdoutWr; + + PROCESS_INFORMATION pi; + + if( CreateProcess( + NULL, + "net view", + NULL, // lpProcessAttributes + NULL, // lpThreadAttributes + TRUE, // bInheritHandls + DETACHED_PROCESS, // dwCreationFlags + NULL, // lpEnvironment + NULL, // lpCurrentDirectory + &si, // lpStartupInfo + &pi // lpProcessInformation + ) ) + { + // read from pipe.. + #define BUFFER_SIZE 8192 + char buffer[BUFFER_SIZE]; + BOOL bDone = FALSE; + CUtlVector<char> totalBuffer; + + while(1) + { + DWORD dwCount = 0; + DWORD dwRead = 0; + + // read from input handle + PeekNamedPipe(hChildStdoutRd, NULL, NULL, NULL, &dwCount, NULL); + if (dwCount) + { + dwCount = min (dwCount, (DWORD)BUFFER_SIZE - 1); + ReadFile(hChildStdoutRd, buffer, dwCount, &dwRead, NULL); + } + if(dwRead) + { + buffer[dwRead] = 0; + totalBuffer.AddMultipleToTail( dwRead, buffer ); + } + // check process termination + else if( WaitForSingleObject( pi.hProcess, 1000 ) != WAIT_TIMEOUT ) + { + if ( bDone ) + break; + + bDone = TRUE; // next time we get it + } + } + + // Now parse the output. + totalBuffer.AddToTail( 0 ); + ParseComputerNames( totalBuffer.Base() ); + } + + CloseHandle( hChildStdoutRd ); + CloseHandle( hChildStdoutWr ); + } +} + + +void CNetViewThread::ParseComputerNames( const char *pNetViewOutput ) +{ + EnterCriticalSection( &m_ComputerNamesCS ); + + m_ComputerNames.PurgeAndDeleteElements(); + + const char *pCur = pNetViewOutput; + while ( *pCur != 0 ) + { + // If we get a \\, then it's a computer name followed by whitespace. + if ( pCur[0] == '\\' && pCur[1] == '\\' ) + { + char curComputerName[512]; + char *pOutPos = curComputerName; + + pCur += 2; + while ( *pCur && !V_isspace( *pCur ) && (pOutPos-curComputerName < 510) ) + { + *pOutPos++ = *pCur++; + } + *pOutPos = 0; + + m_ComputerNames.AddToTail( CopyAlloc( curComputerName ) ); + } + ++pCur; + } + + LeaveCriticalSection( &m_ComputerNamesCS ); +} + + +DWORD CNetViewThread::ThreadFn() +{ + // Update the services list every 30 seconds. + do + { + UpdateServicesFromNetView(); + } while ( WaitForSingleObject( m_hThreadExitEvent, 30000 ) != WAIT_OBJECT_0 ); + + return 0; +} + + +DWORD CNetViewThread::StaticThreadFn( LPVOID lpParameter ) +{ + return ((CNetViewThread*)lpParameter)->ThreadFn(); +} + + diff --git a/utils/vmpi/net_view_thread.h b/utils/vmpi/net_view_thread.h new file mode 100644 index 0000000..4de4406 --- /dev/null +++ b/utils/vmpi/net_view_thread.h @@ -0,0 +1,45 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//=============================================================================// + +#ifndef NET_VIEW_THREAD_H +#define NET_VIEW_THREAD_H +#ifdef _WIN32 +#pragma once +#endif + + +#include "utlvector.h" + + +class CNetViewThread +{ +public: + CNetViewThread(); + ~CNetViewThread(); + + // This creates the thread that periodically checks "net view" to get the current list of + // machines out on the network. + void Init(); + void Term(); + + void GetComputerNames( CUtlVector<char*> &computerNames ); + +private: + + void UpdateServicesFromNetView(); + void ParseComputerNames( const char *pNetViewOutput ); + + DWORD ThreadFn(); + static DWORD WINAPI StaticThreadFn( LPVOID lpParameter ); + + CUtlVector<char*> m_ComputerNames; + HANDLE m_hThread; + HANDLE m_hThreadExitEvent; + CRITICAL_SECTION m_ComputerNamesCS; +}; + + +#endif // NET_VIEW_THREAD_H diff --git a/utils/vmpi/tcpsocket.cpp b/utils/vmpi/tcpsocket.cpp new file mode 100644 index 0000000..8ab67cf --- /dev/null +++ b/utils/vmpi/tcpsocket.cpp @@ -0,0 +1,1178 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + + +//#define PARANOID + +#if defined( PARANOID ) + #include <stdlib.h> + #include <crtdbg.h> +#endif + +#include <winsock2.h> +#include <mswsock.h> +#include "tcpsocket.h" +#include "tier1/utllinkedlist.h" +#include <stdio.h> +#include "threadhelpers.h" +#include "tier0/dbg.h" + + + +#error "I am TCPSocket and I suck. Use IThreadedTCPSocket or ThreadedTCPSocketEmu instead." + + +extern TIMEVAL SetupTimeVal( double flTimeout ); +extern void IPAddrToSockAddr( const CIPAddr *pIn, sockaddr_in *pOut ); +extern void SockAddrToIPAddr( const sockaddr_in *pIn, CIPAddr *pOut ); + + +#define SENTINEL_DISCONNECT -1 +#define SENTINEL_KEEPALIVE -2 + + +#define KEEPALIVE_INTERVAL_MS 3000 // keepalives are sent every N MS +#define KEEPALIVE_TIMEOUT_SECONDS 15.0 // connections timeout after this long + + +static bool g_bEnableTCPTimeout = true; + + +class CRecvData +{ +public: + int m_Count; + unsigned char m_Data[1]; +}; + + + +SOCKET TCPBind( const CIPAddr *pAddr ) +{ + // Create a socket to send and receive through. + SOCKET sock = WSASocket( AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED ); + if ( sock == INVALID_SOCKET ) + { + Assert( false ); + return INVALID_SOCKET; + } + + // bind to it! + sockaddr_in addr; + IPAddrToSockAddr( pAddr, &addr ); + + int status = bind( sock, (sockaddr*)&addr, sizeof(addr) ); + if ( status == 0 ) + { + return sock; + } + else + { + closesocket( sock ); + return INVALID_SOCKET; + } +} + + + +// ---------------------------------------------------------------------------------------- // +// TCP sockets. +// ---------------------------------------------------------------------------------------- // + +enum +{ + OP_RECV=111, + OP_SEND +}; + +// We use this for all OVERLAPPED structures. +class COverlappedPlus : public WSAOVERLAPPED +{ +public: + COverlappedPlus() + { + memset( this, 0, sizeof( WSAOVERLAPPED ) ); + } + + int m_OPType; // One of the OP_ defines. +}; + +typedef struct SendBuf_t +{ + COverlappedPlus m_Overlapped; + int m_Index; // Index into m_SendBufs. + int m_DataLength; + char m_Data[1]; +} SendBuf_s; + + +// These manage a thread that calls SendKeepalive() on all TCPSockets. +// AddGlobalTCPSocket shouldn't be called until you're ready for SendKeepalive() to be called. +class CTCPSocket; +void AddGlobalTCPSocket( CTCPSocket *pSocket ); +void RemoveGlobalTCPSocket( CTCPSocket *pSocket ); + + + +// ------------------------------------------------------------------------------------------ // +// CTCPSocket implementation. +// ------------------------------------------------------------------------------------------ // + +class CTCPSocket : public ITCPSocket +{ +friend class CTCPListenSocket; + +public: + + CTCPSocket() + { + m_Socket = INVALID_SOCKET; + m_bConnected = false; + + m_hIOCP = NULL; + + m_bShouldExitThreads = false; + m_bConnectionLost = false; + m_nSizeBytesReceived = 0; + + m_pIncomingData = NULL; + + memset( &m_RecvOverlapped, 0, sizeof( m_RecvOverlapped ) ); + m_RecvOverlapped.m_OPType = OP_RECV; + + m_hRecvSignal = CreateEvent( NULL, FALSE, FALSE, NULL ); + m_RecvStage = -1; + + m_MainThreadID = GetCurrentThreadId(); + } + + virtual ~CTCPSocket() + { + Term(); + CloseHandle( m_hRecvSignal ); + } + + void Term() + { + Assert( GetCurrentThreadId() == m_MainThreadID ); + + RemoveGlobalTCPSocket( this ); + + if ( m_Socket != SOCKET_ERROR && !m_bConnectionLost ) + { + SendDisconnectSentinel(); + + // Give the sends a second to complete. SO_LINGER is having trouble for some reason. + WaitForSendsToComplete( 1 ); + } + + + StopThreads(); + + if ( m_Socket != INVALID_SOCKET ) + { + closesocket( m_Socket ); + m_Socket = INVALID_SOCKET; + } + + if ( m_hIOCP ) + { + CloseHandle( m_hIOCP ); + m_hIOCP = NULL; + } + + m_bConnected = false; + m_bConnectionLost = true; + m_RecvStage = -1; + + FOR_EACH_LL( m_SendBufs, i ) + { + SendBuf_t *pSendBuf = m_SendBufs[i]; + ParanoidMemoryCheck( pSendBuf ); + free( pSendBuf ); + } + m_SendBufs.Purge(); + + FOR_EACH_LL( m_RecvDatas, j ) + { + CRecvData *pRecvData = m_RecvDatas[j]; + ParanoidMemoryCheck( pRecvData ); + free( pRecvData ); + } + m_RecvDatas.Purge(); + + if ( m_pIncomingData ) + { + ParanoidMemoryCheck( m_pIncomingData ); + free( m_pIncomingData ); + m_pIncomingData = 0; + } + } + + virtual void Release() + { + delete this; + } + + + void ParanoidMemoryCheck( void *ptr = NULL ) + { +#if defined( PARANOID ) + Assert( _CrtIsValidHeapPointer( this ) ); + + if ( ptr ) + { + Assert( _CrtIsValidHeapPointer( ptr ) ); + } + + Assert( _CrtCheckMemory() == TRUE ); +#endif + } + + + virtual bool BindToAny( const unsigned short port ) + { + Term(); + + CIPAddr addr( 0, 0, 0, 0, port ); // INADDR_ANY + m_Socket = TCPBind( &addr ); + if ( m_Socket == INVALID_SOCKET ) + { + return false; + } + else + { + SetInitialSocketOptions(); + return true; + } + } + + + // Set the initial socket options that we want. + void SetInitialSocketOptions() + { + // Set nodelay to improve latency. + BOOL val = TRUE; + setsockopt( m_Socket, IPPROTO_TCP, TCP_NODELAY, (const char FAR *)&val, sizeof(BOOL) ); + + // Make it linger for 3 seconds when it exits. + LINGER linger; + linger.l_onoff = 1; + linger.l_linger = 3; + setsockopt( m_Socket, SOL_SOCKET, SO_LINGER, (char*)&linger, sizeof( linger ) ); + } + + + // Called only by main thread interface functions. + // Returns true if the connection is lost. + bool CheckConnectionLost() + { + Assert( GetCurrentThreadId() == m_MainThreadID ); + + if ( m_Socket == SOCKET_ERROR ) + return true; + + // Have we timed out? + if ( g_bEnableTCPTimeout && (Plat_FloatTime() - m_LastRecvTime > KEEPALIVE_TIMEOUT_SECONDS) ) + { + SetConnectionLost( "Connection timed out." ); + } + + // Has any thread posted that the connection has been lost? + CCriticalSectionLock postLock( &m_ConnectionLostCS ); + postLock.Lock(); + if ( m_bConnectionLost ) + { + Term(); + return true; + } + else + { + return false; + } + } + + // Called by any thread. All interface functions call CheckConnectionLost() and return errors if it's lost. + void SetConnectionLost( const char *pErrorString, int err = -1 ) + { + CCriticalSectionLock postLock( &m_ConnectionLostCS ); + postLock.Lock(); + m_bConnectionLost = true; + postLock.Unlock(); + + // Handle it right away if we're in the main thread. If we're in an IO thread, + // it has to wait until the next interface function calls CheckConnectionLost(). + if ( GetCurrentThreadId() == m_MainThreadID ) + { + Term(); + } + + if ( pErrorString ) + { + m_ErrorString.CopyArray( pErrorString, strlen( pErrorString ) + 1 ); + } + else + { + char *lpMsgBuf; + FormatMessage( + FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + err, + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language + (LPTSTR) &lpMsgBuf, + 0, + NULL + ); + + m_ErrorString.CopyArray( lpMsgBuf, strlen( lpMsgBuf ) + 1 ); + LocalFree( lpMsgBuf ); + } + } + + + // -------------------------------------------------------------------------------------------------- // + // The receive code. + // -------------------------------------------------------------------------------------------------- // + + virtual bool StartWaitingForSize( bool bFresh ) + { + Assert( m_Socket != INVALID_SOCKET ); + Assert( m_bConnected ); + + m_RecvStage = 0; + m_RecvDataSize = -1; + if ( bFresh ) + m_nSizeBytesReceived = 0; + + DWORD dwNumBytesReceived = 0; + WSABUF buf = { sizeof( &m_RecvDataSize ) - m_nSizeBytesReceived, ((char*)&m_RecvDataSize) + m_nSizeBytesReceived }; + DWORD dwFlags = 0; + + int status = WSARecv( + m_Socket, + &buf, + 1, + &dwNumBytesReceived, + &dwFlags, + &m_RecvOverlapped, + NULL ); + + int err = -1; + if ( status == SOCKET_ERROR && (err = WSAGetLastError()) != ERROR_IO_PENDING ) + { + SetConnectionLost( NULL, err ); + return false; + } + else + { + return true; + } + } + + + bool PostNextDataPart() + { + DWORD dwNumBytesReceived = 0; + WSABUF buf = { m_RecvDataSize - m_AmountReceived, (char*)m_pIncomingData->m_Data + m_AmountReceived }; + DWORD dwFlags = 0; + + int status = WSARecv( + m_Socket, + &buf, + 1, + &dwNumBytesReceived, + &dwFlags, + &m_RecvOverlapped, + NULL ); + + int err = -1; + if ( status == SOCKET_ERROR && (err = WSAGetLastError()) != ERROR_IO_PENDING ) + { + SetConnectionLost( NULL, err ); + return false; + } + else + { + return true; + } + } + + + bool StartWaitingForData() + { + Assert( m_Socket != INVALID_SOCKET ); + Assert( m_RecvStage == 0 ); + Assert( m_bConnected ); + Assert( m_RecvDataSize > 0 ); + + m_RecvStage = 1; + + // Add a CRecvData element. + ParanoidMemoryCheck(); + m_pIncomingData = (CRecvData*)malloc( sizeof( CRecvData ) - 1 + m_RecvDataSize ); + if ( !m_pIncomingData ) + { + char str[512]; + _snprintf( str, sizeof( str ), "malloc() failed. m_RecvDataSize = %d\n", m_RecvDataSize ); + SetConnectionLost( str ); + return false; + } + + m_pIncomingData->m_Count = m_RecvDataSize; + + m_AmountReceived = 0; + + return PostNextDataPart(); + } + + virtual bool Recv( CUtlVector<unsigned char> &data, double flTimeout ) + { + if ( CheckConnectionLost() ) + return false; + + // Wait in 50ms chunks, checking for disconnections along the way. + bool bGotData = false; + DWORD msToWait = (DWORD)( flTimeout * 1000.0 ); + do + { + DWORD curWaitTime = min( msToWait, 50 ); + DWORD ret = WaitForSingleObject( m_hRecvSignal, curWaitTime ); + if ( ret == WAIT_OBJECT_0 ) + { + bGotData = true; + break; + } + + // Did the connection timeout? + if ( CheckConnectionLost() ) + return false; + + msToWait -= curWaitTime; + } while ( msToWait ); + + // If we never got a WAIT_OBJECT_0, then we never received anything. + if ( !bGotData ) + return false; + + + CCriticalSectionLock csLock( &m_RecvDataCS ); + csLock.Lock(); + + // Pickup the head m_RecvDatas element. + CRecvData *pRecvData = m_RecvDatas[ m_RecvDatas.Head() ]; + data.CopyArray( pRecvData->m_Data, pRecvData->m_Count ); + + // Now free it. + m_RecvDatas.Remove( m_RecvDatas.Head() ); + ParanoidMemoryCheck( pRecvData ); + free( pRecvData ); + + // Set the event again for the next time around, if there is more data waiting. + if ( m_RecvDatas.Count() > 0 ) + SetEvent( m_hRecvSignal ); + + return true; + } + + // INSIDE IO THREAD. + void HandleRecvCompletion( COverlappedPlus *pInfo, DWORD dwNumBytes ) + { + if ( dwNumBytes == 0 ) + { + SetConnectionLost( "Got 0 bytes in HandleRecvCompletion" ); + return; + } + + m_LastRecvTime = Plat_FloatTime(); + if ( m_RecvStage == 0 ) + { + m_nSizeBytesReceived += dwNumBytes; + if ( m_nSizeBytesReceived == sizeof( m_RecvDataSize ) ) + { + // Size of -1 means the other size is breaking the connection. + if ( m_RecvDataSize == SENTINEL_DISCONNECT ) + { + SetConnectionLost( "Got a graceful disconnect message." ); + return; + } + else if ( m_RecvDataSize == SENTINEL_KEEPALIVE ) + { + // No data follows this. Just let m_LastRecvTime get updated. + StartWaitingForSize( true ); + return; + } + + StartWaitingForData(); + } + else if ( m_nSizeBytesReceived < sizeof( m_RecvDataSize ) ) + { + // Handle the case where we only got some of the data (maybe one of the clients got disconnected). + StartWaitingForSize( false ); + } + else + { + // This case should never ever happen! +#if defined( _DEBUG ) + __asm int 3; +#endif + + SetConnectionLost( "Received too much data in a packet!" ); + return; + } + } + else if ( m_RecvStage == 1 ) + { + // Got the data, make sure we got it all. + m_AmountReceived += dwNumBytes; + + // Sanity check. +#if defined( _DEBUG ) + Assert( m_RecvDataSize == m_pIncomingData->m_Count ); + Assert( m_AmountReceived <= m_RecvDataSize ); // TODO: make this threadsafe for multiple IO threads. +#endif + + if ( m_AmountReceived == m_RecvDataSize ) + { + m_RecvStage = 2; + + // Add the data to the list of packets waiting to be picked up. + CCriticalSectionLock csLock( &m_RecvDataCS ); + csLock.Lock(); + + m_RecvDatas.AddToTail( m_pIncomingData ); + m_pIncomingData = NULL; + + if ( m_RecvDatas.Count() == 1 ) + SetEvent( m_hRecvSignal ); // Notify the Recv() function. + + StartWaitingForSize( true ); + } + else + { + PostNextDataPart(); + } + } + else + { + Assert( false ); + } + } + + + // -------------------------------------------------------------------------------------------------- // + // The send code. + // -------------------------------------------------------------------------------------------------- // + + virtual void WaitForSendsToComplete( double flTimeout ) + { + CWaitTimer waitTimer( flTimeout ); + while ( 1 ) + { + CCriticalSectionLock sendBufLock( &m_SendCS ); + sendBufLock.Lock(); + if( m_SendBufs.Count() == 0 ) + return; + sendBufLock.Unlock(); + + if ( waitTimer.ShouldKeepWaiting() ) + Sleep( 10 ); + else + break; + } + } + + + // This is called in the keepalive thread. + void SendKeepalive() + { + // Send a message saying we're exiting. + ParanoidMemoryCheck(); + SendBuf_t *pBuf = (SendBuf_t*)malloc( sizeof( SendBuf_t ) - 1 + sizeof( int ) ); + if ( !pBuf ) + { + SetConnectionLost( "malloc() in SendKeepalive() failed." ); + return; + } + + pBuf->m_DataLength = sizeof( int ); + *((int*)pBuf->m_Data) = SENTINEL_KEEPALIVE; + InternalSendDataBuf( pBuf ); + } + + + void SendDisconnectSentinel() + { + // Send a message saying we're exiting. + ParanoidMemoryCheck(); + SendBuf_t *pBuf = (SendBuf_t*)malloc( sizeof( SendBuf_t ) - 1 + sizeof( int ) ); + if ( pBuf ) + { + pBuf->m_DataLength = sizeof( int ); + *((int*)pBuf->m_Data) = SENTINEL_DISCONNECT; // This signifies that we're exiting. + InternalSendDataBuf( pBuf ); + } + } + + + virtual bool Send( const void *pData, int len ) + { + const void *pChunks[1] = { pData }; + int chunkLengths[1] = { len }; + return SendChunks( pChunks, chunkLengths, 1 ); + } + + + virtual bool SendChunks( void const * const *pChunks, const int *pChunkLengths, int nChunks ) + { + if ( CheckConnectionLost() ) + return false; + + CChunkWalker walker( pChunks, pChunkLengths, nChunks ); + int totalLength = walker.GetTotalLength(); + + if ( !totalLength ) + return true; + + // Create a buffer to hold the data and copy the data in. + ParanoidMemoryCheck(); + SendBuf_t *pBuf = (SendBuf_t*)malloc( sizeof( SendBuf_t ) - 1 + totalLength + sizeof( int ) ); + if ( !pBuf ) + { + char str[512]; + _snprintf( str, sizeof( str ), "malloc() in SendChunks() failed. totalLength = %d.", totalLength ); + SetConnectionLost( str ); + return false; + } + + pBuf->m_DataLength = totalLength + sizeof( int ); + + int *pByteCountPos = (int*)pBuf->m_Data; + *pByteCountPos = totalLength; + + char *pDataPos = &pBuf->m_Data[ sizeof( int ) ]; + walker.CopyTo( pDataPos, totalLength ); + + int status = InternalSendDataBuf( pBuf ); + int err = -1; + if ( status == SOCKET_ERROR && (err = WSAGetLastError()) != ERROR_IO_PENDING ) + { + SetConnectionLost( NULL, err ); + return false; + } + else + { + return true; + } + } + + + int InternalSendDataBuf( SendBuf_t *pBuf ) + { + // Protect against interference from the keepalive thread. + CCriticalSectionLock csLock( &m_SendCS ); + csLock.Lock(); + + + pBuf->m_Overlapped.m_OPType = OP_SEND; + pBuf->m_Overlapped.hEvent = NULL; + + // Add it to our list of buffers. + pBuf->m_Index = m_SendBufs.AddToTail( pBuf ); + + // Tell Winsock to send it. + WSABUF buf = { pBuf->m_DataLength, pBuf->m_Data }; + + DWORD dwNumBytesSent = 0; + return WSASend( + m_Socket, + &buf, + 1, + &dwNumBytesSent, + 0, + &pBuf->m_Overlapped, + NULL ); + } + + + // INSIDE IO THREAD. + void HandleSendCompletion( COverlappedPlus *pInfo, DWORD dwNumBytes ) + { + if ( dwNumBytes == 0 ) + { + SetConnectionLost( "0 bytes in HandleSendCompletion." ); + return; + } + + // Just free the buffer. + SendBuf_t *pBuf = (SendBuf_t*)pInfo; + Assert( dwNumBytes == (DWORD)pBuf->m_DataLength ); + + CCriticalSectionLock sendBufLock( &m_SendCS ); + sendBufLock.Lock(); + m_SendBufs.Remove( pBuf->m_Index ); + sendBufLock.Unlock(); + + ParanoidMemoryCheck( pBuf ); + free( pBuf ); + } + + + // -------------------------------------------------------------------------------------------------- // + // The connect code. + // -------------------------------------------------------------------------------------------------- // + + virtual bool BeginConnect( const CIPAddr &inputAddr ) + { + sockaddr_in addr; + IPAddrToSockAddr( &inputAddr, &addr ); + + m_bConnected = false; + int ret = connect( m_Socket, (struct sockaddr*)&addr, sizeof( addr ) ); + ret=ret; + + return true; + } + + + virtual bool UpdateConnect() + { + // We're still ok.. just wait until the socket becomes writable (is connected) or we timeout. + fd_set writeSet; + writeSet.fd_count = 1; + writeSet.fd_array[0] = m_Socket; + TIMEVAL timeVal = SetupTimeVal( 0 ); + + // See if it has a packet waiting. + int status = select( 0, NULL, &writeSet, NULL, &timeVal ); + if ( status > 0 ) + { + SetupConnected(); + return true; + } + + return false; + } + + + void SetupConnected() + { + m_bConnected = true; + m_bConnectionLost = false; + m_LastRecvTime = Plat_FloatTime(); + + CreateThreads(); + StartWaitingForSize( true ); + AddGlobalTCPSocket( this ); + } + + + virtual bool IsConnected() + { + CheckConnectionLost(); + return m_bConnected; + } + + + virtual void GetDisconnectReason( CUtlVector<char> &reason ) + { + reason = m_ErrorString; + } + + + // -------------------------------------------------------------------------------------------------- // + // Threads code. + // -------------------------------------------------------------------------------------------------- // + + // Create our IO Completion Port threads. + bool CreateThreads() + { + int nThreads = 1; + SetShouldExitThreads( false ); + + // Create our IO completion port and hook it to our socket. + m_hIOCP = CreateIoCompletionPort( + INVALID_HANDLE_VALUE, NULL, 0, 0); + + m_hIOCP = CreateIoCompletionPort( (HANDLE)m_Socket, m_hIOCP, (unsigned long)this, nThreads ); + + for ( int i=0; i < nThreads; i++ ) + { + DWORD dwThreadID = 0; + HANDLE hThread = CreateThread( + NULL, + 0, + &CTCPSocket::StaticThreadFn, + this, + 0, + &dwThreadID ); + + if ( hThread ) + { + SetThreadPriority( hThread, THREAD_PRIORITY_ABOVE_NORMAL ); + m_Threads.AddToTail( hThread ); + } + else + { + StopThreads(); + return false; + } + } + + return true; + } + + + void StopThreads() + { + // Tell the threads to exit, then wait for them to do so. + SetShouldExitThreads( true ); + WaitForMultipleObjects( m_Threads.Count(), m_Threads.Base(), TRUE, INFINITE ); + + for ( int i=0; i < m_Threads.Count(); i++ ) + { + CloseHandle( m_Threads[i] ); + } + m_Threads.Purge(); + } + + + void SetShouldExitThreads( bool bShouldExit ) + { + CCriticalSectionLock lock( &m_ThreadsCS ); + lock.Lock(); + m_bShouldExitThreads = bShouldExit; + } + + + bool ShouldExitThreads() + { + CCriticalSectionLock lock( &m_ThreadsCS ); + lock.Lock(); + + bool bRet = m_bShouldExitThreads; + return bRet; + } + + + DWORD ThreadFn() + { + while ( 1 ) + { + DWORD dwNumBytes = 0; + unsigned long pInputTCPSocket; + LPOVERLAPPED pOverlapped; + + if ( GetQueuedCompletionStatus( + m_hIOCP, // the port we're listening on + &dwNumBytes, // # bytes received on the port + &pInputTCPSocket,// "completion key" = CTCPSocket* + &pOverlapped, // the overlapped info that was passed into AcceptEx, WSARecv, or WSASend. + 100 // listen for 100ms at a time so we can exit gracefully when the socket is deleted. + ) ) + { + COverlappedPlus *pInfo = (COverlappedPlus*)pOverlapped; + ParanoidMemoryCheck( pInfo ); + + if ( pInfo->m_OPType == OP_RECV ) + { + Assert( pInfo == &m_RecvOverlapped ); + HandleRecvCompletion( pInfo, dwNumBytes ); + } + else + { + Assert( pInfo->m_OPType == OP_SEND ); + HandleSendCompletion( pInfo, dwNumBytes ); + } + } + + if ( ShouldExitThreads() ) + break; + } + + return 0; + } + + + static DWORD WINAPI StaticThreadFn( LPVOID pParameter ) + { + return ((CTCPSocket*)pParameter)->ThreadFn(); + } + + + +private: + + SOCKET m_Socket; + bool m_bConnected; + + + // m_RecvOverlapped is setup to first wait for the size, then the data. + // Then it is not posted until the app grabs the data. + HANDLE m_hRecvSignal; // Tells Recv() when we have data. + COverlappedPlus m_RecvOverlapped; + int m_RecvStage; // -1 = not initialized + // 0 = waiting for size + // 1 = waiting for data + // 2 = waiting for app to pickup the data + + CUtlLinkedList<CRecvData*,int> m_RecvDatas; // The head element is the next one to be picked up. + CRecvData *m_pIncomingData; // The packet we're currently receiving. + CCriticalSection m_RecvDataCS; // This protects adds and removes in the list. + + // These reference the element at the tail of m_RecvData. It is the current one getting + volatile int m_nSizeBytesReceived; // How much of m_RecvDataSize have we received yet? + int m_RecvDataSize; // this is received over the network + int m_AmountReceived; // How much we've received so far. + + // Last time we received anything from this connection. Used to determine if the connection is + // still active. + double m_LastRecvTime; + + + // Outgoing send buffers. + CUtlLinkedList<SendBuf_t*,int> m_SendBufs; + CCriticalSection m_SendCS; + + + // All the threads waiting for IO. + CUtlVector<HANDLE> m_Threads; + HANDLE m_hIOCP; + + // Used during shutdown. + volatile bool m_bShouldExitThreads; + CCriticalSection m_ThreadsCS; + + // For debugging. + DWORD m_MainThreadID; + + // Set by the main thread or IO threads to signal connection lost. + bool m_bConnectionLost; + CCriticalSection m_ConnectionLostCS; + + // This is set when we get disconnected. + CUtlVector<char> m_ErrorString; +}; + + +// ------------------------------------------------------------------------------------------ // +// ITCPListenSocket implementation. +// ------------------------------------------------------------------------------------------ // + +class CTCPListenSocket : public ITCPListenSocket +{ +public: + + CTCPListenSocket() + { + m_Socket = INVALID_SOCKET; + } + + + virtual ~CTCPListenSocket() + { + if ( m_Socket != INVALID_SOCKET ) + { + closesocket( m_Socket ); + } + } + + + // The main function to create one of these suckers. + static ITCPListenSocket* Create( const unsigned short port, int nQueueLength ) + { + CTCPListenSocket *pRet = new CTCPListenSocket; + if ( !pRet ) + return NULL; + + // Bind it to a socket and start listening. + CIPAddr addr( 0, 0, 0, 0, port ); // INADDR_ANY + pRet->m_Socket = TCPBind( &addr ); + if ( pRet->m_Socket == INVALID_SOCKET || + listen( pRet->m_Socket, nQueueLength == -1 ? SOMAXCONN : nQueueLength ) != 0 ) + { + pRet->Release(); + return false; + } + + return pRet; + } + + + virtual void Release() + { + delete this; + } + + + virtual ITCPSocket* UpdateListen( CIPAddr *pAddr ) + { + // We're still ok.. just wait until the socket becomes writable (is connected) or we timeout. + fd_set readSet; + readSet.fd_count = 1; + readSet.fd_array[0] = m_Socket; + TIMEVAL timeVal = SetupTimeVal( 0 ); + + // Wait until it connects. + int status = select( 0, &readSet, NULL, NULL, &timeVal ); + if ( status > 0 ) + { + sockaddr_in addr; + int addrSize = sizeof( addr ); + + // Now accept the final connection. + SOCKET newSock = accept( m_Socket, (struct sockaddr*)&addr, &addrSize ); + if ( newSock == INVALID_SOCKET ) + { + Assert( false ); + } + else + { + CTCPSocket *pRet = new CTCPSocket; + if ( !pRet ) + { + closesocket( newSock ); + return NULL; + } + + pRet->m_Socket = newSock; + pRet->SetInitialSocketOptions(); + pRet->SetupConnected(); + + // Report the address.. + SockAddrToIPAddr( &addr, pAddr ); + + return pRet; + } + } + + return NULL; + } + + +private: + SOCKET m_Socket; +}; + + + +ITCPListenSocket* CreateTCPListenSocket( const unsigned short port, int nQueueLength ) +{ + return CTCPListenSocket::Create( port, nQueueLength ); +} + + +ITCPSocket* CreateTCPSocket() +{ + return new CTCPSocket; +} + + +void TCPSocket_EnableTimeout( bool bEnable ) +{ + g_bEnableTCPTimeout = bEnable; +} + + +// --------------------------------------------------------------------------------- // +// This thread sends keepalives on all active TCP sockets. +// --------------------------------------------------------------------------------- // + +HANDLE g_hKeepaliveThread; +HANDLE g_hKeepaliveThreadSignal; +HANDLE g_hKeepaliveThreadReply; +CUtlLinkedList<CTCPSocket*,int> g_TCPSockets; +CCriticalSection g_TCPSocketsCS; + + +DWORD WINAPI TCPKeepaliveThread( LPVOID pParameter ) +{ + while ( 1 ) + { + if ( WaitForSingleObject( g_hKeepaliveThreadSignal, KEEPALIVE_INTERVAL_MS ) == WAIT_OBJECT_0 ) + break; + + // Tell all TCP sockets to send a keepalive. + CCriticalSectionLock csLock( &g_TCPSocketsCS ); + csLock.Lock(); + + FOR_EACH_LL( g_TCPSockets, i ) + { + g_TCPSockets[i]->SendKeepalive(); + } + } + + SetEvent( g_hKeepaliveThreadReply ); + return 0; +} + + +void AddGlobalTCPSocket( CTCPSocket *pSocket ) +{ + CCriticalSectionLock csLock( &g_TCPSocketsCS ); + csLock.Lock(); + + Assert( g_TCPSockets.Find( pSocket ) == g_TCPSockets.InvalidIndex() ); + g_TCPSockets.AddToTail( pSocket ); + + // If this is the first one, create the keepalive thread. + if ( g_TCPSockets.Count() == 1 ) + { + g_hKeepaliveThreadSignal = CreateEvent( NULL, false, false, NULL ); + g_hKeepaliveThreadReply = CreateEvent( NULL, false, false, NULL ); + + DWORD dwThreadID = 0; + g_hKeepaliveThread = CreateThread( + NULL, + 0, + TCPKeepaliveThread, + NULL, + 0, + &dwThreadID + ); + } +} + + +void RemoveGlobalTCPSocket( CTCPSocket *pSocket ) +{ + bool bThreadRunning = false; + DWORD dwExitCode = 0; + if ( GetExitCodeThread( g_hKeepaliveThread, &dwExitCode ) && dwExitCode == STILL_ACTIVE ) + { + bThreadRunning = true; + } + + CCriticalSectionLock csLock( &g_TCPSocketsCS ); + csLock.Lock(); + + int index = g_TCPSockets.Find( pSocket ); + if ( index != g_TCPSockets.InvalidIndex() ) + { + g_TCPSockets.Remove( index ); + + // If this was the last one, delete the thread. + if ( g_TCPSockets.Count() == 0 ) + { + csLock.Unlock(); + + if ( bThreadRunning ) + { + SetEvent( g_hKeepaliveThreadSignal ); + WaitForSingleObject( g_hKeepaliveThreadReply, INFINITE ); + } + + CloseHandle( g_hKeepaliveThreadSignal ); + CloseHandle( g_hKeepaliveThreadReply ); + CloseHandle( g_hKeepaliveThread ); + return; + } + } + + csLock.Unlock(); +} diff --git a/utils/vmpi/tcpsocket.h b/utils/vmpi/tcpsocket.h new file mode 100644 index 0000000..7cb2998 --- /dev/null +++ b/utils/vmpi/tcpsocket.h @@ -0,0 +1,84 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#ifndef ITCPSOCKET_H +#define ITCPSOCKET_H +#ifdef _WIN32 +#pragma once +#endif + + +#include "ichannel.h" +#include "iphelpers.h" + + +class ITCPSocket : public IChannel +{ +public: + virtual void Release() = 0; + + // Bind to the specified port on any address this host has. Note that the address the + // socket winds up with (and getsockname() returns) isn't decided until you send a packet. + virtual bool BindToAny( const unsigned short port ) = 0; + + + // Use these to connect to a remote listening socket without blocking. + // Call BeginConnect, then call UpdateConnect until it returns true. + virtual bool BeginConnect( const CIPAddr &addr ) = 0; + virtual bool UpdateConnect() = 0; + + + // Connection state. + virtual bool IsConnected() = 0; + + // If IsConnected returns false, you can call this to find out why the socket got disconnected. + virtual void GetDisconnectReason( CUtlVector<char> &reason ) = 0; + + + // Send data. Returns true if successful. + // + // Note: TCP likes to clump your packets together in one, so the data multiple send() calls will + // get concatenated and returned in one recv() call. ITCPSocket FIXES this behavior so your recv() + // calls match your send() calls. + // + virtual bool Send( const void *pData, int size ) = 0; + + // Receive data. Returns the number of bytes received. + // This will wait as long as flTimeout for something to come in. + // Returns false if no data was waiting. + virtual bool Recv( CUtlVector<unsigned char> &data, double flTimeout=0 ) = 0; +}; + + +// Use these to get incoming connections. +class ITCPListenSocket +{ +public: + // Call this to stop listening for connections and delete the object. + virtual void Release() = 0; + + // Keep calling this as long as you want to wait for connections. + virtual ITCPSocket* UpdateListen( CIPAddr *pAddr ) = 0; // pAddr is set to the remote process's address. +}; + + + + +// Use these to create the interfaces. +ITCPSocket* CreateTCPSocket(); + +// Create a socket to listen with. nQueueLength specifies how many connections to enqueue. +// When the queue runs out, connections can take a little longer to make. +ITCPListenSocket* CreateTCPListenSocket( const unsigned short port, int nQueueLength = -1 ); + + +// By default, timeouts are on. It's helpful to turn them off during debugging. +void TCPSocket_EnableTimeout( bool bEnable ); + + + +#endif // ITCPSOCKET_H diff --git a/utils/vmpi/tcpsocket_helpers.cpp b/utils/vmpi/tcpsocket_helpers.cpp new file mode 100644 index 0000000..c336b21 --- /dev/null +++ b/utils/vmpi/tcpsocket_helpers.cpp @@ -0,0 +1,48 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//=============================================================================// + +#include <windows.h> +#include "tcpsocket_helpers.h" + + +// This connects to an ISocket listening with Listen(). +bool TCPSocket_Connect( ITCPSocket *pSocket, const CIPAddr *pAddr, double flTimeout ) +{ + pSocket->BeginConnect( *pAddr ); + + CWaitTimer waitTimer( flTimeout ); + while ( 1 ) + { + if ( pSocket->UpdateConnect() ) + return true; + + if ( waitTimer.ShouldKeepWaiting() ) + Sleep( 10 ); + else + break; + } + + return false; +} + + +ITCPSocket* TCPSocket_ListenForOneConnection( ITCPListenSocket *pSocket, CIPAddr *pAddr, double flTimeout ) +{ + CWaitTimer waitTimer( flTimeout ); + while ( 1 ) + { + ITCPSocket *pRet = pSocket->UpdateListen( pAddr ); + if ( pRet ) + return pRet; + + if ( waitTimer.ShouldKeepWaiting() ) + Sleep( 10 ); + else + break; + } + + return NULL; +} diff --git a/utils/vmpi/tcpsocket_helpers.h b/utils/vmpi/tcpsocket_helpers.h new file mode 100644 index 0000000..870e7e9 --- /dev/null +++ b/utils/vmpi/tcpsocket_helpers.h @@ -0,0 +1,21 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//=============================================================================// + +#ifndef TCPSOCKET_HELPERS_H +#define TCPSOCKET_HELPERS_H +#ifdef _WIN32 +#pragma once +#endif + + +#include "tcpsocket.h" + + +bool TCPSocket_Connect( ITCPSocket *pSocket, const CIPAddr *pAddr, double flTimeout ); +ITCPSocket* TCPSocket_ListenForOneConnection( ITCPListenSocket *pSocket, CIPAddr *pAddr, double flTimeout ); + + +#endif // TCPSOCKET_HELPERS_H diff --git a/utils/vmpi/testapps/MessageWatch/MessageRecvMgr.h b/utils/vmpi/testapps/MessageWatch/MessageRecvMgr.h new file mode 100644 index 0000000..f570ddc --- /dev/null +++ b/utils/vmpi/testapps/MessageWatch/MessageRecvMgr.h @@ -0,0 +1,22 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#ifndef MESSAGERECVMGR_H +#define MESSAGERECVMGR_H +#ifdef _WIN32 +#pragma once +#endif + + +class IMessageRecvMgr +{ +public: + +}; + + +#endif // MESSAGERECVMGR_H diff --git a/utils/vmpi/testapps/MessageWatch/MessageWatch.cpp b/utils/vmpi/testapps/MessageWatch/MessageWatch.cpp new file mode 100644 index 0000000..4e8dab0 --- /dev/null +++ b/utils/vmpi/testapps/MessageWatch/MessageWatch.cpp @@ -0,0 +1,77 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// MessageWatch.cpp : Defines the class behaviors for the application. +// + +#include "stdafx.h" +#include "MessageWatch.h" +#include "MessageWatchDlg.h" + +#ifdef _DEBUG +#define new DEBUG_NEW +#undef THIS_FILE +static char THIS_FILE[] = __FILE__; +#endif + +///////////////////////////////////////////////////////////////////////////// +// CMessageWatchApp + +BEGIN_MESSAGE_MAP(CMessageWatchApp, CWinApp) + //{{AFX_MSG_MAP(CMessageWatchApp) + // NOTE - the ClassWizard will add and remove mapping macros here. + // DO NOT EDIT what you see in these blocks of generated code! + //}}AFX_MSG + ON_COMMAND(ID_HELP, CWinApp::OnHelp) +END_MESSAGE_MAP() + +///////////////////////////////////////////////////////////////////////////// +// CMessageWatchApp construction + +CMessageWatchApp::CMessageWatchApp() +{ + // TODO: add construction code here, + // Place all significant initialization in InitInstance +} + +///////////////////////////////////////////////////////////////////////////// +// The one and only CMessageWatchApp object + +CMessageWatchApp theApp; + +///////////////////////////////////////////////////////////////////////////// +// CMessageWatchApp initialization + +BOOL CMessageWatchApp::InitInstance() +{ + // Standard initialization + // If you are not using these features and wish to reduce the size + // of your final executable, you should remove from the following + // the specific initialization routines you do not need. + +#ifdef _AFXDLL + Enable3dControls(); // Call this when using MFC in a shared DLL +#else + Enable3dControlsStatic(); // Call this when linking to MFC statically +#endif + + CMessageWatchDlg dlg; + m_pMainWnd = &dlg; + int nResponse = dlg.DoModal(); + if (nResponse == IDOK) + { + // TODO: Place code here to handle when the dialog is + // dismissed with OK + } + else if (nResponse == IDCANCEL) + { + // TODO: Place code here to handle when the dialog is + // dismissed with Cancel + } + + return FALSE; +} diff --git a/utils/vmpi/testapps/MessageWatch/MessageWatch.h b/utils/vmpi/testapps/MessageWatch/MessageWatch.h new file mode 100644 index 0000000..3ad65ab --- /dev/null +++ b/utils/vmpi/testapps/MessageWatch/MessageWatch.h @@ -0,0 +1,56 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// MessageWatch.h : main header file for the MESSAGEWATCH application +// + +#if !defined(AFX_MESSAGEWATCH_H__72A09EC9_2B19_4AC5_A281_5FAD41F6DFCA__INCLUDED_) +#define AFX_MESSAGEWATCH_H__72A09EC9_2B19_4AC5_A281_5FAD41F6DFCA__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#ifndef __AFXWIN_H__ + #error include 'stdafx.h' before including this file for PCH +#endif + +#include "resource.h" // main symbols + +///////////////////////////////////////////////////////////////////////////// +// CMessageWatchApp: +// See MessageWatch.cpp for the implementation of this class +// + +class CMessageWatchApp : public CWinApp +{ +public: + CMessageWatchApp(); + +// Overrides + // ClassWizard generated virtual function overrides + //{{AFX_VIRTUAL(CMessageWatchApp) + public: + virtual BOOL InitInstance(); + //}}AFX_VIRTUAL + +// Implementation + + //{{AFX_MSG(CMessageWatchApp) + // NOTE - the ClassWizard will add and remove member functions here. + // DO NOT EDIT what you see in these blocks of generated code ! + //}}AFX_MSG + DECLARE_MESSAGE_MAP() +}; + + +///////////////////////////////////////////////////////////////////////////// + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_MESSAGEWATCH_H__72A09EC9_2B19_4AC5_A281_5FAD41F6DFCA__INCLUDED_) diff --git a/utils/vmpi/testapps/MessageWatch/MessageWatch.rc b/utils/vmpi/testapps/MessageWatch/MessageWatch.rc new file mode 100644 index 0000000..bfbbbd5 --- /dev/null +++ b/utils/vmpi/testapps/MessageWatch/MessageWatch.rc @@ -0,0 +1,194 @@ +//Microsoft Developer Studio generated resource script. +// +#include "resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#include "afxres.h" + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +// English (U.S.) resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +#ifdef _WIN32 +LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US +#pragma code_page(1252) +#endif //_WIN32 + +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE DISCARDABLE +BEGIN + "resource.h\0" +END + +2 TEXTINCLUDE DISCARDABLE +BEGIN + "#include ""afxres.h""\r\n" + "\0" +END + +3 TEXTINCLUDE DISCARDABLE +BEGIN + "#define _AFX_NO_SPLITTER_RESOURCES\r\n" + "#define _AFX_NO_OLE_RESOURCES\r\n" + "#define _AFX_NO_TRACKER_RESOURCES\r\n" + "#define _AFX_NO_PROPERTY_RESOURCES\r\n" + "\r\n" + "#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)\r\n" + "#ifdef _WIN32\r\n" + "LANGUAGE 9, 1\r\n" + "#pragma code_page(1252)\r\n" + "#endif //_WIN32\r\n" + "#include ""res\\MessageWatch.rc2"" // non-Microsoft Visual C++ edited resources\r\n" + "#include ""afxres.rc"" // Standard components\r\n" + "#endif\r\n" + "\0" +END + +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// Icon +// + +// Icon with lowest ID value placed first to ensure application icon +// remains consistent on all systems. +IDR_MAINFRAME ICON DISCARDABLE "res\\MessageWatch.ico" + +///////////////////////////////////////////////////////////////////////////// +// +// Dialog +// + +IDD_MESSAGEWATCH_DIALOG DIALOGEX 0, 0, 232, 147 +STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU +EXSTYLE WS_EX_APPWINDOW +CAPTION "MessageWatch" +FONT 8, "MS Sans Serif" +BEGIN + PUSHBUTTON "Quit",IDCANCEL,175,126,50,14 + LISTBOX IDC_MACHINES,7,7,218,114,LBS_SORT | LBS_NOINTEGRALHEIGHT | + WS_VSCROLL | WS_TABSTOP + PUSHBUTTON "&Show All",IDSHOWALL,7,126,50,14 + PUSHBUTTON "&Hide All",IDHIDEALL,91,126,50,14 +END + +IDD_OUTPUT DIALOG DISCARDABLE 0, 0, 320, 225 +STYLE WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Output" +FONT 8, "MS Sans Serif" +BEGIN + EDITTEXT IDC_DEBUG_OUTPUT,7,7,306,211,ES_MULTILINE | ES_READONLY | + WS_VSCROLL +END + + +#ifndef _MAC +///////////////////////////////////////////////////////////////////////////// +// +// Version +// + +VS_VERSION_INFO VERSIONINFO + FILEVERSION 1,0,0,1 + PRODUCTVERSION 1,0,0,1 + FILEFLAGSMASK 0x3fL +#ifdef _DEBUG + FILEFLAGS 0x1L +#else + FILEFLAGS 0x0L +#endif + FILEOS 0x4L + FILETYPE 0x1L + FILESUBTYPE 0x0L +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904B0" + BEGIN + VALUE "CompanyName", "\0" + VALUE "FileDescription", "MessageWatch MFC Application\0" + VALUE "FileVersion", "1, 0, 0, 1\0" + VALUE "InternalName", "MessageWatch\0" + VALUE "LegalCopyright", "Copyright (C) 2002\0" + VALUE "LegalTrademarks", "\0" + VALUE "OriginalFilename", "MessageWatch.EXE\0" + VALUE "ProductName", "MessageWatch Application\0" + VALUE "ProductVersion", "1, 0, 0, 1\0" + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 1200 + END +END + +#endif // !_MAC + + +///////////////////////////////////////////////////////////////////////////// +// +// DESIGNINFO +// + +#ifdef APSTUDIO_INVOKED +GUIDELINES DESIGNINFO DISCARDABLE +BEGIN + IDD_MESSAGEWATCH_DIALOG, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 225 + TOPMARGIN, 7 + BOTTOMMARGIN, 140 + END + + IDD_OUTPUT, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 313 + TOPMARGIN, 7 + BOTTOMMARGIN, 218 + END +END +#endif // APSTUDIO_INVOKED + +#endif // English (U.S.) resources +///////////////////////////////////////////////////////////////////////////// + + + +#ifndef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 3 resource. +// +#define _AFX_NO_SPLITTER_RESOURCES +#define _AFX_NO_OLE_RESOURCES +#define _AFX_NO_TRACKER_RESOURCES +#define _AFX_NO_PROPERTY_RESOURCES + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +#ifdef _WIN32 +LANGUAGE 9, 1 +#pragma code_page(1252) +#endif //_WIN32 +#include "res\MessageWatch.rc2" // non-Microsoft Visual C++ edited resources +#include "afxres.rc" // Standard components +#endif + +///////////////////////////////////////////////////////////////////////////// +#endif // not APSTUDIO_INVOKED + diff --git a/utils/vmpi/testapps/MessageWatch/MessageWatch.vcproj b/utils/vmpi/testapps/MessageWatch/MessageWatch.vcproj new file mode 100644 index 0000000..1fd1804 --- /dev/null +++ b/utils/vmpi/testapps/MessageWatch/MessageWatch.vcproj @@ -0,0 +1,282 @@ +<?xml version="1.0" encoding="Windows-1252"?> +<VisualStudioProject + ProjectType="Visual C++" + Version="7.10" + Name="MessageWatch" + ProjectGUID="{52DE0F9C-D5D8-4C31-A6EB-6841285BF1CB}" + SccProjectName="" + SccAuxPath="" + SccLocalPath="" + SccProvider="" + Keyword="MFCProj"> + <Platforms> + <Platform + Name="Win32"/> + </Platforms> + <Configurations> + <Configuration + Name="Debug|Win32" + OutputDirectory=".\Debug" + IntermediateDirectory=".\Debug" + ConfigurationType="1" + UseOfMFC="2" + ATLMinimizesCRunTimeLibraryUsage="FALSE" + CharacterSet="2"> + <Tool + Name="VCCLCompilerTool" + Optimization="0" + AdditionalIncludeDirectories="..\..\common,..\..\..\public,..\..\..\public\tier1,..\..\..\common,.." + PreprocessorDefinitions="_DEBUG;WIN32;_WINDOWS;PROTECTED_THINGS_DISABLE" + BasicRuntimeChecks="3" + RuntimeLibrary="3" + UsePrecompiledHeader="3" + PrecompiledHeaderThrough="stdafx.h" + PrecompiledHeaderFile=".\Debug/MessageWatch.pch" + AssemblerListingLocation=".\Debug/" + ObjectFile=".\Debug/" + ProgramDataBaseFileName=".\Debug/" + WarningLevel="3" + SuppressStartupBanner="TRUE" + DebugInformationFormat="4" + CompileAs="0"/> + <Tool + Name="VCCustomBuildTool" + CommandLine="copy "$(TargetPath)" ..\..\..\..\game\bin +" + Outputs="..\..\..\..\game\bin\messagewatch.exe"/> + <Tool + Name="VCLinkerTool" + AdditionalDependencies="ws2_32.lib" + OutputFile=".\Debug/MessageWatch.exe" + LinkIncremental="1" + SuppressStartupBanner="TRUE" + GenerateDebugInformation="TRUE" + ProgramDatabaseFile=".\Debug/MessageWatch.pdb" + SubSystem="2" + TargetMachine="1"/> + <Tool + Name="VCMIDLTool" + PreprocessorDefinitions="_DEBUG" + MkTypLibCompatible="TRUE" + SuppressStartupBanner="TRUE" + TargetEnvironment="1" + TypeLibraryName=".\Debug/MessageWatch.tlb" + HeaderFileName=""/> + <Tool + Name="VCPostBuildEventTool"/> + <Tool + Name="VCPreBuildEventTool"/> + <Tool + Name="VCPreLinkEventTool"/> + <Tool + Name="VCResourceCompilerTool" + PreprocessorDefinitions="_DEBUG" + Culture="1033"/> + <Tool + Name="VCWebServiceProxyGeneratorTool"/> + <Tool + Name="VCXMLDataGeneratorTool"/> + <Tool + Name="VCWebDeploymentTool"/> + <Tool + Name="VCManagedWrapperGeneratorTool"/> + <Tool + Name="VCAuxiliaryManagedWrapperGeneratorTool"/> + </Configuration> + <Configuration + Name="Release|Win32" + OutputDirectory=".\Release" + IntermediateDirectory=".\Release" + ConfigurationType="1" + UseOfMFC="2" + ATLMinimizesCRunTimeLibraryUsage="FALSE" + CharacterSet="2"> + <Tool + Name="VCCLCompilerTool" + Optimization="2" + InlineFunctionExpansion="1" + AdditionalIncludeDirectories="..\..\common,..\..\..\public,..\..\..\public\tier1,..\..\..\common,.." + PreprocessorDefinitions="NDEBUG;WIN32;_WINDOWS;PROTECTED_THINGS_DISABLE" + StringPooling="TRUE" + RuntimeLibrary="2" + EnableFunctionLevelLinking="TRUE" + UsePrecompiledHeader="3" + PrecompiledHeaderThrough="stdafx.h" + PrecompiledHeaderFile=".\Release/MessageWatch.pch" + AssemblerListingLocation=".\Release/" + ObjectFile=".\Release/" + ProgramDataBaseFileName=".\Release/" + WarningLevel="3" + SuppressStartupBanner="TRUE" + CompileAs="0"/> + <Tool + Name="VCCustomBuildTool" + CommandLine="copy "$(TargetPath)" ..\..\..\..\game\bin +" + Outputs="..\..\..\..\game\bin\messagewatch.exe"/> + <Tool + Name="VCLinkerTool" + AdditionalDependencies="ws2_32.lib" + OutputFile=".\Release/MessageWatch.exe" + LinkIncremental="1" + SuppressStartupBanner="TRUE" + ProgramDatabaseFile=".\Release/MessageWatch.pdb" + SubSystem="2" + TargetMachine="1"/> + <Tool + Name="VCMIDLTool" + PreprocessorDefinitions="NDEBUG" + MkTypLibCompatible="TRUE" + SuppressStartupBanner="TRUE" + TargetEnvironment="1" + TypeLibraryName=".\Release/MessageWatch.tlb" + HeaderFileName=""/> + <Tool + Name="VCPostBuildEventTool"/> + <Tool + Name="VCPreBuildEventTool"/> + <Tool + Name="VCPreLinkEventTool"/> + <Tool + Name="VCResourceCompilerTool" + PreprocessorDefinitions="NDEBUG" + Culture="1033"/> + <Tool + Name="VCWebServiceProxyGeneratorTool"/> + <Tool + Name="VCXMLDataGeneratorTool"/> + <Tool + Name="VCWebDeploymentTool"/> + <Tool + Name="VCManagedWrapperGeneratorTool"/> + <Tool + Name="VCAuxiliaryManagedWrapperGeneratorTool"/> + </Configuration> + </Configurations> + <References> + </References> + <Files> + <Filter + Name="Source Files" + Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"> + <File + RelativePath="..\..\common\consolewnd.cpp"> + </File> + <File + RelativePath="MessageWatch.cpp"> + </File> + <File + RelativePath="MessageWatch.rc"> + </File> + <File + RelativePath="MessageWatchDlg.cpp"> + </File> + <File + RelativePath="StdAfx.cpp"> + </File> + <File + RelativePath="win_idle.cpp"> + </File> + </Filter> + <Filter + Name="Header Files" + Filter="h;hpp;hxx;hm;inl"> + <File + RelativePath="..\..\common\consolewnd.h"> + </File> + <File + RelativePath="..\..\common\iphelpers.h"> + </File> + <File + RelativePath="..\..\common\messagemgr.h"> + </File> + <File + RelativePath="MessageWatch.h"> + </File> + <File + RelativePath="MessageWatchDlg.h"> + </File> + <File + RelativePath="Resource.h"> + </File> + <File + RelativePath="StdAfx.h"> + </File> + <File + RelativePath="..\..\common\tcpsocket.h"> + </File> + <File + RelativePath="..\..\common\threadhelpers.h"> + </File> + <File + RelativePath="win_idle.h"> + </File> + </Filter> + <Filter + Name="Resource Files" + Filter="ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"> + <File + RelativePath="res\MessageWatch.ico"> + </File> + <File + RelativePath="res\MessageWatch.rc2"> + </File> + </Filter> + <File + RelativePath="ReadMe.txt"> + </File> + <File + RelativePath="..\..\..\lib\public\tier0.lib"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCustomBuildTool" + Description="" + CommandLine=""/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCustomBuildTool" + Description="" + CommandLine=""/> + </FileConfiguration> + </File> + <File + RelativePath="..\..\..\lib\public\vmpi.lib"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCustomBuildTool" + Description="" + CommandLine=""/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCustomBuildTool" + Description="" + CommandLine=""/> + </FileConfiguration> + </File> + <File + RelativePath="..\..\..\lib\public\vstdlib.lib"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCustomBuildTool" + Description="" + CommandLine=""/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCustomBuildTool" + Description="" + CommandLine=""/> + </FileConfiguration> + </File> + </Files> + <Globals> + </Globals> +</VisualStudioProject> diff --git a/utils/vmpi/testapps/MessageWatch/MessageWatchDlg.cpp b/utils/vmpi/testapps/MessageWatch/MessageWatchDlg.cpp new file mode 100644 index 0000000..9098caa --- /dev/null +++ b/utils/vmpi/testapps/MessageWatch/MessageWatchDlg.cpp @@ -0,0 +1,324 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// MessageWatchDlg.cpp : implementation file +// + +#include "stdafx.h" +#include "MessageWatch.h" +#include "MessageWatchDlg.h" +#include "messagemgr.h" +#include "tier1/strtools.h" + +#ifdef _DEBUG +#define new DEBUG_NEW +#undef THIS_FILE +static char THIS_FILE[] = __FILE__; +#endif + + +#define WM_STARTIDLE (WM_USER + 565) + + +// --------------------------------------------------------------------------- // +// CSender. +// --------------------------------------------------------------------------- // + +CSender::CSender() +{ + m_pSocket = NULL; + m_pConsoleWnd = NULL; +} + +CSender::~CSender() +{ + if ( m_pSocket ) + m_pSocket->Release(); + + if ( m_pConsoleWnd ) + m_pConsoleWnd->Release(); +} + + +///////////////////////////////////////////////////////////////////////////// +// CMessageWatchDlg dialog + +CMessageWatchDlg::CMessageWatchDlg(CWnd* pParent /*=NULL*/) + : CDialog(CMessageWatchDlg::IDD, pParent) +{ + //{{AFX_DATA_INIT(CMessageWatchDlg) + // NOTE: the ClassWizard will add member initialization here + //}}AFX_DATA_INIT + // Note that LoadIcon does not require a subsequent DestroyIcon in Win32 + m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME); + + m_pListenSocket = NULL; +} + +CMessageWatchDlg::~CMessageWatchDlg() +{ + // destroy the sender objects. + + if ( m_pListenSocket ) + m_pListenSocket->Release(); +} + +void CMessageWatchDlg::DoDataExchange(CDataExchange* pDX) +{ + CDialog::DoDataExchange(pDX); + //{{AFX_DATA_MAP(CMessageWatchDlg) + DDX_Control(pDX, IDC_MACHINES, m_Machines); + //}}AFX_DATA_MAP +} + +BEGIN_MESSAGE_MAP(CMessageWatchDlg, CDialog) + //{{AFX_MSG_MAP(CMessageWatchDlg) + ON_MESSAGE(WM_STARTIDLE, OnStartIdle) + ON_WM_PAINT() + ON_WM_QUERYDRAGICON() + ON_LBN_DBLCLK(IDC_MACHINES, OnDblclkMachines) + ON_BN_CLICKED(IDSHOWALL, OnShowall) + ON_BN_CLICKED(IDHIDEALL, OnHideall) + //}}AFX_MSG_MAP +END_MESSAGE_MAP() + +///////////////////////////////////////////////////////////////////////////// +// CMessageWatchDlg message handlers + +BOOL CMessageWatchDlg::OnInitDialog() +{ + CDialog::OnInitDialog(); + + // Set the icon for this dialog. The framework does this automatically + // when the application's main window is not a dialog + SetIcon(m_hIcon, TRUE); // Set big icon + SetIcon(m_hIcon, FALSE); // Set small icon + + // Setup our listen socket and thread. + m_pListenSocket = CreateIPSocket(); + m_pListenSocket->BindToAny( MSGMGR_BROADCAST_PORT ); + + m_cWinIdle.StartIdle( GetSafeHwnd(), WM_STARTIDLE, 0, 0, 100 ); + m_cWinIdle.NextIdle(); + + return TRUE; // return TRUE unless you set the focus to a control +} + + +LONG CMessageWatchDlg::OnStartIdle( UINT, LONG ) +{ + MSG msg; + if (!PeekMessage(&msg, GetSafeHwnd(), 0,0, PM_NOREMOVE)) + OnIdle(); + m_cWinIdle.NextIdle(); + return 0; +} + + +void CMessageWatchDlg::OnIdle() +{ + // Kill dead connections. + int iNext; + for ( int iSender=m_Senders.Head(); iSender != m_Senders.InvalidIndex(); iSender = iNext ) + { + iNext = m_Senders.Next( iSender ); + + CSender *pSender = m_Senders[iSender]; + if ( pSender->m_pSocket && !pSender->m_pSocket->IsConnected() ) + { + // Just release the socket so the text stays there. + pSender->m_pSocket->Release(); + pSender->m_pSocket = NULL; + } + } + + // Look for new connections. + while ( 1 ) + { + CIPAddr ipFrom; + char data[16]; + int len = m_pListenSocket->RecvFrom( data, sizeof( data ), &ipFrom ); + if ( len == -1 ) + break; + + if ( data[0] == MSGMGR_PACKETID_ANNOUNCE_PRESENCE && + *((int*)&data[1]) == MSGMGR_VERSION ) + { + int iPort = *((int*)&data[5]); + + // See if we have a machine with this info yet. + CIPAddr connectAddr = ipFrom; + connectAddr.port = iPort; + + // NOTE: we'll accept connections from machines we were connected to earlier but + // lost the connection to. + CSender *pSender = FindSenderByAddr( ipFrom.ip ); + if ( !pSender || !pSender->m_pSocket ) + { + // 'nitiate the connection. + ITCPSocket *pNew = CreateTCPSocket(); + if ( pNew->BindToAny( 0 ) && TCPSocket_Connect( pNew, &connectAddr, 1000 ) ) + { + char nameStr[256]; + char title[512]; + if ( !ConvertIPAddrToString( &ipFrom, nameStr, sizeof( nameStr ) ) ) + Q_snprintf( nameStr, sizeof( nameStr ), "%d.%d.%d.%d", ipFrom.ip[0], ipFrom.ip[1], ipFrom.ip[2], ipFrom.ip[3] ); + + Q_snprintf( title, sizeof( title ), "%s:%d", nameStr, iPort ); + + // If the sender didn't exist yet, add a new one. + if ( !pSender ) + { + pSender = new CSender; + + IConsoleWnd *pWnd = CreateConsoleWnd( + AfxGetInstanceHandle(), + IDD_OUTPUT, + IDC_DEBUG_OUTPUT, + false + ); + + pSender->m_pConsoleWnd = pWnd; + pWnd->SetTitle( title ); + + Q_strncpy( pSender->m_Name, title, sizeof( pSender->m_Name ) ); + m_Senders.AddToTail( pSender ); + m_Machines.AddString( pSender->m_Name ); + } + + pSender->m_Addr = connectAddr; + pSender->m_pSocket = pNew; + } + else + { + pNew->Release(); + } + } + } + } + + + // Read input from our current connections. + FOR_EACH_LL( m_Senders, i ) + { + CSender *pSender = m_Senders[i]; + + while ( 1 ) + { + if ( !pSender->m_pSocket ) + break; + + CUtlVector<unsigned char> data; + if ( !pSender->m_pSocket->Recv( data ) ) + break; + + if ( data[0] == MSGMGR_PACKETID_MSG ) + { + char *pMsg = (char*)&data[1]; + pSender->m_pConsoleWnd->PrintToConsole( pMsg ); + OutputDebugString( pMsg ); + } + } + } +} + + +void CMessageWatchDlg::OnDestroy() +{ + // Stop the idling thread + m_cWinIdle.EndIdle(); + CDialog::OnDestroy(); +} + + +CSender* CMessageWatchDlg::FindSenderByAddr( const unsigned char ip[4] ) +{ + FOR_EACH_LL( m_Senders, i ) + { + if ( memcmp( m_Senders[i]->m_Addr.ip, ip, 4 ) == 0 ) + return m_Senders[i]; + } + return NULL; +} + + +CSender* CMessageWatchDlg::FindSenderByName( const char *pName ) +{ + FOR_EACH_LL( m_Senders, i ) + { + if ( stricmp( pName, m_Senders[i]->m_Name ) == 0 ) + return m_Senders[i]; + } + return NULL; +} + + +// If you add a minimize button to your dialog, you will need the code below +// to draw the icon. For MFC applications using the document/view model, +// this is automatically done for you by the framework. + +void CMessageWatchDlg::OnPaint() +{ + if (IsIconic()) + { + CPaintDC dc(this); // device context for painting + + SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0); + + // Center icon in client rectangle + int cxIcon = GetSystemMetrics(SM_CXICON); + int cyIcon = GetSystemMetrics(SM_CYICON); + CRect rect; + GetClientRect(&rect); + int x = (rect.Width() - cxIcon + 1) / 2; + int y = (rect.Height() - cyIcon + 1) / 2; + + // Draw the icon + dc.DrawIcon(x, y, m_hIcon); + } + else + { + CDialog::OnPaint(); + } +} + +// The system calls this to obtain the cursor to display while the user drags +// the minimized window. +HCURSOR CMessageWatchDlg::OnQueryDragIcon() +{ + return (HCURSOR) m_hIcon; +} + +void CMessageWatchDlg::OnDblclkMachines() +{ + int index = m_Machines.GetCurSel(); + if ( index != LB_ERR ) + { + CString str; + m_Machines.GetText( index, str ); + + CSender *pSender = FindSenderByName( str ); + if ( pSender ) + pSender->m_pConsoleWnd->SetVisible( true ); + } +} + +void CMessageWatchDlg::OnShowall() +{ + FOR_EACH_LL( m_Senders, i ) + { + m_Senders[i]->m_pConsoleWnd->SetVisible( true ); + } +} + +void CMessageWatchDlg::OnHideall() +{ + FOR_EACH_LL( m_Senders, i ) + { + m_Senders[i]->m_pConsoleWnd->SetVisible( false ); + } +} diff --git a/utils/vmpi/testapps/MessageWatch/MessageWatchDlg.h b/utils/vmpi/testapps/MessageWatch/MessageWatchDlg.h new file mode 100644 index 0000000..e495a54 --- /dev/null +++ b/utils/vmpi/testapps/MessageWatch/MessageWatchDlg.h @@ -0,0 +1,100 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// MessageWatchDlg.h : header file +// + +#if !defined(AFX_MESSAGEWATCHDLG_H__AB9CEAF4_0166_4CCA_9DEC_77C0918F78C4__INCLUDED_) +#define AFX_MESSAGEWATCHDLG_H__AB9CEAF4_0166_4CCA_9DEC_77C0918F78C4__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + + +#include "iphelpers.h" +#include "tcpsocket.h" +#include "threadhelpers.h" +#include "consolewnd.h" +#include "win_idle.h" + + +///////////////////////////////////////////////////////////////////////////// +// CMessageWatchDlg dialog + +class CSender +{ +public: + CSender(); + ~CSender(); + +public: + + CIPAddr m_Addr; + ITCPSocket *m_pSocket; + IConsoleWnd *m_pConsoleWnd; + char m_Name[128]; +}; + +class CMessageWatchDlg : public CDialog +{ +// Construction +public: + CMessageWatchDlg(CWnd* pParent = NULL); // standard constructor + ~CMessageWatchDlg(); + + + // Listen for broadcasts on this socket. + ISocket *m_pListenSocket; + + // Connections we've made. + CUtlLinkedList<CSender*,int> m_Senders; + + CCriticalSection m_SocketsCS; + CWinIdle m_cWinIdle; + + + CSender* FindSenderByAddr( const unsigned char ip[4] ); + CSender* FindSenderByName( const char *pName ); + + +// Dialog Data + //{{AFX_DATA(CMessageWatchDlg) + enum { IDD = IDD_MESSAGEWATCH_DIALOG }; + CListBox m_Machines; + //}}AFX_DATA + + // ClassWizard generated virtual function overrides + //{{AFX_VIRTUAL(CMessageWatchDlg) + protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support + //}}AFX_VIRTUAL + +// Implementation +protected: + HICON m_hIcon; + + void OnIdle(); + + // Generated message map functions + //{{AFX_MSG(CMessageWatchDlg) + afx_msg void OnDestroy(); + afx_msg LONG OnStartIdle(UINT, LONG); + virtual BOOL OnInitDialog(); + afx_msg void OnPaint(); + afx_msg HCURSOR OnQueryDragIcon(); + afx_msg void OnDblclkMachines(); + afx_msg void OnShowall(); + afx_msg void OnHideall(); + //}}AFX_MSG + DECLARE_MESSAGE_MAP() +}; + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_MESSAGEWATCHDLG_H__AB9CEAF4_0166_4CCA_9DEC_77C0918F78C4__INCLUDED_) diff --git a/utils/vmpi/testapps/MessageWatch/StdAfx.cpp b/utils/vmpi/testapps/MessageWatch/StdAfx.cpp new file mode 100644 index 0000000..43fa619 --- /dev/null +++ b/utils/vmpi/testapps/MessageWatch/StdAfx.cpp @@ -0,0 +1,15 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// stdafx.cpp : source file that includes just the standard includes +// MessageWatch.pch will be the pre-compiled header +// stdafx.obj will contain the pre-compiled type information + +#include "stdafx.h" + + + diff --git a/utils/vmpi/testapps/MessageWatch/StdAfx.h b/utils/vmpi/testapps/MessageWatch/StdAfx.h new file mode 100644 index 0000000..adf866a --- /dev/null +++ b/utils/vmpi/testapps/MessageWatch/StdAfx.h @@ -0,0 +1,33 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, but +// are changed infrequently +// + +#if !defined(AFX_STDAFX_H__70653A1B_FB34_4AD9_861C_580071240D6F__INCLUDED_) +#define AFX_STDAFX_H__70653A1B_FB34_4AD9_861C_580071240D6F__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers + +#include <afxwin.h> // MFC core and standard components +#include <afxext.h> // MFC extensions +#include <afxdtctl.h> // MFC support for Internet Explorer 4 Common Controls +#ifndef _AFX_NO_AFXCMN_SUPPORT +#include <afxcmn.h> // MFC support for Windows Common Controls +#endif // _AFX_NO_AFXCMN_SUPPORT + + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_STDAFX_H__70653A1B_FB34_4AD9_861C_580071240D6F__INCLUDED_) diff --git a/utils/vmpi/testapps/MessageWatch/res/MessageWatch.ico b/utils/vmpi/testapps/MessageWatch/res/MessageWatch.ico Binary files differnew file mode 100644 index 0000000..dc0d87d --- /dev/null +++ b/utils/vmpi/testapps/MessageWatch/res/MessageWatch.ico diff --git a/utils/vmpi/testapps/MessageWatch/res/MessageWatch.rc2 b/utils/vmpi/testapps/MessageWatch/res/MessageWatch.rc2 new file mode 100644 index 0000000..cf543e7 --- /dev/null +++ b/utils/vmpi/testapps/MessageWatch/res/MessageWatch.rc2 @@ -0,0 +1,13 @@ +// +// MESSAGEWATCH.RC2 - resources Microsoft Visual C++ does not edit directly +// + +#ifdef APSTUDIO_INVOKED + #error this file is not editable by Microsoft Visual C++ +#endif //APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// Add manually edited resources here... + +///////////////////////////////////////////////////////////////////////////// diff --git a/utils/vmpi/testapps/MessageWatch/resource.h b/utils/vmpi/testapps/MessageWatch/resource.h new file mode 100644 index 0000000..05f2c75 --- /dev/null +++ b/utils/vmpi/testapps/MessageWatch/resource.h @@ -0,0 +1,29 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +//{{NO_DEPENDENCIES}} +// Microsoft Developer Studio generated include file. +// Used by MessageWatch.rc +// +#define IDSHOWALL 3 +#define IDHIDEALL 4 +#define IDD_MESSAGEWATCH_DIALOG 102 +#define IDR_MAINFRAME 128 +#define IDD_OUTPUT 129 +#define IDC_MACHINES 1000 +#define IDC_DEBUG_OUTPUT 1000 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 129 +#define _APS_NEXT_COMMAND_VALUE 32771 +#define _APS_NEXT_CONTROL_VALUE 1001 +#define _APS_NEXT_SYMED_VALUE 101 +#endif +#endif diff --git a/utils/vmpi/testapps/MessageWatch/win_idle.cpp b/utils/vmpi/testapps/MessageWatch/win_idle.cpp new file mode 100644 index 0000000..69ac9da --- /dev/null +++ b/utils/vmpi/testapps/MessageWatch/win_idle.cpp @@ -0,0 +1,123 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// Class for sending idle messages to a window + +#include "stdafx.h" +#include "win_idle.h" + +// Stub function to get into the object's main thread loop +DWORD WINAPI CWinIdle::ThreadStub(LPVOID pIdle) +{ + return ((CWinIdle *)pIdle)->RunIdle(); +} + +CWinIdle::CWinIdle() : + m_hIdleThread(NULL), + m_hIdleEvent(NULL), + m_hStopEvent(NULL), + m_hWnd(0), + m_uMsg(0), + m_dwDelay(0) +{ +} + +CWinIdle::~CWinIdle() +{ + if (m_hIdleThread) + OutputDebugString("!!CWinIdle Warning!! Idle thread not shut down!\n"); +} + +DWORD CWinIdle::RunIdle() +{ + // Set up an event list + HANDLE aEvents[2]; + + aEvents[0] = m_hStopEvent; + aEvents[1] = m_hIdleEvent; + + // Wait for a stop or idle event + while (WaitForMultipleObjects(2, aEvents, FALSE, INFINITE) != WAIT_OBJECT_0) + { + // Send an idle message + PostMessage(m_hWnd, m_uMsg, m_wParam, m_lParam); + // Wait for a bit... + Sleep(m_dwDelay); + } + + return 0; +} + +BOOL CWinIdle::StartIdle(HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam, DWORD dwDelay) +{ + // Make sure it's not already running + if (m_hIdleThread) + return FALSE; + + // Make sure they send in a valid handle.. + if (!hWnd) + return FALSE; + + // Create the events + m_hIdleEvent = CreateEvent(NULL, FALSE, FALSE, NULL); + m_hStopEvent = CreateEvent(NULL, FALSE, FALSE, NULL); + + // Make sure the events got created + if ((!m_hIdleEvent) || (!m_hStopEvent)) + return FALSE; + + // Create the thread + DWORD dwThreadID; + m_hIdleThread = CreateThread(NULL, 0, CWinIdle::ThreadStub, (void *)this, 0, &dwThreadID); + + if (m_hIdleThread) + { + SetThreadPriority(m_hIdleThread, THREAD_PRIORITY_IDLE); + + m_hWnd = hWnd; + m_uMsg = uMessage; + m_wParam = wParam; + m_lParam = lParam; + + m_dwDelay = dwDelay; + } + + return m_hIdleThread != 0; +} + +BOOL CWinIdle::EndIdle() +{ + // Make sure it's running + if (!m_hIdleThread) + return FALSE; + + // Stop the idle thread + SetEvent(m_hStopEvent); + WaitForSingleObject(m_hIdleThread, INFINITE); + CloseHandle(m_hIdleThread); + + // Get rid of the event objects + CloseHandle(m_hIdleEvent); + CloseHandle(m_hStopEvent); + + // Set everything back to 0 + m_hIdleEvent = 0; + m_hStopEvent = 0; + m_hIdleThread = 0; + + return TRUE; +} + +void CWinIdle::NextIdle() +{ + // Make sure the thread's running + if (!m_hIdleThread) + return; + + // Signal an idle message + SetEvent(m_hIdleEvent); +} diff --git a/utils/vmpi/testapps/MessageWatch/win_idle.h b/utils/vmpi/testapps/MessageWatch/win_idle.h new file mode 100644 index 0000000..6e2e3f3 --- /dev/null +++ b/utils/vmpi/testapps/MessageWatch/win_idle.h @@ -0,0 +1,78 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// WinIdle.h - Defines a class for sending idle messages to a window from a secondary thread + +#ifndef __WINIDLE_H__ +#define __WINIDLE_H__ + + +class CWinIdle +{ +protected: + HANDLE m_hIdleEvent, m_hStopEvent; + + HWND m_hWnd; + UINT m_uMsg; + WPARAM m_wParam; + LPARAM m_lParam; + + DWORD m_dwDelay; + + HANDLE m_hIdleThread; + + // The thread calling stub + static DWORD WINAPI ThreadStub(LPVOID pIdle); + // The actual idle loop + virtual DWORD RunIdle(); + +public: + CWinIdle(); + virtual ~CWinIdle(); + + inline DWORD GetDelay() {return m_dwDelay;} + inline void SetDelay(DWORD delay) {m_dwDelay = delay;} + + // Member access + virtual HANDLE GetThreadHandle() const { return m_hIdleThread; }; + + // Start idling, and define the message and window to use + // Returns TRUE on success + virtual BOOL StartIdle(HWND hWnd, UINT uMessage, WPARAM wParam = 0, LPARAM lParam = 0, DWORD dwDelay = 0); + // Stop idling + // Returns TRUE on success + virtual BOOL EndIdle(); + // Notify the idle process that the message was received. + // Note : If this function is not called, the idle thread will not send any messages + virtual void NextIdle(); +}; + + +// Used to slow down the idle thread while dialogs are up. +class IdleChanger +{ +public: + IdleChanger(CWinIdle *pIdle, DWORD msDelay) + { + m_pIdle = pIdle; + m_OldDelay = pIdle->GetDelay(); + pIdle->SetDelay(msDelay); + } + + ~IdleChanger() + { + m_pIdle->SetDelay(m_OldDelay); + } + + CWinIdle *m_pIdle; + DWORD m_OldDelay; +}; + + + +#endif //__WINIDLE_H__ + diff --git a/utils/vmpi/testapps/ThreadedTCPSocketTest/StdAfx.cpp b/utils/vmpi/testapps/ThreadedTCPSocketTest/StdAfx.cpp new file mode 100644 index 0000000..538b0e0 --- /dev/null +++ b/utils/vmpi/testapps/ThreadedTCPSocketTest/StdAfx.cpp @@ -0,0 +1,15 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// stdafx.cpp : source file that includes just the standard includes +// ThreadedTCPSocketTest.pch will be the pre-compiled header +// stdafx.obj will contain the pre-compiled type information + +#include "stdafx.h" + +// TODO: reference any additional headers you need in STDAFX.H +// and not in this file diff --git a/utils/vmpi/testapps/ThreadedTCPSocketTest/StdAfx.h b/utils/vmpi/testapps/ThreadedTCPSocketTest/StdAfx.h new file mode 100644 index 0000000..e29801c --- /dev/null +++ b/utils/vmpi/testapps/ThreadedTCPSocketTest/StdAfx.h @@ -0,0 +1,31 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, but +// are changed infrequently +// + +#if !defined(AFX_STDAFX_H__AA10D99C_786F_4324_86C6_4D7CDE546561__INCLUDED_) +#define AFX_STDAFX_H__AA10D99C_786F_4324_86C6_4D7CDE546561__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers + +#include <stdio.h> +#include <windows.h> +#include <conio.h> + +// TODO: reference additional headers your program requires here + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_STDAFX_H__AA10D99C_786F_4324_86C6_4D7CDE546561__INCLUDED_) diff --git a/utils/vmpi/testapps/ThreadedTCPSocketTest/ThreadedTCPSocketTest.cpp b/utils/vmpi/testapps/ThreadedTCPSocketTest/ThreadedTCPSocketTest.cpp new file mode 100644 index 0000000..0b82c56 --- /dev/null +++ b/utils/vmpi/testapps/ThreadedTCPSocketTest/ThreadedTCPSocketTest.cpp @@ -0,0 +1,198 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// ThreadedTCPSocketTest.cpp : Defines the entry point for the console application. +// + +#include "stdafx.h" +#include "IThreadedTCPSocket.h" +#include "threadhelpers.h" +#include "vstdlib/random.h" + + +CCriticalSection g_MsgCS; + + +IThreadedTCPSocket *g_pClientSocket = NULL; +IThreadedTCPSocket *g_pServerSocket = NULL; + +CEvent g_ClientPacketEvent; +CUtlVector<char> g_ClientPacket; + + + +SpewRetval_t MySpewFunc( SpewType_t type, char const *pMsg ) +{ + CCriticalSectionLock csLock( &g_MsgCS ); + csLock.Lock(); + + printf( "%s", pMsg ); + OutputDebugString( pMsg ); + + csLock.Unlock(); + + if( type == SPEW_ASSERT ) + return SPEW_DEBUGGER; + else if( type == SPEW_ERROR ) + return SPEW_ABORT; + else + return SPEW_CONTINUE; +} + + +class CHandler_Server : public ITCPSocketHandler +{ +public: + virtual void Init( IThreadedTCPSocket *pSocket ) + { + } + + virtual void OnPacketReceived( CTCPPacket *pPacket ) + { + // Echo the data back. + g_pServerSocket->Send( pPacket->GetData(), pPacket->GetLen() ); + pPacket->Release(); + } + + virtual void OnError( int errorCode, const char *pErrorString ) + { + Msg( "Server error: %s\n", pErrorString ); + } +}; + + + +class CHandler_Client : public ITCPSocketHandler +{ +public: + virtual void Init( IThreadedTCPSocket *pSocket ) + { + } + + virtual void OnPacketReceived( CTCPPacket *pPacket ) + { + if ( g_ClientPacket.Count() < pPacket->GetLen() ) + g_ClientPacket.SetSize( pPacket->GetLen() ); + + memcpy( g_ClientPacket.Base(), pPacket->GetData(), pPacket->GetLen() ); + g_ClientPacketEvent.SetEvent(); + pPacket->Release(); + } + + virtual void OnError( int errorCode, const char *pErrorString ) + { + Msg( "Client error: %s\n", pErrorString ); + } +}; + + + +class CHandlerCreator_Server : public IHandlerCreator +{ +public: + virtual ITCPSocketHandler* CreateNewHandler() + { + return new CHandler_Server; + } +}; + +class CHandlerCreator_Client : public IHandlerCreator +{ +public: + virtual ITCPSocketHandler* CreateNewHandler() + { + return new CHandler_Client; + } +}; + + + +int main(int argc, char* argv[]) +{ + SpewOutputFunc( MySpewFunc ); + + // Figure out a random port to use. + CCycleCount cnt; + cnt.Sample(); + CUniformRandomStream randomStream; + randomStream.SetSeed( cnt.GetMicroseconds() ); + int iPort = randomStream.RandomInt( 20000, 30000 ); + + + g_ClientPacketEvent.Init( false, false ); + + + // Setup the "server". + CHandlerCreator_Server serverHandler; + CIPAddr addr( 127, 0, 0, 1, iPort ); + + ITCPConnectSocket *pListener = ThreadedTCP_CreateListener( + &serverHandler, + (unsigned short)iPort ); + + + // Setup the "client". + CHandlerCreator_Client clientCreator; + ITCPConnectSocket *pConnector = ThreadedTCP_CreateConnector( + CIPAddr( 127, 0, 0, 1, iPort ), + CIPAddr(), + &clientCreator ); + + + // Wait for them to connect. + while ( !g_pClientSocket ) + { + if ( !pConnector->Update( &g_pClientSocket ) ) + { + Error( "Error in client connector!\n" ); + } + } + pConnector->Release(); + + + while ( !g_pServerSocket ) + { + if ( !pListener->Update( &g_pServerSocket ) ) + Error( "Error in server connector!\n" ); + } + pListener->Release(); + + + // Send some data. + __int64 totalBytes = 0; + CCycleCount startTime; + int iPacket = 1; + + startTime.Sample(); + CUtlVector<char> buf; + + while ( (GetAsyncKeyState( VK_SHIFT ) & 0x8000) == 0 ) + { + int size = randomStream.RandomInt( 1024*0, 1024*320 ); + if ( buf.Count() < size ) + buf.SetSize( size ); + + if ( g_pClientSocket->Send( buf.Base(), size ) ) + { + // Server receives the data and echoes it back. Verify that the data is good. + WaitForSingleObject( g_ClientPacketEvent.GetEventHandle(), INFINITE ); + Assert( memcmp( g_ClientPacket.Base(), buf.Base(), size ) == 0 ); + + totalBytes += size; + CCycleCount curTime, elapsed; + curTime.Sample(); + CCycleCount::Sub( curTime, startTime, elapsed ); + double flSeconds = elapsed.GetSeconds(); + Msg( "Packet %d, %d bytes, %dk/sec\n", iPacket++, size, (int)(((totalBytes+511)/1024) / flSeconds) ); + } + } + + g_pClientSocket->Release(); + g_pServerSocket->Release(); + return 0; +} + diff --git a/utils/vmpi/testapps/ThreadedTCPSocketTest/ThreadedTCPSocketTest.vcproj b/utils/vmpi/testapps/ThreadedTCPSocketTest/ThreadedTCPSocketTest.vcproj new file mode 100644 index 0000000..60c80d4 --- /dev/null +++ b/utils/vmpi/testapps/ThreadedTCPSocketTest/ThreadedTCPSocketTest.vcproj @@ -0,0 +1,253 @@ +<?xml version="1.0" encoding="Windows-1252"?> +<VisualStudioProject + ProjectType="Visual C++" + Version="7.10" + Name="ThreadedTCPSocketTest" + ProjectGUID="{6973F221-D381-4569-901F-6D5311FB4CD5}" + SccProjectName="" + SccAuxPath="" + SccLocalPath="" + SccProvider=""> + <Platforms> + <Platform + Name="Win32"/> + </Platforms> + <Configurations> + <Configuration + Name="Debug|Win32" + OutputDirectory=".\Debug" + IntermediateDirectory=".\Debug" + ConfigurationType="1" + UseOfMFC="0" + ATLMinimizesCRunTimeLibraryUsage="FALSE" + CharacterSet="2"> + <Tool + Name="VCCLCompilerTool" + Optimization="0" + AdditionalIncludeDirectories="..,..\..\..\public,..\..\..\public\tier1" + PreprocessorDefinitions="_DEBUG;WIN32;_CONSOLE;PROTECTED_THINGS_DISABLE" + BasicRuntimeChecks="3" + RuntimeLibrary="1" + UsePrecompiledHeader="3" + PrecompiledHeaderThrough="stdafx.h" + PrecompiledHeaderFile=".\Debug/ThreadedTCPSocketTest.pch" + AssemblerListingLocation=".\Debug/" + ObjectFile=".\Debug/" + ProgramDataBaseFileName=".\Debug/" + WarningLevel="3" + SuppressStartupBanner="TRUE" + DebugInformationFormat="4" + CompileAs="0"/> + <Tool + Name="VCCustomBuildTool"/> + <Tool + Name="VCLinkerTool" + AdditionalDependencies="ws2_32.lib odbc32.lib odbccp32.lib" + OutputFile=".\Debug/ThreadedTCPSocketTest.exe" + LinkIncremental="1" + SuppressStartupBanner="TRUE" + GenerateDebugInformation="TRUE" + ProgramDatabaseFile=".\Debug/ThreadedTCPSocketTest.pdb" + SubSystem="1" + TargetMachine="1"/> + <Tool + Name="VCMIDLTool" + TypeLibraryName=".\Debug/ThreadedTCPSocketTest.tlb" + HeaderFileName=""/> + <Tool + Name="VCPostBuildEventTool"/> + <Tool + Name="VCPreBuildEventTool"/> + <Tool + Name="VCPreLinkEventTool"/> + <Tool + Name="VCResourceCompilerTool" + PreprocessorDefinitions="_DEBUG" + Culture="1033"/> + <Tool + Name="VCWebServiceProxyGeneratorTool"/> + <Tool + Name="VCXMLDataGeneratorTool"/> + <Tool + Name="VCWebDeploymentTool"/> + <Tool + Name="VCManagedWrapperGeneratorTool"/> + <Tool + Name="VCAuxiliaryManagedWrapperGeneratorTool"/> + </Configuration> + <Configuration + Name="Release|Win32" + OutputDirectory=".\Release" + IntermediateDirectory=".\Release" + ConfigurationType="1" + UseOfMFC="0" + ATLMinimizesCRunTimeLibraryUsage="FALSE" + CharacterSet="2"> + <Tool + Name="VCCLCompilerTool" + Optimization="2" + InlineFunctionExpansion="1" + AdditionalIncludeDirectories="..,..\..\..\public,..\..\..\public\tier1" + PreprocessorDefinitions="NDEBUG;WIN32;_CONSOLE;PROTECTED_THINGS_DISABLE" + StringPooling="TRUE" + RuntimeLibrary="0" + EnableFunctionLevelLinking="TRUE" + UsePrecompiledHeader="3" + PrecompiledHeaderThrough="stdafx.h" + PrecompiledHeaderFile=".\Release/ThreadedTCPSocketTest.pch" + AssemblerListingLocation=".\Release/" + ObjectFile=".\Release/" + ProgramDataBaseFileName=".\Release/" + WarningLevel="3" + SuppressStartupBanner="TRUE" + DebugInformationFormat="3" + CompileAs="0"/> + <Tool + Name="VCCustomBuildTool"/> + <Tool + Name="VCLinkerTool" + AdditionalDependencies="ws2_32.lib odbc32.lib odbccp32.lib" + OutputFile=".\Release/ThreadedTCPSocketTest.exe" + LinkIncremental="1" + SuppressStartupBanner="TRUE" + GenerateDebugInformation="TRUE" + ProgramDatabaseFile=".\Release/ThreadedTCPSocketTest.pdb" + SubSystem="1" + TargetMachine="1"/> + <Tool + Name="VCMIDLTool" + TypeLibraryName=".\Release/ThreadedTCPSocketTest.tlb" + HeaderFileName=""/> + <Tool + Name="VCPostBuildEventTool"/> + <Tool + Name="VCPreBuildEventTool"/> + <Tool + Name="VCPreLinkEventTool"/> + <Tool + Name="VCResourceCompilerTool" + PreprocessorDefinitions="NDEBUG" + Culture="1033"/> + <Tool + Name="VCWebServiceProxyGeneratorTool"/> + <Tool + Name="VCXMLDataGeneratorTool"/> + <Tool + Name="VCWebDeploymentTool"/> + <Tool + Name="VCManagedWrapperGeneratorTool"/> + <Tool + Name="VCAuxiliaryManagedWrapperGeneratorTool"/> + </Configuration> + </Configurations> + <References> + </References> + <Files> + <Filter + Name="Source Files" + Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"> + <File + RelativePath="StdAfx.cpp"> + </File> + <File + RelativePath="..\ThreadedTCPSocket.cpp"> + </File> + <File + RelativePath="..\ThreadedTCPSocketEmu.cpp"> + </File> + <File + RelativePath="ThreadedTCPSocketTest.cpp"> + </File> + </Filter> + <Filter + Name="Header Files" + Filter="h;hpp;hxx;hm;inl"> + <File + RelativePath="..\IThreadedTCPSocket.h"> + </File> + <File + RelativePath="StdAfx.h"> + </File> + <File + RelativePath="..\ThreadedTCPSocketEmu.h"> + </File> + </Filter> + <Filter + Name="Resource Files" + Filter="ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"> + </Filter> + <File + RelativePath="..\..\..\lib\public\dbg.lib"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCustomBuildTool" + Description="" + CommandLine=""/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCustomBuildTool" + Description="" + CommandLine=""/> + </FileConfiguration> + </File> + <File + RelativePath="..\..\..\lib\public\platform.lib"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCustomBuildTool" + Description="" + CommandLine=""/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCustomBuildTool" + Description="" + CommandLine=""/> + </FileConfiguration> + </File> + <File + RelativePath="ReadMe.txt"> + </File> + <File + RelativePath="..\..\..\lib\public\vmpi.lib"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCustomBuildTool" + Description="" + CommandLine=""/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCustomBuildTool" + Description="" + CommandLine=""/> + </FileConfiguration> + </File> + <File + RelativePath="..\..\..\lib\public\vstdlib.lib"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCustomBuildTool" + Description="" + CommandLine=""/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCustomBuildTool" + Description="" + CommandLine=""/> + </FileConfiguration> + </File> + </Files> + <Globals> + </Globals> +</VisualStudioProject> diff --git a/utils/vmpi/testapps/pingpong/StdAfx.cpp b/utils/vmpi/testapps/pingpong/StdAfx.cpp new file mode 100644 index 0000000..31353c4 --- /dev/null +++ b/utils/vmpi/testapps/pingpong/StdAfx.cpp @@ -0,0 +1,15 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// stdafx.cpp : source file that includes just the standard includes +// pingpong.pch will be the pre-compiled header +// stdafx.obj will contain the pre-compiled type information + +#include "stdafx.h" + +// TODO: reference any additional headers you need in STDAFX.H +// and not in this file diff --git a/utils/vmpi/testapps/pingpong/StdAfx.h b/utils/vmpi/testapps/pingpong/StdAfx.h new file mode 100644 index 0000000..59dfc17 --- /dev/null +++ b/utils/vmpi/testapps/pingpong/StdAfx.h @@ -0,0 +1,29 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, but +// are changed infrequently +// + +#if !defined(AFX_STDAFX_H__13A3CFA6_6BF8_45A8_A2CD_91444DCFF7C0__INCLUDED_) +#define AFX_STDAFX_H__13A3CFA6_6BF8_45A8_A2CD_91444DCFF7C0__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers + +#include <stdio.h> + +// TODO: reference additional headers your program requires here + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_STDAFX_H__13A3CFA6_6BF8_45A8_A2CD_91444DCFF7C0__INCLUDED_) diff --git a/utils/vmpi/testapps/pingpong/pingpong.cpp b/utils/vmpi/testapps/pingpong/pingpong.cpp new file mode 100644 index 0000000..e589197 --- /dev/null +++ b/utils/vmpi/testapps/pingpong/pingpong.cpp @@ -0,0 +1,308 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// pingpong.cpp : Defines the entry point for the console application. +// + +#include "stdafx.h" +#include <assert.h> +#include <stdlib.h> +#include "tcpsocket.h" +#include "tier0/fasttimer.h" +#include "vmpi.h" +#include "tcpsocket_helpers.h" + +//#define USE_MPI + + +#if defined( USE_MPI ) + #include "mpi/mpi.h" + #include "vmpi.h" + #include "tier1/bitbuf.h" + + int myProcId = -1; +#else + IChannel *g_pSocket = NULL; + int g_iPortNum = 27141; +#endif + + +int PrintUsage() +{ + printf( "pingpong <-server or -client ip>\n" ); + return 1; +} + + +void DoClientConnect( const char *pIP ) +{ +#if defined( USE_MPI ) + int argc = 1; + char *testargv[1] = { "-nounc" }; + char **argv = testargv; + if ( MPI_Init( &argc, &argv ) ) + { + assert( false ); + } + MPI_Comm_rank( MPI_COMM_WORLD, &myProcId ); + + int nProcs; + MPI_Comm_size( MPI_COMM_WORLD, &nProcs ); + if ( nProcs != 2 ) + { + assert( false ); + } +#else + // Try to connect, or listen. + ITCPSocket *pTCPSocket = CreateTCPSocket(); + if ( !pTCPSocket->BindToAny( 0 ) ) + { + assert( false ); + } + + CIPAddr addr; + if ( !ConvertStringToIPAddr( pIP, &addr ) ) + { + assert( false ); + } + + addr.port = g_iPortNum; + printf( "Client connecting to %d.%d.%d.%d:%d\n", addr.ip[0], addr.ip[1], addr.ip[2], addr.ip[3], addr.port ); + if ( !TCPSocket_Connect( pTCPSocket, &addr, 50000 ) ) + { + assert( false ); + } + + printf( "Client connected...\n "); + g_pSocket = pTCPSocket; +#endif +} + + +void DoServerConnect() +{ +#if defined( USE_MPI ) + ISocket *pSocket = CreateIPSocket(); + if ( !pSocket ) + { + printf( "Error creating a socket.\n" ); + assert( false ); + return; + } + else if ( !pSocket->BindToAny( VMPI_SERVICE_PORT ) ) + { + printf( "Error binding a socket to port %d.\n", VMPI_SERVICE_PORT ); + assert( false ); + return; + } + + printf( "Waiting for jobs...\n" ); + while ( 1 ) + { + // Any incoming packets? + char data[2048]; + CIPAddr ipFrom; + int len = pSocket->RecvFrom( data, sizeof( data ), &ipFrom ); + if ( len > 3 ) + { + bf_read buf( data, len ); + if ( buf.ReadByte() == VMPI_PROTOCOL_VERSION ) + { + if ( buf.ReadByte() == VMPI_LOOKING_FOR_WORKERS ) + { + // Read the listen port. + int iListenPort = buf.ReadLong(); + + static char ipString[128]; + _snprintf( ipString, sizeof( ipString ), "%d.%d.%d.%d:%d", ipFrom.ip[0], ipFrom.ip[1], ipFrom.ip[2], ipFrom.ip[3], iListenPort ); + + int argc = 3; + char *testargv[3]; + testargv[0] = "<supposedly the executable name!>"; + testargv[1] = "-mpi_worker"; + testargv[2] = ipString; + + char **argv = testargv; + if ( MPI_Init( &argc, &argv ) ) + { + assert( false ); + } + MPI_Comm_rank( MPI_COMM_WORLD, &myProcId ); + + int nProcs; + MPI_Comm_size( MPI_COMM_WORLD, &nProcs ); + if ( nProcs != 2 ) + { + assert( false ); + } + break; + } + } + } + + Sleep( 100 ); + } + + pSocket->Release(); +#else + // Try to connect, or listen. + ITCPListenSocket *pListen = CreateTCPListenSocket( g_iPortNum ); + if ( !pListen ) + { + assert( false ); + } + + printf( "Server listening...\n" ); + + CIPAddr addr; + ITCPSocket *pTCPSocket = TCPSocket_ListenForOneConnection( pListen, &addr, 50000 ); + if ( !pTCPSocket ) + { + assert( false ); + } + pListen->Release(); + + printf( "Server connected...\n "); + g_pSocket = pTCPSocket; +#endif +} + + +void SendData( const void *pBuf, int size ) +{ +#if defined( USE_MPI ) + MPI_Send( (void*)pBuf, size, MPI_BYTE, !myProcId, 0, MPI_COMM_WORLD ); +#else + g_pSocket->Send( pBuf, size ); +#endif +} + + +void RecvData( CUtlVector<unsigned char> &recvBuf ) +{ +#if defined( USE_MPI ) + MPI_Status stat; + MPI_Probe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &stat); + + recvBuf.SetCount( stat.count ); + MPI_Recv( recvBuf.Base(), stat.count, MPI_BYTE, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &stat); +#else + if ( !g_pSocket->Recv( recvBuf, 50000 ) ) + { + g_pSocket->Release(); + g_pSocket = NULL; + } +#endif +} + + +int main( int argc, char* argv[] ) +{ + if ( argc < 2 ) + { + return PrintUsage(); + } + + const char *pClientOrServer = argv[1]; + const char *pIP = NULL; + + bool bClient = false; + if ( stricmp( pClientOrServer, "-client" ) == 0 ) + { + if ( argc < 3 ) + { + return PrintUsage(); + } + + bClient = true; + pIP = argv[2]; + } + + CUtlVector<unsigned char> recvBuf; + if ( bClient ) + { + DoClientConnect( pIP ); + + // Ok, now start blasting packets of different sizes and measure how long it takes to get an ack back. + int nIterations = 30; + + for ( int size=350; size <= 350000; size += 512 ) + { + CUtlVector<unsigned char> buf; + buf.SetCount( size ); + + double flTotalRoundTripTime = 0; + + CFastTimer throughputTimer; + throughputTimer.Start(); + + for ( int i=0; i < nIterations; i++ ) + { + for ( int z=0; z < size; z++ ) + buf[z] = (char)rand(); + + SendData( buf.Base(), buf.Count() ); + + CFastTimer timer; + timer.Start(); + RecvData( recvBuf ); + timer.End(); + + + // Make sure we got the same data back. + assert( recvBuf.Count() == buf.Count() ); + for ( z=0; z < size; z++ ) + { + assert( recvBuf[z] == buf[z] ); + } + + + //if ( i % 100 == 0 ) + // printf( "%05d\n", i ); +printf( "%d\n", i ); + flTotalRoundTripTime += timer.GetDuration().GetMillisecondsF(); + } + throughputTimer.End(); + double flTotalSeconds = throughputTimer.GetDuration().GetSeconds(); + + double flAvgRoundTripTime = flTotalRoundTripTime / nIterations; + printf( "%d: %.2f ms per roundtrip (%d bytes/sec) sec: %.2f megs: %.2f\n", + size, + flAvgRoundTripTime, + (int)((size*nIterations)/flTotalSeconds), + flTotalSeconds, + (double)(size*nIterations) / (1024*1024) ); + } + + // Send an 'end' message to the server. + int val = -1; + SendData( &val, sizeof( val ) ); + } + else + { + // Wait for a connection. + DoServerConnect(); + + // Wait for packets and ack them. + while ( 1 ) + { + RecvData( recvBuf ); + if ( !g_pSocket ) + break; + + if ( recvBuf.Count() < 4 ) + { + assert( false ); + } + + SendData( recvBuf.Base(), recvBuf.Count() ); + } + } + + return 0; +} + diff --git a/utils/vmpi/testapps/pingpong/pingpong.vcproj b/utils/vmpi/testapps/pingpong/pingpong.vcproj new file mode 100644 index 0000000..e162afb --- /dev/null +++ b/utils/vmpi/testapps/pingpong/pingpong.vcproj @@ -0,0 +1,245 @@ +<?xml version="1.0" encoding="Windows-1252"?> +<VisualStudioProject + ProjectType="Visual C++" + Version="7.10" + Name="pingpong" + ProjectGUID="{5E114A75-BC7C-4E3A-895D-47C097AFF02B}" + SccProjectName="" + SccAuxPath="" + SccLocalPath="" + SccProvider=""> + <Platforms> + <Platform + Name="Win32"/> + </Platforms> + <Configurations> + <Configuration + Name="Release|Win32" + OutputDirectory=".\Release" + IntermediateDirectory=".\Release" + ConfigurationType="1" + UseOfMFC="0" + ATLMinimizesCRunTimeLibraryUsage="FALSE" + CharacterSet="2"> + <Tool + Name="VCCLCompilerTool" + Optimization="2" + InlineFunctionExpansion="1" + AdditionalIncludeDirectories="..\..\..\public,..\..\common,..\..\vmpi" + PreprocessorDefinitions="NDEBUG;WIN32;_CONSOLE;PROTECTED_THINGS_DISABLE" + StringPooling="TRUE" + RuntimeLibrary="0" + EnableFunctionLevelLinking="TRUE" + PrecompiledHeaderFile=".\Release/pingpong.pch" + AssemblerListingLocation=".\Release/" + ObjectFile=".\Release/" + ProgramDataBaseFileName=".\Release/" + WarningLevel="4" + SuppressStartupBanner="TRUE" + DebugInformationFormat="3" + CompileAs="0"/> + <Tool + Name="VCCustomBuildTool"/> + <Tool + Name="VCLinkerTool" + AdditionalDependencies="ws2_32.lib odbc32.lib odbccp32.lib" + OutputFile=".\Release/pingpong.exe" + LinkIncremental="1" + SuppressStartupBanner="TRUE" + IgnoreAllDefaultLibraries="FALSE" + IgnoreDefaultLibraryNames="libcmtd.lib" + GenerateDebugInformation="TRUE" + ProgramDatabaseFile=".\Release/pingpong.pdb" + SubSystem="1" + TargetMachine="1"/> + <Tool + Name="VCMIDLTool" + TypeLibraryName=".\Release/pingpong.tlb" + HeaderFileName=""/> + <Tool + Name="VCPostBuildEventTool"/> + <Tool + Name="VCPreBuildEventTool"/> + <Tool + Name="VCPreLinkEventTool"/> + <Tool + Name="VCResourceCompilerTool" + PreprocessorDefinitions="NDEBUG" + Culture="1033"/> + <Tool + Name="VCWebServiceProxyGeneratorTool"/> + <Tool + Name="VCXMLDataGeneratorTool"/> + <Tool + Name="VCWebDeploymentTool"/> + <Tool + Name="VCManagedWrapperGeneratorTool"/> + <Tool + Name="VCAuxiliaryManagedWrapperGeneratorTool"/> + </Configuration> + <Configuration + Name="Debug|Win32" + OutputDirectory=".\Debug" + IntermediateDirectory=".\Debug" + ConfigurationType="1" + UseOfMFC="0" + ATLMinimizesCRunTimeLibraryUsage="FALSE" + CharacterSet="2"> + <Tool + Name="VCCLCompilerTool" + Optimization="0" + AdditionalIncludeDirectories="..\..\..\public,..\..\common,..\..\vmpi" + PreprocessorDefinitions="_DEBUG;WIN32;_CONSOLE;PROTECTED_THINGS_DISABLE" + BasicRuntimeChecks="3" + RuntimeLibrary="1" + PrecompiledHeaderFile=".\Debug/pingpong.pch" + AssemblerListingLocation=".\Debug/" + ObjectFile=".\Debug/" + ProgramDataBaseFileName=".\Debug/" + WarningLevel="4" + SuppressStartupBanner="TRUE" + DebugInformationFormat="4" + CompileAs="0"/> + <Tool + Name="VCCustomBuildTool"/> + <Tool + Name="VCLinkerTool" + AdditionalDependencies="ws2_32.lib odbc32.lib odbccp32.lib" + OutputFile=".\Debug/pingpong.exe" + LinkIncremental="2" + SuppressStartupBanner="TRUE" + IgnoreDefaultLibraryNames="libcmt.lib" + GenerateDebugInformation="TRUE" + ProgramDatabaseFile=".\Debug/pingpong.pdb" + SubSystem="1" + TargetMachine="1"/> + <Tool + Name="VCMIDLTool" + TypeLibraryName=".\Debug/pingpong.tlb" + HeaderFileName=""/> + <Tool + Name="VCPostBuildEventTool"/> + <Tool + Name="VCPreBuildEventTool"/> + <Tool + Name="VCPreLinkEventTool"/> + <Tool + Name="VCResourceCompilerTool" + PreprocessorDefinitions="_DEBUG" + Culture="1033"/> + <Tool + Name="VCWebServiceProxyGeneratorTool"/> + <Tool + Name="VCXMLDataGeneratorTool"/> + <Tool + Name="VCWebDeploymentTool"/> + <Tool + Name="VCManagedWrapperGeneratorTool"/> + <Tool + Name="VCAuxiliaryManagedWrapperGeneratorTool"/> + </Configuration> + </Configurations> + <References> + </References> + <Files> + <Filter + Name="Source Files" + Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"> + <File + RelativePath="..\..\..\public\tier0\memoverride.cpp"> + </File> + <File + RelativePath="pingpong.cpp"> + </File> + <File + RelativePath="StdAfx.cpp"> + </File> + <File + RelativePath="..\tcpsocket.cpp"> + </File> + <File + RelativePath="..\tcpsocket_helpers.cpp"> + </File> + </Filter> + <Filter + Name="Header Files" + Filter="h;hpp;hxx;hm;inl"> + <File + RelativePath="..\..\..\public\tier1\bitbuf.h"> + </File> + <File + RelativePath="..\..\..\public\platform\fasttimer.h"> + </File> + <File + RelativePath="..\..\common\ichannel.h"> + </File> + <File + RelativePath="..\..\common\iphelpers.h"> + </File> + <File + RelativePath="..\..\common\loopback_channel.h"> + </File> + <File + RelativePath="StdAfx.h"> + </File> + <File + RelativePath="..\..\common\tcpsocket.h"> + </File> + <File + RelativePath="..\..\..\public\tier1\utlvector.h"> + </File> + <File + RelativePath="..\..\common\vmpi.h"> + </File> + </Filter> + <Filter + Name="Resource Files" + Filter="ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"> + </Filter> + <File + RelativePath="ReadMe.txt"> + </File> + <File + RelativePath="..\..\..\lib\public\tier0.lib"> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCustomBuildTool" + Description="" + CommandLine=""/> + </FileConfiguration> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCustomBuildTool" + Description="" + CommandLine=""/> + </FileConfiguration> + </File> + <File + RelativePath="..\..\..\lib\public\tier1.lib"> + </File> + <File + RelativePath="..\..\..\lib\public\vmpi.lib"> + </File> + <File + RelativePath="..\..\..\lib\public\vstdlib.lib"> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCustomBuildTool" + Description="" + CommandLine=""/> + </FileConfiguration> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCustomBuildTool" + Description="" + CommandLine=""/> + </FileConfiguration> + </File> + </Files> + <Globals> + </Globals> +</VisualStudioProject> diff --git a/utils/vmpi/testapps/socket_stresstest/StdAfx.cpp b/utils/vmpi/testapps/socket_stresstest/StdAfx.cpp new file mode 100644 index 0000000..2b565b0 --- /dev/null +++ b/utils/vmpi/testapps/socket_stresstest/StdAfx.cpp @@ -0,0 +1,15 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// stdafx.cpp : source file that includes just the standard includes +// socket_stresstest.pch will be the pre-compiled header +// stdafx.obj will contain the pre-compiled type information + +#include "stdafx.h" + +// TODO: reference any additional headers you need in STDAFX.H +// and not in this file diff --git a/utils/vmpi/testapps/socket_stresstest/StdAfx.h b/utils/vmpi/testapps/socket_stresstest/StdAfx.h new file mode 100644 index 0000000..3c554be --- /dev/null +++ b/utils/vmpi/testapps/socket_stresstest/StdAfx.h @@ -0,0 +1,33 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, but +// are changed infrequently +// + +#if !defined(AFX_STDAFX_H__7E382B26_1CB4_461A_8087_762358153941__INCLUDED_) +#define AFX_STDAFX_H__7E382B26_1CB4_461A_8087_762358153941__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers + +#include <windows.h> +#include <stdio.h> +#include "tcpsocket.h" +#include <conio.h> +#include <stdlib.h> + +// TODO: reference additional headers your program requires here + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_STDAFX_H__7E382B26_1CB4_461A_8087_762358153941__INCLUDED_) diff --git a/utils/vmpi/testapps/socket_stresstest/socket_stresstest.cpp b/utils/vmpi/testapps/socket_stresstest/socket_stresstest.cpp new file mode 100644 index 0000000..55ab97d --- /dev/null +++ b/utils/vmpi/testapps/socket_stresstest/socket_stresstest.cpp @@ -0,0 +1,274 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// socket_stresstest.cpp : Defines the entry point for the console application. +// + +#include "stdafx.h" +#include "utllinkedlist.h" + + +class CSocketInfo +{ +public: + + bool IsValid() + { + return m_pSocket != 0; + } + + void Term(); + + void ThreadFn(); + + + +public: + ITCPSocket *m_pSocket; + int m_iListenPort; + + DWORD m_CreateTime; // When this socket was created. + DWORD m_ExpireTime; +}; + + + +CSocketInfo g_Infos[132]; +CRITICAL_SECTION g_CS, g_PrintCS; +HANDLE g_hThreads[ ARRAYSIZE( g_Infos ) ]; +bool g_bShouldExit = false; +CUtlLinkedList<int,int> g_ListenPorts; + + +SpewRetval_t StressTestSpew( SpewType_t type, char const *pMsg ) +{ + EnterCriticalSection( &g_PrintCS ); + printf( "%s", pMsg ); + LeaveCriticalSection( &g_PrintCS ); + + if( type == SPEW_ASSERT ) + return SPEW_DEBUGGER; + else if( type == SPEW_ERROR ) + return SPEW_ABORT; + else + return SPEW_CONTINUE; +} + + +void CSocketInfo::Term() +{ + if ( m_pSocket ) + { + m_pSocket->Release(); + m_pSocket = 0; + } +} + + +CSocketInfo* FindOldestSocketInfo( CSocketInfo *pInfos, int nInfos ) +{ + int iOldest = 0; + DWORD oldestTime = 0xFFFFFFFF; + for ( int i=0; i < nInfos; i++ ) + { + if ( !pInfos[i].IsValid() ) + return &pInfos[i]; + + if ( pInfos[i].m_CreateTime < oldestTime ) + { + oldestTime = pInfos[i].m_CreateTime; + iOldest = i; + } + } + return &pInfos[iOldest]; +} + + +int g_iNextExpire = -1; + +void CSocketInfo::ThreadFn() +{ + int iInfo = this - g_Infos; + + while ( !g_bShouldExit ) + { + DWORD curTime = GetTickCount(); + + // Break the connection after a certain amount of time. + if ( m_pSocket && curTime >= m_ExpireTime ) + { + Term(); + Msg( "%02d: expire.\n", iInfo, m_iListenPort ); + } + + if ( m_pSocket ) + { + EnterCriticalSection( &g_CS ); + if ( g_iNextExpire == -1 ) + { + g_iNextExpire = iInfo; + LeaveCriticalSection( &g_CS ); + + Msg( "%02d: forcing an expire.\n", iInfo, m_iListenPort ); + Sleep( 16000 ); + + EnterCriticalSection( &g_CS ); + g_iNextExpire = -1; + } + LeaveCriticalSection( &g_CS ); + + if ( m_pSocket->IsConnected() ) + { + // Receive whatever data it has waiting for it. + CUtlVector<unsigned char> data; + while ( m_pSocket->Recv( data ) ) + { + Msg( "%02d: recv %d.\n", iInfo, data.Count() ); + } + + // Send some data. + int size = rand() % 8192; + data.SetSize( size ); + m_pSocket->Send( data.Base(), data.Count() ); + //Msg( "%02d: send %d.\n", iInfo, data.Count() ); + } + else + { + Term(); + } + } + else + { + // Not initialized.. either listen or connect. + int iConnectPort = -1; + if ( rand() > VALVE_RAND_MAX/2 ) + { + if ( rand() % 100 < 50 ) + Sleep( 500 ); + + EnterCriticalSection( &g_CS ); + int iHead = g_ListenPorts.Head(); + if ( iHead != g_ListenPorts.InvalidIndex() ) + iConnectPort = g_ListenPorts[iHead]; + LeaveCriticalSection( &g_CS ); + } + + if ( iConnectPort != -1 ) + { + CIPAddr addr( 127, 0, 0, 1, iConnectPort ); + + m_pSocket = CreateTCPSocket(); + m_pSocket->BindToAny( 0 ); + m_CreateTime = curTime; + m_ExpireTime = curTime + rand() % 5000; + if ( !TCPSocket_Connect( m_pSocket, &addr, 3.0f ) ) + { + Term(); + } + } + else + { + for ( int iTry=0; iTry < 32; iTry++ ) + { + m_iListenPort = 100 + rand() % (VALVE_RAND_MAX/2); + ITCPListenSocket *pListenSocket = CreateTCPListenSocket( m_iListenPort ); + if ( pListenSocket ) + { + Msg( "%02d: listen on %d.\n", iInfo, m_iListenPort ); + + // Add us to the list of ports to connect to. + EnterCriticalSection( &g_CS ); + g_ListenPorts.AddToTail( m_iListenPort ); + LeaveCriticalSection( &g_CS ); + + // Listen for a connection. + CIPAddr connectedAddr; + m_pSocket = TCPSocket_ListenForOneConnection( pListenSocket, &connectedAddr, 4.0 ); + + // Remove us from the list of ports to connect to. + EnterCriticalSection( &g_CS ); + g_ListenPorts.Remove( g_ListenPorts.Find( m_iListenPort ) ); + LeaveCriticalSection( &g_CS ); + + pListenSocket->Release(); + + if ( m_pSocket ) + { + Msg( "%02d: listen found connection.\n", iInfo ); + m_CreateTime = curTime; + m_ExpireTime = curTime + rand() % 5000; + } + break; + } + } + } + } + + Sleep( 1 ); + } + + g_hThreads[iInfo] = 0; +} + + +DWORD WINAPI ThreadFn( LPVOID lpParameter ) +{ + CSocketInfo *pInfo = (CSocketInfo*)lpParameter; + pInfo->ThreadFn(); + return 0; +} + + +void AllocError( unsigned long size ) +{ + Assert( false ); +} + + +int main(int argc, char* argv[]) +{ + memset( g_Infos, 0, sizeof( g_Infos ) ); + memset( g_hThreads, 0, sizeof( g_hThreads ) ); + + InitializeCriticalSection( &g_CS ); + InitializeCriticalSection( &g_PrintCS ); + + SpewOutputFunc( StressTestSpew ); + Plat_SetAllocErrorFn( AllocError ); + + SetPriorityClass( GetCurrentProcess(), IDLE_PRIORITY_CLASS ); + + for ( int i=0; i < ARRAYSIZE( g_Infos ); i++ ) + { + DWORD dwThreadID = 0; + g_hThreads[i] = CreateThread( + NULL, + 0, + ThreadFn, + &g_Infos[i], + 0, + &dwThreadID ); + } + + + while ( !kbhit() ) + { + } + + g_bShouldExit = true; + + HANDLE hZeroArray[ ARRAYSIZE( g_Infos ) ]; + memset( hZeroArray, 0, sizeof( hZeroArray ) ); + + while ( memcmp( hZeroArray, g_hThreads, sizeof( hZeroArray ) ) != 0 ) + { + Sleep( 10 ); + } + + return 0; +} + diff --git a/utils/vmpi/testapps/socket_stresstest/socket_stresstest.vcproj b/utils/vmpi/testapps/socket_stresstest/socket_stresstest.vcproj new file mode 100644 index 0000000..89b144e --- /dev/null +++ b/utils/vmpi/testapps/socket_stresstest/socket_stresstest.vcproj @@ -0,0 +1,210 @@ +<?xml version="1.0" encoding="Windows-1252"?> +<VisualStudioProject + ProjectType="Visual C++" + Version="7.10" + Name="socket_stresstest" + ProjectGUID="{46DE8944-1A71-4A43-98FE-7A96CB8E5596}" + SccProjectName="" + SccAuxPath="" + SccLocalPath="" + SccProvider=""> + <Platforms> + <Platform + Name="Win32"/> + </Platforms> + <Configurations> + <Configuration + Name="Debug|Win32" + OutputDirectory=".\Debug" + IntermediateDirectory=".\Debug" + ConfigurationType="1" + UseOfMFC="0" + ATLMinimizesCRunTimeLibraryUsage="FALSE" + CharacterSet="2"> + <Tool + Name="VCCLCompilerTool" + Optimization="0" + AdditionalIncludeDirectories="..,..\..\common,..\..\..\public,..\..\..\public\tier1" + PreprocessorDefinitions="_DEBUG;WIN32;_CONSOLE;PROTECTED_THINGS_DISABLE" + BasicRuntimeChecks="3" + RuntimeLibrary="1" + PrecompiledHeaderFile=".\Debug/socket_stresstest.pch" + AssemblerListingLocation=".\Debug/" + ObjectFile=".\Debug/" + ProgramDataBaseFileName=".\Debug/" + WarningLevel="3" + SuppressStartupBanner="TRUE" + DebugInformationFormat="4" + CompileAs="0"/> + <Tool + Name="VCCustomBuildTool"/> + <Tool + Name="VCLinkerTool" + AdditionalDependencies="ws2_32.lib odbc32.lib odbccp32.lib" + OutputFile=".\Debug/socket_stresstest.exe" + LinkIncremental="1" + SuppressStartupBanner="TRUE" + GenerateDebugInformation="TRUE" + ProgramDatabaseFile=".\Debug/socket_stresstest.pdb" + SubSystem="1" + TargetMachine="1"/> + <Tool + Name="VCMIDLTool" + TypeLibraryName=".\Debug/socket_stresstest.tlb" + HeaderFileName=""/> + <Tool + Name="VCPostBuildEventTool"/> + <Tool + Name="VCPreBuildEventTool"/> + <Tool + Name="VCPreLinkEventTool"/> + <Tool + Name="VCResourceCompilerTool" + PreprocessorDefinitions="_DEBUG" + Culture="1033"/> + <Tool + Name="VCWebServiceProxyGeneratorTool"/> + <Tool + Name="VCXMLDataGeneratorTool"/> + <Tool + Name="VCWebDeploymentTool"/> + <Tool + Name="VCManagedWrapperGeneratorTool"/> + <Tool + Name="VCAuxiliaryManagedWrapperGeneratorTool"/> + </Configuration> + <Configuration + Name="Release|Win32" + OutputDirectory=".\Release" + IntermediateDirectory=".\Release" + ConfigurationType="1" + UseOfMFC="0" + ATLMinimizesCRunTimeLibraryUsage="FALSE" + CharacterSet="2"> + <Tool + Name="VCCLCompilerTool" + Optimization="2" + InlineFunctionExpansion="1" + AdditionalIncludeDirectories="..,..\..\common,..\..\..\public,..\..\..\public\tier1" + PreprocessorDefinitions="NDEBUG;WIN32;_CONSOLE;PROTECTED_THINGS_DISABLE" + StringPooling="TRUE" + RuntimeLibrary="0" + EnableFunctionLevelLinking="TRUE" + PrecompiledHeaderFile=".\Release/socket_stresstest.pch" + AssemblerListingLocation=".\Release/" + ObjectFile=".\Release/" + ProgramDataBaseFileName=".\Release/" + WarningLevel="3" + SuppressStartupBanner="TRUE" + CompileAs="0"/> + <Tool + Name="VCCustomBuildTool"/> + <Tool + Name="VCLinkerTool" + AdditionalDependencies="ws2_32.lib odbc32.lib odbccp32.lib" + OutputFile=".\Release/socket_stresstest.exe" + LinkIncremental="1" + SuppressStartupBanner="TRUE" + ProgramDatabaseFile=".\Release/socket_stresstest.pdb" + SubSystem="1" + TargetMachine="1"/> + <Tool + Name="VCMIDLTool" + TypeLibraryName=".\Release/socket_stresstest.tlb" + HeaderFileName=""/> + <Tool + Name="VCPostBuildEventTool"/> + <Tool + Name="VCPreBuildEventTool"/> + <Tool + Name="VCPreLinkEventTool"/> + <Tool + Name="VCResourceCompilerTool" + PreprocessorDefinitions="NDEBUG" + Culture="1033"/> + <Tool + Name="VCWebServiceProxyGeneratorTool"/> + <Tool + Name="VCXMLDataGeneratorTool"/> + <Tool + Name="VCWebDeploymentTool"/> + <Tool + Name="VCManagedWrapperGeneratorTool"/> + <Tool + Name="VCAuxiliaryManagedWrapperGeneratorTool"/> + </Configuration> + </Configurations> + <References> + </References> + <Files> + <Filter + Name="Source Files" + Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"> + <File + RelativePath="..\iphelpers.cpp"> + </File> + <File + RelativePath="socket_stresstest.cpp"> + </File> + <File + RelativePath="StdAfx.cpp"> + </File> + <File + RelativePath="..\tcpsocket.cpp"> + </File> + <File + RelativePath="..\threadhelpers.cpp"> + </File> + </Filter> + <Filter + Name="Header Files" + Filter="h;hpp;hxx;hm;inl"> + <File + RelativePath="StdAfx.h"> + </File> + </Filter> + <Filter + Name="Resource Files" + Filter="ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"> + </Filter> + <File + RelativePath="ReadMe.txt"> + </File> + <File + RelativePath="..\..\..\lib\public\tier0.lib"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCustomBuildTool" + Description="" + CommandLine=""/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCustomBuildTool" + Description="" + CommandLine=""/> + </FileConfiguration> + </File> + <File + RelativePath="..\..\..\lib\public\vstdlib.lib"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCustomBuildTool" + Description="" + CommandLine=""/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCustomBuildTool" + Description="" + CommandLine=""/> + </FileConfiguration> + </File> + </Files> + <Globals> + </Globals> +</VisualStudioProject> diff --git a/utils/vmpi/testapps/vmpi_launch/StdAfx.cpp b/utils/vmpi/testapps/vmpi_launch/StdAfx.cpp new file mode 100644 index 0000000..7d621ea --- /dev/null +++ b/utils/vmpi/testapps/vmpi_launch/StdAfx.cpp @@ -0,0 +1,15 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// stdafx.cpp : source file that includes just the standard includes +// vmpi_launch.pch will be the pre-compiled header +// stdafx.obj will contain the pre-compiled type information + +#include "stdafx.h" + +// TODO: reference any additional headers you need in STDAFX.H +// and not in this file diff --git a/utils/vmpi/testapps/vmpi_launch/StdAfx.h b/utils/vmpi/testapps/vmpi_launch/StdAfx.h new file mode 100644 index 0000000..a673b65 --- /dev/null +++ b/utils/vmpi/testapps/vmpi_launch/StdAfx.h @@ -0,0 +1,30 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, but +// are changed infrequently +// + +#if !defined(AFX_STDAFX_H__00616BF6_B7E2_4D94_8DC8_3F85BEBD1834__INCLUDED_) +#define AFX_STDAFX_H__00616BF6_B7E2_4D94_8DC8_3F85BEBD1834__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers + +#include <stdio.h> +#include <windows.h> + +// TODO: reference additional headers your program requires here + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_STDAFX_H__00616BF6_B7E2_4D94_8DC8_3F85BEBD1834__INCLUDED_) diff --git a/utils/vmpi/testapps/vmpi_launch/vmpi_launch.cpp b/utils/vmpi/testapps/vmpi_launch/vmpi_launch.cpp new file mode 100644 index 0000000..7ecb47b --- /dev/null +++ b/utils/vmpi/testapps/vmpi_launch/vmpi_launch.cpp @@ -0,0 +1,256 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// vmpi_launch.cpp : Defines the entry point for the console application. +// + +#include "stdafx.h" +#include "iphelpers.h" +#include "bitbuf.h" +#include "vmpi.h" + +bool g_bBroadcast = false; + +int PrintUsage() +{ + printf( "vmpi_launch -machine <remote machine> -priority <priority> [-mpi_pw <password>] -command \"command line...\"\n" ); + printf( "-command must be the last switch..\n" ); + return 1; +} + + +int GetCurMicrosecondsAndSleep( int sleepLen ) +{ + Sleep( sleepLen ); + + int retVal; + __asm + { + rdtsc + mov retVal, eax + } + return retVal; +} + + +const char* FindArg( int argc, char **argv, const char *pName, const char *pDefault ) +{ + for ( int i=0; i < argc; i++ ) + { + if ( stricmp( argv[i], pName ) == 0 ) + { + if ( (i+1) < argc ) + return argv[i+1]; + else + return pDefault; + } + } + return NULL; +} + + +int ParseArgs( int argc, char **argv, CIPAddr &remoteIP, int &iPriority, int &iFirstArg ) +{ + if ( FindArg( argc, argv, "-broadcast", "1" ) ) + g_bBroadcast = true; + + if ( g_bBroadcast == false ) + { + const char *pRemoteIPStr = FindArg( argc, argv, "-machine", NULL ); + if ( !pRemoteIPStr || !ConvertStringToIPAddr( pRemoteIPStr, &remoteIP ) ) + { + printf( "%s is not a valid machine name or IP address.\n", pRemoteIPStr ); + return PrintUsage(); + } + } + + iPriority = 0; + const char *pPriorityStr = FindArg( argc, argv, "-priority", NULL ); + if ( pPriorityStr ) + iPriority = atoi( pPriorityStr ); + + if ( iPriority < 0 || iPriority > 1000 ) + { + printf( "%s is not a valid priority.\n", pPriorityStr ); + return PrintUsage(); + } + + const char *pCommand = FindArg( argc, argv, "-command", NULL ); + if ( !pCommand ) + { + return PrintUsage(); + } + for ( iFirstArg=1; iFirstArg < argc; iFirstArg++ ) + { + if ( argv[iFirstArg] == pCommand ) + break; + } + + return 0; +} + + +void SendJobRequest( + ISocket *pSocket, + int argc, + char **argv, + CIPAddr &remoteIP, + int &iPriority, + int &iFirstArg, + int jobID[4] ) +{ + // Build the packet to send out the job. + char packetData[4096]; + bf_write packetBuf; + + // Come up with a unique job ID. + jobID[0] = GetCurMicrosecondsAndSleep( 1 ); + jobID[1] = GetCurMicrosecondsAndSleep( 1 ); + jobID[2] = GetCurMicrosecondsAndSleep( 1 ); + jobID[3] = GetCurMicrosecondsAndSleep( 1 ); + + + // Broadcast out to tell all the machines we want workers. + packetBuf.StartWriting( packetData, sizeof( packetData ) ); + packetBuf.WriteByte( VMPI_PROTOCOL_VERSION ); + + const char *pPassword = FindArg( argc, argv, "-mpi_pw", "" ); + packetBuf.WriteString( pPassword ); + + packetBuf.WriteByte( VMPI_LOOKING_FOR_WORKERS ); + + packetBuf.WriteShort( 0 ); // Tell the port that we're listening on. + // In this case, there is no VMPI master waiting for the app to connect, so + // this parameter doesn't matter. + packetBuf.WriteShort( iPriority ); + + packetBuf.WriteLong( jobID[0] ); + packetBuf.WriteLong( jobID[1] ); + packetBuf.WriteLong( jobID[2] ); + packetBuf.WriteLong( jobID[3] ); + packetBuf.WriteWord( argc-iFirstArg ); // 1 command line argument.. + + // Write the alternate exe name. + for ( int iArg=iFirstArg; iArg < argc; iArg++ ) + packetBuf.WriteString( argv[iArg] ); + + for ( int iBroadcastPort=VMPI_SERVICE_PORT; iBroadcastPort <= VMPI_LAST_SERVICE_PORT; iBroadcastPort++ ) + { + remoteIP.port = iBroadcastPort; + + if ( g_bBroadcast == false ) + pSocket->SendTo( &remoteIP, packetBuf.GetBasePointer(), packetBuf.GetNumBytesWritten() ); + else + pSocket->Broadcast( packetBuf.GetBasePointer(), packetBuf.GetNumBytesWritten(), iBroadcastPort ); + } + + if ( g_bBroadcast == false ) + printf( "Sent command, waiting for reply...\n" ); + else + printf( "Sent command\n" ); +} + + +bool WaitForJobStart( ISocket *pSocket, const CIPAddr &remoteIP, const int jobID[4] ) +{ + while ( 1 ) + { + CIPAddr senderAddr; + char data[4096]; + int len = -1; + + if ( g_bBroadcast == false ) + pSocket->RecvFrom( data, sizeof( data ), &senderAddr ); + else + pSocket->RecvFrom( data, sizeof( data ), NULL ); + + if ( len == 19 && + memcmp( senderAddr.ip, remoteIP.ip, sizeof( senderAddr.ip ) ) == 0 && + data[1] == VMPI_NOTIFY_START_STATUS && + memcmp( &data[2], jobID, 16 ) == 0 ) + { + if ( data[18] == 0 ) + { + // Wasn't able to run. + printf( "Wasn't able to run on target machine.\n" ); + return false; + } + else + { + // Ok, the process is running now. + printf( "Process running, waiting for completion...\n" ); + return true; + } + } + + Sleep( 100 ); + } +} + + +void WaitForJobEnd( ISocket *pSocket, const CIPAddr &remoteIP, const int jobID[4] ) +{ + while ( 1 ) + { + CIPAddr senderAddr; + char data[4096]; + int len = pSocket->RecvFrom( data, sizeof( data ), &senderAddr ); + if ( len == 18 && + memcmp( senderAddr.ip, remoteIP.ip, sizeof( senderAddr.ip ) ) == 0 && + data[1] == VMPI_NOTIFY_END_STATUS && + memcmp( &data[2], jobID, 16 ) == 0 ) + { + int ret = *((int*)&data[2]); + printf( "Finished [%d].\n", ret ); + break; + } + + Sleep( 100 ); + } +} + + +int main(int argc, char* argv[]) +{ + if ( argc < 4 ) + { + return PrintUsage(); + } + + + // Parse the command line. + CIPAddr remoteIP; + int iFirstArg, iPriority; + int jobID[4]; + + int ret = ParseArgs( argc, argv, remoteIP, iPriority, iFirstArg ); + if ( ret != 0 ) + return ret; + + // Now send the command to the vmpi service on that machine. + ISocket *pSocket = CreateIPSocket(); + if ( !pSocket->BindToAny( 0 ) ) + { + printf( "Error binding a socket.\n" ); + return 1; + } + + SendJobRequest( pSocket, argc, argv, remoteIP, iPriority, iFirstArg, jobID ); + + // Wait for a reply, positive or negative. + if ( g_bBroadcast == false ) + { + if ( !WaitForJobStart( pSocket, remoteIP, jobID ) ) + return 2; + + WaitForJobEnd( pSocket, remoteIP, jobID ); + } + + pSocket->Release(); + return 0; +} + diff --git a/utils/vmpi/testapps/vmpi_launch/vmpi_launch.vpc b/utils/vmpi/testapps/vmpi_launch/vmpi_launch.vpc new file mode 100644 index 0000000..99b642a --- /dev/null +++ b/utils/vmpi/testapps/vmpi_launch/vmpi_launch.vpc @@ -0,0 +1,38 @@ +//----------------------------------------------------------------------------- +// VMPI_LAUNCH.VPC +// +// Project Script +//----------------------------------------------------------------------------- + +$Macro SRCDIR "..\..\..\.." +$Macro OUTBINDIR "$SRCDIR\..\game\bin" + +$Include "$SRCDIR\vpc_scripts\source_exe_con_win32_base.vpc" + +$Configuration +{ + $Compiler + { + $AdditionalIncludeDirectories "$BASE,.\,..\.." + } + + $Linker + { + $AdditionalDependencies "ws2_32.lib odbc32.lib odbccp32.lib" + } +} + +$Project "Vmpi_launch" +{ + $Folder "Source Files" + { + $File "..\..\iphelpers.cpp" + $File "StdAfx.cpp" + $File "vmpi_launch.cpp" + } + + $Folder "Header Files" + { + $File "StdAfx.h" + } +} diff --git a/utils/vmpi/testapps/vmpi_ping/StdAfx.cpp b/utils/vmpi/testapps/vmpi_ping/StdAfx.cpp new file mode 100644 index 0000000..94441ca --- /dev/null +++ b/utils/vmpi/testapps/vmpi_ping/StdAfx.cpp @@ -0,0 +1,15 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// stdafx.cpp : source file that includes just the standard includes +// vmpi_ping.pch will be the pre-compiled header +// stdafx.obj will contain the pre-compiled type information + +#include "stdafx.h" + +// TODO: reference any additional headers you need in STDAFX.H +// and not in this file diff --git a/utils/vmpi/testapps/vmpi_ping/StdAfx.h b/utils/vmpi/testapps/vmpi_ping/StdAfx.h new file mode 100644 index 0000000..1339f3d --- /dev/null +++ b/utils/vmpi/testapps/vmpi_ping/StdAfx.h @@ -0,0 +1,30 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, but +// are changed infrequently +// + +#if !defined(AFX_STDAFX_H__04B9E767_FE9B_4F2A_84A3_D6B85737214E__INCLUDED_) +#define AFX_STDAFX_H__04B9E767_FE9B_4F2A_84A3_D6B85737214E__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers + +#include <windows.h> +#include <stdio.h> + +// TODO: reference additional headers your program requires here + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_STDAFX_H__04B9E767_FE9B_4F2A_84A3_D6B85737214E__INCLUDED_) diff --git a/utils/vmpi/testapps/vmpi_ping/vmpi_ping.cpp b/utils/vmpi/testapps/vmpi_ping/vmpi_ping.cpp new file mode 100644 index 0000000..17ddd8e --- /dev/null +++ b/utils/vmpi/testapps/vmpi_ping/vmpi_ping.cpp @@ -0,0 +1,196 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// vmpi_ping.cpp : Defines the entry point for the console application. +// + +#include "stdafx.h" +#include "iphelpers.h" +#include "vmpi.h" +#include "tier0/platform.h" +#include "bitbuf.h" +#include <conio.h> +#include <stdlib.h> + + +const char* FindArg( int argc, char **argv, const char *pName, const char *pDefault = "" ) +{ + for ( int i=0; i < argc; i++ ) + { + if ( stricmp( argv[i], pName ) == 0 ) + { + if ( (i+1) < argc ) + return argv[i+1]; + else + return pDefault; + } + } + return NULL; +} + + +int main(int argc, char* argv[]) +{ + CUtlVector<CIPAddr> addrs; + + printf( "\n" ); + printf( "vmpi_ping <option>\n" ); + printf( "option can be:\n" ); + printf( " -stop .. stop any VMPI services\n" ); + printf( " -kill .. kill any processes being run by VMPI\n" ); + printf( " -patch <timeout> .. stops VMPI services for <timeout> seconds\n" ); + printf( " -mpi_pw <password> .. only talk to services with the specified password\n" ); + printf( " -dns .. enable DNS lookups (slows the listing down)\n" ); + printf( " -ShowConsole .. show the console window\n" ); + printf( " -HideConsole .. hide the console window\n" ); + + //Scary to show these to users... + //printf( " -ShowCache .. show the cache directory and its capacity\n" ); + //printf( " -FlushCache .. flush the cache of ALL VMPI services\n" ); + + printf( "\n" ); + + + ISocket *pSocket = CreateIPSocket(); + if ( !pSocket->BindToAny( 0 ) ) + { + printf( "Error binding to a port!\n" ); + return 1; + } + + const char *pPassword = FindArg( argc, argv, "-mpi_pw" ); + + + // Figure out which action they want to take. + int timeout = 0; + char cRequest = VMPI_PING_REQUEST; + if ( FindArg( argc, argv, "-Stop" ) ) + { + cRequest = VMPI_STOP_SERVICE; + } + else if ( FindArg( argc, argv, "-Kill" ) ) + { + cRequest = VMPI_KILL_PROCESS; + } +/* + else if ( FindArg( argc, argv, "-ShowConsole" ) ) + { + cRequest = VMPI_SHOW_CONSOLE_WINDOW; + } + else if ( FindArg( argc, argv, "-HideConsole" ) ) + { + cRequest = VMPI_HIDE_CONSOLE_WINDOW; + } +*/ + else if ( FindArg( argc, argv, "-ShowCache" ) ) + { + cRequest = VMPI_GET_CACHE_INFO; + } + else if ( FindArg( argc, argv, "-FlushCache" ) ) + { + cRequest = VMPI_FLUSH_CACHE; + } + else + { + const char *pTimeout = FindArg( argc, argv, "-patch", "60" ); + if ( pTimeout ) + { + if ( isdigit( pTimeout[0] ) ) + { + cRequest = VMPI_SERVICE_PATCH; + timeout = atoi( pTimeout ); + printf( "Patching with timeout of %d seconds.\n", timeout ); + } + else + { + printf( "-patch requires a timeout parameter.\n" ); + return 1; + } + } + } + + + int nMachines = 0; + printf( "Pinging VMPI Services... press a key to stop.\n\n" ); + while ( !kbhit() ) + { + for ( int i=VMPI_SERVICE_PORT; i <= VMPI_LAST_SERVICE_PORT; i++ ) + { + unsigned char data[256]; + bf_write buf( data, sizeof( data ) ); + buf.WriteByte( VMPI_PROTOCOL_VERSION ); + buf.WriteString( pPassword ); + buf.WriteByte( cRequest ); + + if ( cRequest == VMPI_SERVICE_PATCH ) + buf.WriteLong( timeout ); + + pSocket->Broadcast( data, buf.GetNumBytesWritten(), i ); + } + + while ( 1 ) + { + CIPAddr ipFrom; + char in[256]; + int len = pSocket->RecvFrom( in, sizeof( in ), &ipFrom ); + if ( len == -1 ) + break; + + if ( len >= 2 && + in[0] == VMPI_PROTOCOL_VERSION && + in[1] == VMPI_PING_RESPONSE && + addrs.Find( ipFrom ) == -1 ) + { + char *pStateString = "(unknown)"; + if ( len >= 3 ) + { + if ( in[2] ) + pStateString = "(running)"; + else + pStateString = "(idle) "; + } + + ++nMachines; + char nameStr[256]; + + if ( FindArg( argc, argv, "-dns" ) && ConvertIPAddrToString( &ipFrom, nameStr, sizeof( nameStr ) ) ) + { + printf( "%02d. %s - %s:%d (%d.%d.%d.%d)", + nMachines, pStateString, nameStr, ipFrom.port, + ipFrom.ip[0], ipFrom.ip[1], ipFrom.ip[2], ipFrom.ip[3] ); + } + else + { + printf( "%02d. %s - %d.%d.%d.%d:%d", + nMachines, pStateString, ipFrom.ip[0], ipFrom.ip[1], ipFrom.ip[2], ipFrom.ip[3], ipFrom.port ); + } + + if ( cRequest == VMPI_GET_CACHE_INFO ) + { + // Next var is a 64-bit int with the size of the cache. + char *pCur = &in[3]; + __int64 cacheSize = *((__int64*)pCur); + pCur += sizeof( __int64 ); + + char *pCacheDir = pCur; + + __int64 nMegs = cacheSize / (1024*1024); + printf( "\n\tCache dir: %s, size: %d megs", pCur, nMegs ); + } + + printf( "\n" ); + + addrs.AddToTail( ipFrom ); + } + } + + Sleep( 1000 ); + } + + return 0; +} + diff --git a/utils/vmpi/testapps/vmpi_ping/vmpi_ping.vcproj b/utils/vmpi/testapps/vmpi_ping/vmpi_ping.vcproj new file mode 100644 index 0000000..a2a6dc7 --- /dev/null +++ b/utils/vmpi/testapps/vmpi_ping/vmpi_ping.vcproj @@ -0,0 +1,249 @@ +<?xml version="1.0" encoding="Windows-1252"?> +<VisualStudioProject + ProjectType="Visual C++" + Version="7.10" + Name="vmpi_ping" + ProjectGUID="{D6F83A58-89A2-4F57-9761-32208BD95E83}" + SccProjectName="" + SccAuxPath="" + SccLocalPath="" + SccProvider=""> + <Platforms> + <Platform + Name="Win32"/> + </Platforms> + <Configurations> + <Configuration + Name="Debug|Win32" + OutputDirectory=".\Debug" + IntermediateDirectory=".\Debug" + ConfigurationType="1" + UseOfMFC="0" + ATLMinimizesCRunTimeLibraryUsage="FALSE" + CharacterSet="2"> + <Tool + Name="VCCLCompilerTool" + Optimization="0" + AdditionalIncludeDirectories="..\..\common,..\..\..\common,..\..\..\public,..\..\..\public\tier1,.." + PreprocessorDefinitions="_DEBUG;WIN32;_CONSOLE;PROTECTED_THINGS_DISABLE" + BasicRuntimeChecks="3" + RuntimeLibrary="5" + UsePrecompiledHeader="3" + PrecompiledHeaderThrough="stdafx.h" + PrecompiledHeaderFile=".\Debug/vmpi_ping.pch" + AssemblerListingLocation=".\Debug/" + ObjectFile=".\Debug/" + ProgramDataBaseFileName=".\Debug/" + WarningLevel="3" + SuppressStartupBanner="TRUE" + DebugInformationFormat="4" + CompileAs="0"/> + <Tool + Name="VCCustomBuildTool" + CommandLine="if exist ..\..\..\..\game\bin\vmpi_ping.exe attrib -r ..\..\..\..\game\bin\vmpi_ping.exe +copy "$(TargetPath)" ..\..\..\..\game\bin +" + Outputs="..\..\..\..\game\bin\vmpi_ping.exe"/> + <Tool + Name="VCLinkerTool" + AdditionalDependencies="ws2_32.lib odbc32.lib odbccp32.lib" + OutputFile=".\Debug/vmpi_ping.exe" + LinkIncremental="1" + SuppressStartupBanner="TRUE" + GenerateDebugInformation="TRUE" + ProgramDatabaseFile=".\Debug/vmpi_ping.pdb" + SubSystem="1" + TargetMachine="1"/> + <Tool + Name="VCMIDLTool" + TypeLibraryName=".\Debug/vmpi_ping.tlb" + HeaderFileName=""/> + <Tool + Name="VCPostBuildEventTool"/> + <Tool + Name="VCPreBuildEventTool"/> + <Tool + Name="VCPreLinkEventTool"/> + <Tool + Name="VCResourceCompilerTool" + PreprocessorDefinitions="_DEBUG" + Culture="1033"/> + <Tool + Name="VCWebServiceProxyGeneratorTool"/> + <Tool + Name="VCXMLDataGeneratorTool"/> + <Tool + Name="VCWebDeploymentTool"/> + <Tool + Name="VCManagedWrapperGeneratorTool"/> + <Tool + Name="VCAuxiliaryManagedWrapperGeneratorTool"/> + </Configuration> + <Configuration + Name="Release|Win32" + OutputDirectory=".\Release" + IntermediateDirectory=".\Release" + ConfigurationType="1" + UseOfMFC="0" + ATLMinimizesCRunTimeLibraryUsage="FALSE" + CharacterSet="2"> + <Tool + Name="VCCLCompilerTool" + Optimization="2" + InlineFunctionExpansion="1" + AdditionalIncludeDirectories="..\..\common,..\..\..\common,..\..\..\public,..\..\..\public\tier1,.." + PreprocessorDefinitions="NDEBUG;WIN32;_CONSOLE;PROTECTED_THINGS_DISABLE" + StringPooling="TRUE" + RuntimeLibrary="4" + EnableFunctionLevelLinking="TRUE" + UsePrecompiledHeader="3" + PrecompiledHeaderThrough="stdafx.h" + PrecompiledHeaderFile=".\Release/vmpi_ping.pch" + AssemblerListingLocation=".\Release/" + ObjectFile=".\Release/" + ProgramDataBaseFileName=".\Release/" + WarningLevel="3" + SuppressStartupBanner="TRUE" + CompileAs="0"/> + <Tool + Name="VCCustomBuildTool" + CommandLine="if exist ..\..\..\..\game\bin\vmpi_ping.exe attrib -r ..\..\..\..\game\bin\vmpi_ping.exe +copy "$(TargetPath)" ..\..\..\..\game\bin +" + Outputs="..\..\..\..\game\bin\vmpi_ping.exe"/> + <Tool + Name="VCLinkerTool" + AdditionalDependencies="ws2_32.lib odbc32.lib odbccp32.lib" + OutputFile=".\Release/vmpi_ping.exe" + LinkIncremental="1" + SuppressStartupBanner="TRUE" + ProgramDatabaseFile=".\Release/vmpi_ping.pdb" + SubSystem="1" + TargetMachine="1"/> + <Tool + Name="VCMIDLTool" + TypeLibraryName=".\Release/vmpi_ping.tlb" + HeaderFileName=""/> + <Tool + Name="VCPostBuildEventTool"/> + <Tool + Name="VCPreBuildEventTool"/> + <Tool + Name="VCPreLinkEventTool"/> + <Tool + Name="VCResourceCompilerTool" + PreprocessorDefinitions="NDEBUG" + Culture="1033"/> + <Tool + Name="VCWebServiceProxyGeneratorTool"/> + <Tool + Name="VCXMLDataGeneratorTool"/> + <Tool + Name="VCWebDeploymentTool"/> + <Tool + Name="VCManagedWrapperGeneratorTool"/> + <Tool + Name="VCAuxiliaryManagedWrapperGeneratorTool"/> + </Configuration> + </Configurations> + <References> + </References> + <Files> + <Filter + Name="Source Files" + Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"> + <File + RelativePath="..\iphelpers.cpp"> + </File> + <File + RelativePath="..\..\..\public\tier0\memoverride.cpp"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + </File> + <File + RelativePath="StdAfx.cpp"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="1"/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="1"/> + </FileConfiguration> + </File> + <File + RelativePath="vmpi_ping.cpp"> + </File> + </Filter> + <Filter + Name="Header Files" + Filter="h;hpp;hxx;hm;inl"> + <File + RelativePath="..\..\common\iphelpers.h"> + </File> + <File + RelativePath="StdAfx.h"> + </File> + </Filter> + <Filter + Name="Resource Files" + Filter="ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"> + </Filter> + <File + RelativePath="ReadMe.txt"> + </File> + <File + RelativePath="..\..\..\lib\public\tier0.lib"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCustomBuildTool" + Description="" + CommandLine=""/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCustomBuildTool" + Description="" + CommandLine=""/> + </FileConfiguration> + </File> + <File + RelativePath="..\..\..\lib\public\tier1.lib"> + </File> + <File + RelativePath="..\..\..\lib\public\vstdlib.lib"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCustomBuildTool" + Description="" + CommandLine=""/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCustomBuildTool" + Description="" + CommandLine=""/> + </FileConfiguration> + </File> + </Files> + <Globals> + </Globals> +</VisualStudioProject> diff --git a/utils/vmpi/threadhelpers.cpp b/utils/vmpi/threadhelpers.cpp new file mode 100644 index 0000000..1205eb8 --- /dev/null +++ b/utils/vmpi/threadhelpers.cpp @@ -0,0 +1,155 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#include <windows.h> +#include "threadhelpers.h" +#include "tier0/dbg.h" + + +// -------------------------------------------------------------------------------- // +// CCriticalSection implementation. +// -------------------------------------------------------------------------------- // + +CCriticalSection::CCriticalSection() +{ + Assert( sizeof( CRITICAL_SECTION ) == SIZEOF_CS ); + +#if defined( _DEBUG ) + InitializeCriticalSection( (CRITICAL_SECTION*)&m_DeadlockProtect ); +#endif + + InitializeCriticalSection( (CRITICAL_SECTION*)&m_CS ); +} + + +CCriticalSection::~CCriticalSection() +{ + DeleteCriticalSection( (CRITICAL_SECTION*)&m_CS ); + +#if defined( _DEBUG ) + DeleteCriticalSection( (CRITICAL_SECTION*)&m_DeadlockProtect ); +#endif +} + + + +void CCriticalSection::Lock() +{ +#if defined( _DEBUG ) + // Check if this one is already locked. + DWORD id = GetCurrentThreadId(); + EnterCriticalSection( (CRITICAL_SECTION*)&m_DeadlockProtect ); + Assert( m_Locks.Find( id ) == m_Locks.InvalidIndex() ); + m_Locks.AddToTail( id ); + LeaveCriticalSection( (CRITICAL_SECTION*)&m_DeadlockProtect ); +#endif + + EnterCriticalSection( (CRITICAL_SECTION*)&m_CS ); +} + + +void CCriticalSection::Unlock() +{ +#if defined( _DEBUG ) + // Check if this one is already locked. + DWORD id = GetCurrentThreadId(); + EnterCriticalSection( (CRITICAL_SECTION*)&m_DeadlockProtect ); + int index = m_Locks.Find( id ); + Assert( index != m_Locks.InvalidIndex() ); + m_Locks.Remove( index ); + LeaveCriticalSection( (CRITICAL_SECTION*)&m_DeadlockProtect ); +#endif + + LeaveCriticalSection( (CRITICAL_SECTION*)&m_CS ); +} + + + +// -------------------------------------------------------------------------------- // +// CCriticalSectionLock implementation. +// -------------------------------------------------------------------------------- // + +CCriticalSectionLock::CCriticalSectionLock( CCriticalSection *pCS ) +{ + m_pCS = pCS; + m_bLocked = false; +} + + +CCriticalSectionLock::~CCriticalSectionLock() +{ + if ( m_bLocked ) + m_pCS->Unlock(); +} + + +void CCriticalSectionLock::Lock() +{ + Assert( !m_bLocked ); + m_bLocked = true; + m_pCS->Lock(); +} + + +void CCriticalSectionLock::Unlock() +{ + Assert( m_bLocked ); + m_bLocked = false; + m_pCS->Unlock(); +} + + +// -------------------------------------------------------------------------------- // +// CEvent implementation. +// -------------------------------------------------------------------------------- // + +CEvent::CEvent() +{ + m_hEvent = NULL; +} + +CEvent::~CEvent() +{ + Term(); +} + +bool CEvent::Init( bool bManualReset, bool bInitialState ) +{ + Term(); + + m_hEvent = (void*)CreateEvent( NULL, bManualReset, bInitialState, NULL ); + return (m_hEvent != NULL); +} + +void CEvent::Term() +{ + if ( m_hEvent ) + { + CloseHandle( (HANDLE)m_hEvent ); + m_hEvent = NULL; + } +} + +void* CEvent::GetEventHandle() const +{ + Assert( m_hEvent ); + return m_hEvent; +} + +bool CEvent::SetEvent() +{ + Assert( m_hEvent ); + return ::SetEvent( (HANDLE)m_hEvent ) != 0; +} + +bool CEvent::ResetEvent() +{ + Assert( m_hEvent ); + return ::ResetEvent( (HANDLE)m_hEvent ) != 0; +} + + diff --git a/utils/vmpi/threadhelpers.h b/utils/vmpi/threadhelpers.h new file mode 100644 index 0000000..bfba74f --- /dev/null +++ b/utils/vmpi/threadhelpers.h @@ -0,0 +1,110 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#ifndef THREADHELPERS_H +#define THREADHELPERS_H +#ifdef _WIN32 +#pragma once +#endif + + +#include "tier1/utllinkedlist.h" + + +#define SIZEOF_CS 24 // sizeof( CRITICAL_SECTION ) + + +class CCriticalSection +{ +public: + CCriticalSection(); + ~CCriticalSection(); + + +protected: + + friend class CCriticalSectionLock; + + void Lock(); + void Unlock(); + + +public: + char m_CS[SIZEOF_CS]; + + // Used to protect against deadlock in debug mode. +//#if defined( _DEBUG ) + CUtlLinkedList<unsigned long,int> m_Locks; + char m_DeadlockProtect[SIZEOF_CS]; +//#endif +}; + + +// Use this to lock a critical section. +class CCriticalSectionLock +{ +public: + CCriticalSectionLock( CCriticalSection *pCS ); + ~CCriticalSectionLock(); + void Lock(); + void Unlock(); + +private: + CCriticalSection *m_pCS; + bool m_bLocked; +}; + + +template< class T > +class CCriticalSectionData : private CCriticalSection +{ +public: + // You only have access to the data between Lock() and Unlock(). + T* Lock() + { + CCriticalSection::Lock(); + return &m_Data; + } + + void Unlock() + { + CCriticalSection::Unlock(); + } + +private: + T m_Data; +}; + + + +// ------------------------------------------------------------------------------------------------ // +// CEvent. +// ------------------------------------------------------------------------------------------------ // +class CEvent +{ +public: + CEvent(); + ~CEvent(); + + bool Init( bool bManualReset, bool bInitialState ); + void Term(); + + void* GetEventHandle() const; + + // Signal the event. + bool SetEvent(); + + // Unset the event's signalled status. + bool ResetEvent(); + + +private: + void *m_hEvent; +}; + + +#endif // THREADHELPERS_H diff --git a/utils/vmpi/vmpi.cpp b/utils/vmpi/vmpi.cpp new file mode 100644 index 0000000..ceed5fb --- /dev/null +++ b/utils/vmpi/vmpi.cpp @@ -0,0 +1,2478 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: This module implements the subset of MPI that VRAD and VVIS use. +// +// $NoKeywords: $ +//=============================================================================// + +#include <windows.h> +#include <io.h> +#include <conio.h> +#include <sys/stat.h> +#include <stdio.h> +#include <direct.h> +#include "iphelpers.h" +#include "utlvector.h" +#include "utllinkedlist.h" +#include "vmpi.h" +#include "bitbuf.h" +#include "tier1/strtools.h" +#include "threadhelpers.h" +#include "IThreadedTCPSocket.h" +#include "vstdlib/random.h" +#include "vmpi_distribute_work.h" +#include "filesystem.h" +#include "checksum_md5.h" +#include "tslist.h" +#include "tier0/icommandline.h" + + +#define DEFAULT_MAX_WORKERS 32 // Unless they specify -mpi_MaxWorkers, it will stop accepting workers after it gets this many. +int g_nMaxWorkerCount = DEFAULT_MAX_WORKERS; + +#define VMPI_INTERNAL_PACKET_ID 27 + #define VMPI_INTERNAL_SUBPACKET_MACHINE_NAME 1 + #define VMPI_INTERNAL_SUBPACKET_COMMAND_LINE 2 + #define VMPI_INTERNAL_SUBPACKET_WAITING_FOR_COMMAND_LINE 3 + #define VMPI_INTERNAL_SUBPACKET_GROUPED_PACKET 4 + #define VMPI_INTERNAL_SUBPACKET_TIMING_WAIT_DONE 5 + #define VMPI_INTERNAL_SUBPACKET_VERIFY_EXE_NAME 6 + + +typedef CUtlVector<char> PersistentPacket; + +CCriticalSection g_PersistentPacketsCS; +CUtlLinkedList<PersistentPacket*> g_PersistentPackets; + + +// Command-line parameters list. +#define VMPI_PARAM( paramName, paramFlags, helpText ) {paramName, paramFlags, "-"#paramName, helpText}, +class CVMPIParam +{ +public: + EVMPICmdLineParam m_eParam; + int m_ParamFlags; + const char *m_pName; + const char *m_pHelpText; +}; +static CVMPIParam g_VMPIParams[] = +{ + {k_eVMPICmdLineParam_FirstParam, 0, "k_eVMPICmdLineParam_FirstParam", "unused"}, + {k_eVMPICmdLineParam_VMPIParam, 0, "mpi", "Enable VMPI."}, +#include "vmpi_parameters.h" +}; +#undef VMPI_PARAM + + +// ---------------------------------------------------------------------------------------- // +// Globals. +// ---------------------------------------------------------------------------------------- // + +class CVMPIConnection; + +// Used by -mpi_AutoRestart. +CUtlVector<char*> g_OriginalCommandLineParameters; + +// This queues up all the incoming VMPI messages. +CCriticalSection g_VMPIMessagesCS; +CUtlLinkedList< CTCPPacket*, int > g_VMPIMessages; +CEvent g_VMPIMessagesEvent; // This is set when there are messages in the queue. + +// These are used to notify the main thread when some socket had OnError() called on it. +CUtlLinkedList<CVMPIConnection*,int> g_ErrorSockets; +CEvent g_ErrorSocketsEvent; +CCriticalSection g_ErrorSocketsCS; +bool g_bTimingWaitDone = false; +bool g_bGroupPackets = false; + +#define MAX_VMPI_CONNECTIONS 512 +CVMPIConnection *g_Connections[MAX_VMPI_CONNECTIONS]; +int g_nConnections = 0; +CCriticalSection g_ConnectionsCS; + +// If true, then it will set certain thread priorities low. +bool g_bSetThreadPriorities = true; + +VMPIDispatchFn g_VMPIDispatch[MAX_VMPI_PACKET_IDS]; +CTSList<MessageBuffer *> g_DispatchBuffers; + +VMPIRunMode g_VMPIRunMode = VMPI_RUN_NETWORKED; +VMPIFileSystemMode g_VMPIFileSystemMode = VMPI_FILESYSTEM_TCP; + +static char g_GroupedPacketHeader[] = { VMPI_INTERNAL_PACKET_ID, VMPI_INTERNAL_SUBPACKET_GROUPED_PACKET }; +static unsigned long g_LastFlushGroupedPacketsTime = 0; + +// Set to true if we're running under the SDK (i.e. vmpi_transfer.exe is not found). +bool g_bVMPISDKMode = false; +bool g_bVMPISDKModeSet = false; // If g_bVMPISDKMode has not been set, then VMPI_IsSDKMode just looks for VMPI_Transfer (and doesn't check the command line). + +int g_nBytesSent = 0; +int g_nMessagesSent = 0; +int g_nBytesReceived = 0; +int g_nMessagesReceived = 0; + +int g_nMulticastBytesSent = 0; +int g_nMulticastBytesReceived = 0; + + +CUtlLinkedList<VMPI_Disconnect_Handler,int> g_DisconnectHandlers; + +bool g_bUseMPI = false; +int g_iVMPIVerboseLevel = 0; +bool g_bMPIMaster = false; + +bool g_bMPI_Stats = false; +bool g_bMPI_StatsTextOutput = false; + +char g_CurrentStageString[128] = ""; +CCriticalSection g_CurrentStageCS; + +char g_MasterExeName[MAX_PATH]; +bool g_bReceivedMasterExeName = false; + + +// Change our window text. +HINSTANCE g_hKernel32DLL = NULL; +typedef HWND (*GetConsoleWndFn)(); +GetConsoleWndFn g_pConsoleWndFn = NULL; + + +// ---------------------------------------------------------------------------------------- // +// Classes. +// ---------------------------------------------------------------------------------------- // + +// This class is used while discovering what files the workers need. +class CDependencyInfo +{ +public: + class CDependencyFile + { + public: + char m_Name[MAX_PATH]; + }; + + + // This is the directory where the dependency files live (i.e. all the binaries that the workers need to run the job). + char m_DependencyFilesDir[MAX_PATH]; + + // "vrad.exe", "vvis.exe", etc. + char m_OriginalExeFilename[MAX_PATH]; + + CUtlVector<CDependencyFile*> m_Files; + + +public: + + CDependencyFile* FindFile( const char *pFilename ) + { + for ( int i=0; i < m_Files.Count(); i++ ) + { + if ( stricmp( pFilename, m_Files[i]->m_Name ) == 0 ) + return m_Files[i]; + } + return NULL; + } +}; + + +class CVMPIConnection : public ITCPSocketHandler +{ +public: + CVMPIConnection( int iConnection ) + { + m_iConnection = iConnection; + m_pSocket = NULL; + m_bIsAService = false; + + char str[512]; + Q_snprintf( str, sizeof( str ), "%d", iConnection ); + SetMachineName( str ); + m_JobWorkerID = 0xFFFFFFFF; + + m_bNameSet = false; + } + + ~CVMPIConnection() + { + if ( m_pSocket ) + m_pSocket->Release(); + } + + +public: + + void HandleDisconnect() + { + if ( m_pSocket ) + { + // Copy out the error string. + CCriticalSectionLock csLock( &g_ErrorSocketsCS ); + csLock.Lock(); + char str[512]; + Q_strncpy( str, m_ErrorString.Base(), sizeof( str ) ); + csLock.Unlock(); + + // Tell the app. + FOR_EACH_LL( g_DisconnectHandlers, i ) + g_DisconnectHandlers[i]( m_iConnection, str ); + + // Free our socket. + m_pSocket->Release(); + m_pSocket = NULL; + } + } + + + IThreadedTCPSocket* GetSocket() + { + return m_pSocket; + } + + + void SetMachineName( const char *pName ) + { + m_MachineName.CopyArray( pName, strlen( pName ) + 1 ); + m_bNameSet = true; + } + + const char* GetMachineName() + { + return m_MachineName.Base(); + } + + bool HasMachineNameBeenSet() + { + return m_bNameSet; + } + + +// ITCPSocketHandler implementation (thread-safe stuff). +public: + + virtual void Init( IThreadedTCPSocket *pSocket ) + { + m_pSocket = pSocket; + } + + virtual void OnPacketReceived( CTCPPacket *pPacket ) + { + // Set who this message came from. + pPacket->SetUserData( m_iConnection ); + Assert( m_iConnection >= 0 && m_iConnection < 2048 ); + + // Store it in the global list. + CCriticalSectionLock csLock( &g_VMPIMessagesCS ); + csLock.Lock(); + + g_VMPIMessages.AddToTail( pPacket ); + + if ( g_VMPIMessages.Count() == 1 ) + g_VMPIMessagesEvent.SetEvent(); + } + + virtual void OnError( int errorCode, const char *pErrorString ) + { + if ( !g_bMPIMaster ) + { + Msg( "%s - CVMPIConnection::OnError( %s )\n", GetMachineName(), pErrorString ); + } + + CCriticalSectionLock csLock( &g_ErrorSocketsCS ); + csLock.Lock(); + + m_ErrorString.CopyArray( pErrorString, strlen( pErrorString ) + 1 ); + + g_ErrorSockets.AddToTail( this ); + + // Notify the main thread that a socket is in trouble! + g_ErrorSocketsEvent.SetEvent(); + + // Make sure the main thread picks up this error soon. + InterlockedIncrement( &m_ErrorSignal ); + } + + +public: + + unsigned long m_JobWorkerID; + bool m_bIsAService; // If true, then this is just a service getting the files. Don't count it as an active worker. + + CUtlVector<int> m_GroupedChunkLengths; + CUtlVector<void*> m_GroupedChunks; + + +private: + + CUtlVector<char> m_MachineName; + CUtlVector<char> m_ErrorString; + long m_ErrorSignal; + int m_iConnection; + IThreadedTCPSocket *m_pSocket; + bool m_bNameSet; +}; + + +class CVMPIConnectionCreator : public IHandlerCreator +{ +public: + virtual ITCPSocketHandler* CreateNewHandler() + { + Assert( g_nConnections < MAX_VMPI_CONNECTIONS ); + CVMPIConnection *pRet = new CVMPIConnection( g_nConnections ); + g_Connections[g_nConnections++] = pRet; + return pRet; + } +}; + + + +// ---------------------------------------------------------------------------------------- // +// Helpers. +// ---------------------------------------------------------------------------------------- // + +const char* VMPI_FindArg( int argc, char **argv, const char *pName, const char *pDefault ) +{ + for ( int i=0; i < argc; i++ ) + { + if ( stricmp( argv[i], pName ) == 0 ) + { + if ( (i+1) < argc ) + return argv[i+1]; + else + return pDefault; + } + } + return NULL; +} + + +void ParseOptions( int argc, char **argv ) +{ + if ( VMPI_FindArg( argc, argv, VMPI_GetParamString( mpi_NoTimeout ) ) ) + ThreadedTCP_EnableTimeouts( false ); + + if ( VMPI_FindArg( argc, argv, VMPI_GetParamString( mpi_DontSetThreadPriorities ) ) ) + { + Msg( "%s found.\n", VMPI_GetParamString( mpi_DontSetThreadPriorities ) ); + g_bSetThreadPriorities = false; + ThreadedTCP_SetTCPSocketThreadPriorities( false ); + } + + if ( VMPI_FindArg( argc, argv, VMPI_GetParamString( mpi_GroupPackets ) ) ) + { + Msg( "%s found.\n", VMPI_GetParamString( mpi_GroupPackets ) ); + g_bGroupPackets = true; + } + + const char *pTransmitRate = VMPI_FindArg( argc, argv, VMPI_GetParamString( mpi_FileTransmitRate ), "1" ); + if ( pTransmitRate ) + { + extern int MULTICAST_TRANSMIT_RATE; + MULTICAST_TRANSMIT_RATE = atoi( pTransmitRate ) * 1024; + } + + const char *pVerbose = VMPI_FindArg( argc, argv, VMPI_GetParamString( mpi_Verbose ), "1" ); + if ( pVerbose ) + { + if ( pVerbose[0] == '1' ) + g_iVMPIVerboseLevel = 1; + else if ( pVerbose[0] == '2' ) + g_iVMPIVerboseLevel = 2; + } + + if ( VMPI_FindArg( argc, argv, VMPI_GetParamString( mpi_Stats ) ) ) + g_bMPI_Stats = true; + + if ( VMPI_FindArg( argc, argv, VMPI_GetParamString( mpi_Stats_TextOutput ) ) ) + g_bMPI_StatsTextOutput = true; +} + + +void SetupDependencyFilename( CDependencyInfo *pInfo, const char *pPatchDirectory ) +{ + char baseExeFilename[512]; + if ( !GetModuleFileName( GetModuleHandle( NULL ), baseExeFilename, sizeof( baseExeFilename ) ) ) + Error( "GetModuleFileName failed." ); + + // If they're in patch mode, then the dependency files come out of a directory they've passed in. + // Otherwise, the files come from the same exe dir we're in (like c:\valve\game\bin). + if ( pPatchDirectory ) + { + V_strncpy( pInfo->m_DependencyFilesDir, pPatchDirectory, sizeof( pInfo->m_DependencyFilesDir ) ); + } + else + { + V_strncpy( pInfo->m_DependencyFilesDir, baseExeFilename, sizeof( pInfo->m_DependencyFilesDir ) ); + V_StripLastDir( pInfo->m_DependencyFilesDir, sizeof( pInfo->m_DependencyFilesDir ) ); + } + + // Get the exe filename. + V_strncpy( pInfo->m_OriginalExeFilename, V_UnqualifiedFileName( baseExeFilename ), sizeof( pInfo->m_OriginalExeFilename ) ); +} + + +bool ReadString( char *pOut, int maxLen, FILE *fp ) +{ + if ( !fgets( pOut, maxLen, fp ) || pOut[0] == 0 ) + return false; + + int len = strlen( pOut ); + if ( pOut[len - 1] == '\n' ) + pOut[len - 1] = 0; + + return true; +} + + +void ParseDependencyFile( CDependencyInfo *pInfo, const char *pDepFilename ) +{ + FILE *fp = fopen( pDepFilename, "rt" ); + if ( !fp ) + Error( "Can't find %s.", pDepFilename ); + + const char *pOptionalPrefix = "optional "; + + char tempStr[MAX_PATH]; + while ( ReadString( tempStr, sizeof( tempStr ), fp ) ) + { + CDependencyInfo::CDependencyFile *pFile = new CDependencyInfo::CDependencyFile; + bool bOptional = false; + if ( strstr( tempStr, "optional " ) == tempStr ) + { + bOptional = true; + Q_strncpy( pFile->m_Name, tempStr + strlen( pOptionalPrefix ), sizeof( pFile->m_Name ) ); + } + else + { + Q_strncpy( pFile->m_Name, tempStr, sizeof( pFile->m_Name ) ); + } + + // Now get the file info. + char fullFilename[MAX_PATH]; + V_ComposeFileName( pInfo->m_DependencyFilesDir, pFile->m_Name, fullFilename, sizeof( fullFilename ) ); + + if ( _access( fullFilename, 0 ) == 0 ) + { + pInfo->m_Files.AddToTail( pFile ); + } + else + { + delete pFile; + + if ( !bOptional ) + Error( "Can't find %s (listed in %s).", fullFilename, pDepFilename ); + } + } + + fclose( fp ); +} + + +void SetupDependenciesForPatch( CDependencyInfo *pInfo, const char *pPatchDirectory ) +{ + char searchStr[MAX_PATH]; + V_ComposeFileName( pPatchDirectory, "*.*", searchStr, sizeof( searchStr ) ); + + _finddata_t data; + long handle = _findfirst( searchStr, &data ); + if ( handle != -1 ) + { + do + { + if ( data.name[0] == '.' || (data.attrib & _A_SUBDIR) != 0 ) + continue; + + CDependencyInfo::CDependencyFile *pFile = new CDependencyInfo::CDependencyFile; + V_strncpy( pFile->m_Name, data.name, sizeof( pFile->m_Name ) ); + pInfo->m_Files.AddToTail( pFile ); + } while( _findnext( handle, &data ) == 0 ); + + _findclose( handle ); + } +} + + +void SetupDependencyInfo( CDependencyInfo *pInfo, const char *pDependencyFilename, bool bPatchMode ) +{ + if ( bPatchMode ) + { + const char *pPatchDirectory = pDependencyFilename; + + SetupDependencyFilename( pInfo, pPatchDirectory ); + SetupDependenciesForPatch( pInfo, pPatchDirectory ); + } + else + { + SetupDependencyFilename( pInfo, NULL ); + + // Parse the dependency file. + char depFilename[MAX_PATH]; + V_ComposeFileName( pInfo->m_DependencyFilesDir, pDependencyFilename, depFilename, sizeof( depFilename ) ); + ParseDependencyFile( pInfo, depFilename ); + } +} + + +int GetCurMicrosecondsAndSleep( int sleepLen ) +{ + Sleep( sleepLen ); + + CCycleCount cnt; + cnt.Sample(); + return cnt.GetMicroseconds(); +} + + +void CountActiveConnections( int *nRegularWorkers, int *nServiceDownloaders ) +{ + *nRegularWorkers = *nServiceDownloaders = 0; + int nTotalConnections = g_nConnections; + for ( int i=0; i < nTotalConnections; i++ ) + { + if ( VMPI_IsProcConnected( i ) ) + { + if ( VMPI_IsProcAService( i ) ) + (*nServiceDownloaders)++; + else + (*nRegularWorkers)++; + } + } +} + +// In this function, we update the window text to tell how many active workers there are. +void UpdateActiveConnectionsText() +{ + if ( !g_bMPIMaster || !g_pConsoleWndFn ) + return; + + HWND hWnd = g_pConsoleWndFn(); + if ( !hWnd ) + return; + + int nRegularWorkers, nDownloaders; + CountActiveConnections( &nRegularWorkers, &nDownloaders ); + + char str[512]; + if ( g_bVMPISDKMode ) + { + V_snprintf( str, sizeof( str ), "VMPI (SDK) - Workers: %d", nRegularWorkers ); + } + else + { + V_snprintf( str, sizeof( str ), "VMPI - Workers: %d, Downloaders: %d", nRegularWorkers, nDownloaders ); + } + SetWindowText( hWnd, str ); +} + + +void VMPI_SendMachineNameTo( int iProc ) +{ + const char *pMyName = VMPI_GetLocalMachineName(); + + unsigned char packetData[512]; + packetData[0] = VMPI_INTERNAL_PACKET_ID; + packetData[1] = VMPI_INTERNAL_SUBPACKET_MACHINE_NAME; + Q_strncpy( (char*)&packetData[2], pMyName, sizeof( packetData ) - 2 ); + VMPI_SendData( packetData, 2 + strlen( pMyName ) + 1, iProc ); +} + +static CVMPIConnection* FindConnectionBySocket( IThreadedTCPSocket *pSocket, bool bLockConnections ) +{ + CCriticalSectionLock connectionsLock( &g_ConnectionsCS ); + if ( bLockConnections ) + connectionsLock.Lock(); + + for ( int i=0; i < g_nConnections; i++ ) + if ( g_Connections[i]->GetSocket() == pSocket ) + return g_Connections[i]; + + return NULL; +} + +static char* CopyString( const char *pStr ) +{ + int len = V_strlen( pStr ) + 1; + char *pArg = new char[len]; + Q_strncpy( pArg, pStr, len ); + return pArg; +} + +// ---------------------------------------------------------------------------------------- // +// Internal VMPI dispatch.. +// ---------------------------------------------------------------------------------------- // + +void VMPI_SetMachineName( int iProc, const char *pName ); + +CUtlVector<char*> g_WorkerCommandLine; +bool g_bReceivedWorkerCommandLine = false; + + +bool VMPI_InternalDispatchFn( MessageBuffer *pBuf, int iSource, int iPacketID ) +{ + if ( pBuf->getLen() >= 2 ) + { + if ( pBuf->data[1] == VMPI_INTERNAL_SUBPACKET_MACHINE_NAME ) + { + if ( pBuf->getLen() >= 3 ) + { + VMPI_SetMachineName( iSource, &pBuf->data[2] ); + return true; + } + } + else if ( pBuf->data[1] == VMPI_INTERNAL_SUBPACKET_WAITING_FOR_COMMAND_LINE ) + { + if ( !VMPI_IsSDKMode() ) + { + Warning( "Worker %d is running in SDK mode (and the master is not)!\n", iSource ); + } + return true; + } + else if ( pBuf->data[1] == VMPI_INTERNAL_SUBPACKET_COMMAND_LINE ) + { + pBuf->setOffset( 2 ); + + int nArgs; + pBuf->read( &nArgs, sizeof( nArgs ) ); + for ( int i=0; i < nArgs; i++ ) + { + char str[4096]; + if ( pBuf->ReadString( str, sizeof( str ) ) == -1 ) + Error( "Error in ReadString() while reading command line." ); + + g_WorkerCommandLine.AddToTail( CopyString( str ) ); + } + + g_bReceivedWorkerCommandLine = true; + return true; + } + else if ( pBuf->data[1] == VMPI_INTERNAL_SUBPACKET_VERIFY_EXE_NAME ) + { + pBuf->setOffset( 2 ); + + if ( pBuf->ReadString( g_MasterExeName, sizeof( g_MasterExeName ) ) == -1 ) + Error( "Error in ReadString() while reading VMPI_INTERNAL_SUBPACKET_VERIFY_EXE_NAME." ); + + g_bReceivedMasterExeName = true; + return true; + } + else if ( pBuf->data[1] == VMPI_INTERNAL_SUBPACKET_TIMING_WAIT_DONE ) + { + g_bTimingWaitDone = true; + return true; + } + } + + return false; +} +CDispatchReg g_VMPIInternalDispatchReg( VMPI_INTERNAL_PACKET_ID, VMPI_InternalDispatchFn ); // register to handle the messages we want + + +void VMPI_SendCommandLine( int argc, char **argv ) +{ + MessageBuffer mb; + + char cPacketHeader[2] = {VMPI_INTERNAL_PACKET_ID, VMPI_INTERNAL_SUBPACKET_COMMAND_LINE}; + mb.write( cPacketHeader, sizeof( cPacketHeader ) ); + mb.write( &argc, sizeof( argc ) ); + for ( int i=0; i < argc; i++ ) + mb.WriteString( argv[i] ); + + VMPI_SendData( mb.data, mb.getLen(), VMPI_PERSISTENT ); +} + +void VMPI_ReceiveCommandLine() +{ + // For verification purposes, tell the master we're trying to get the command line. + unsigned char chData[2] = {VMPI_INTERNAL_PACKET_ID, VMPI_INTERNAL_SUBPACKET_WAITING_FOR_COMMAND_LINE}; + VMPI_SendData( chData, sizeof( chData ), VMPI_MASTER_ID ); + + double startTime = Plat_FloatTime(); + while ( !g_bReceivedWorkerCommandLine ) + { + if ( Plat_FloatTime() - startTime > 30 ) + Error( "VMPI_ReceiveCommandLine: timeout. Is the master running in SDK mode?" ); + + VMPI_DispatchNextMessage( 10 * 1000 ); + } +} + + +void VMPI_SendExeName() +{ + MessageBuffer mb; + + char cPacketHeader[2] = {VMPI_INTERNAL_PACKET_ID, VMPI_INTERNAL_SUBPACKET_VERIFY_EXE_NAME}; + mb.write( cPacketHeader, sizeof( cPacketHeader ) ); + + char baseExeFilename[MAX_PATH], fileBase[MAX_PATH]; + if ( !GetModuleFileName( GetModuleHandle( NULL ), baseExeFilename, sizeof( baseExeFilename ) ) ) + Error( "VMPI_CheckSDKMode -> GetModuleFileName failed." ); + + V_FileBase( baseExeFilename, fileBase, sizeof( fileBase ) ); + mb.WriteString( fileBase ); + + VMPI_SendData( mb.data, mb.getLen(), VMPI_PERSISTENT ); +} + +void VMPI_ReceiveExeName() +{ + double startTime = Plat_FloatTime(); + while ( !g_bReceivedMasterExeName ) + { + if ( Plat_FloatTime() - startTime > 30 ) + Error( "VMPI_ReceiveExeName: timeout." ); + + VMPI_DispatchNextMessage( 10 * 1000 ); + } + + // Now compare the exe name we got with our own. + char baseExeFilename[MAX_PATH], fileBase[MAX_PATH]; + if ( !GetModuleFileName( GetModuleHandle( NULL ), baseExeFilename, sizeof( baseExeFilename ) ) ) + Error( "VMPI_CheckSDKMode -> GetModuleFileName failed." ); + + // Unless we're a vmpi_transfer.. vmpi_transfer can always connect. + V_FileBase( baseExeFilename, fileBase, sizeof( fileBase ) ); + if ( V_stricmp( fileBase, "vmpi_transfer" ) != 0 ) + { + if ( V_stricmp( fileBase, g_MasterExeName ) != 0 ) + { + Error( "VMPI_ReceiveExeName: mismatched exe names (master: %s, me: %s).\nThis usually just means the master finished" + " a job like vvis really fast and started a vrad immediately, and an old vvis worker connected to the new vrad job.", + g_MasterExeName, fileBase ); + } + } +} + + +// ---------------------------------------------------------------------------------------- // +// CMasterBroadcaster +// This class broadcasts messages looking for workers. The app updates it as often as possible +// and it'll add workers as necessary. +// ---------------------------------------------------------------------------------------- // + +#define MASTER_BROADCAST_INTERVAL 600 // Send every N milliseconds. + +class CMasterBroadcaster +{ +public: + + CMasterBroadcaster(); + ~CMasterBroadcaster(); + + bool Init( int argc, char **argv, const char *pDependencyFilename, int nMaxWorkers, VMPIRunMode runMode, bool bPatchMode ); + void Term(); + + // What port is it listening on? + int GetListenPort() const; + + // These can be used to allow more workers on or filter who's able to connect + int GetMaxWorkers() const; + void IncreaseMaxWorkers( int count ); + void SetPassword( const char *pPassword ); + void SetNoTimeoutOption(); + + +private: + + void GetPatchWorkerList( int argc, char **argv ); + + +private: + + class CMasterBroadcastInfo + { + public: + int m_JobID[4]; + char m_Password[256]; + char m_WorkerExeFilename[MAX_PATH]; + CUtlVector<char*> m_Args; + char m_PatchVersion[32]; // 0 if not patching. + bool m_bForcePatch; + }; + + void ThreadFn(); + static DWORD WINAPI StaticThreadFn( LPVOID lpParameter ); + + bool Update(); + void BuildBroadcastPacket( bf_write &buf ); + + +private: + + ITCPConnectSocket *m_pListenSocket; + ITCPConnectSocket *m_pDownloaderListenSocket; + ISocket *m_pSocket; + + DWORD m_LastSendTime; + CMasterBroadcastInfo m_BroadcastInfo; + CUtlVector<CIPAddr> m_PatchWorkerIPs; // If in patch mode, these are the IPs we send the job request to (instead of broadcasting). + bool m_bPatching; + + CVMPIConnectionCreator m_ConnectionCreator; + int m_nMaxWorkers; + + HANDLE m_hThread; + CEvent m_hShutdownEvent; + CEvent m_hShutdownReply; + + VMPIRunMode m_RunMode; + int m_iListenPort; + int m_iDownloaderListenPort; +}; + + +CMasterBroadcaster::CMasterBroadcaster() +{ + m_pListenSocket = NULL; + m_pDownloaderListenSocket = NULL; + m_pSocket = NULL; + m_iListenPort = -1; + m_iDownloaderListenPort = -1; +} + +CMasterBroadcaster::~CMasterBroadcaster() +{ + Term(); +} + + +void CMasterBroadcaster::GetPatchWorkerList( int argc, char **argv ) +{ + m_PatchWorkerIPs.Purge(); + for ( int i=0; i < argc-1; i++ ) + { + if ( V_stricmp( argv[i], "-mpi_PatchWorkers" ) == 0 ) + { + int workerCount = atoi( argv[i+1] ); + for ( int iWorker=0; iWorker < workerCount; iWorker++ ) + { + int iArg = i+2 + iWorker; + if ( iArg >= argc ) + Error( "-mpi_PatchWorkers: %d specified for count, but not enough IPs following.\n", workerCount ); + + int a, b, c, d; + const char *pArg = argv[iArg]; + sscanf( pArg, "%d.%d.%d.%d", &a, &b, &c, &d ); + + CIPAddr addr; + addr.Init( a, b, c, d, 0 ); + m_PatchWorkerIPs.AddToTail( addr ); + } + return; + } + } +} + +bool CMasterBroadcaster::Init( + int argc, + char **argv, + const char *pDependencyFilename, + int nMaxWorkers, + VMPIRunMode runMode, + bool bPatchMode ) +{ + m_RunMode = runMode; + m_nMaxWorkers = nMaxWorkers; + + // Open the file that tells us which binaries we depend on. + CDependencyInfo dependencyInfo; + if ( m_RunMode == VMPI_RUN_NETWORKED && !g_bVMPISDKMode ) + { + SetupDependencyInfo( &dependencyInfo, pDependencyFilename, bPatchMode ); + } + + m_pListenSocket = NULL; + m_pDownloaderListenSocket = NULL; + + const char *pPortStr = VMPI_FindArg( argc, argv, VMPI_GetParamString( mpi_Port ) ); + if ( pPortStr ) + { + m_iListenPort = atoi( pPortStr ); + m_iDownloaderListenPort = m_iListenPort + 1; + m_pListenSocket = ThreadedTCP_CreateListener( &m_ConnectionCreator, m_iListenPort ); + if ( !g_bVMPISDKMode ) + { + m_pDownloaderListenSocket = ThreadedTCP_CreateListener( &m_ConnectionCreator, m_iDownloaderListenPort ); + } + } + else + { + // Create a socket to listen on. + CCycleCount cnt; + cnt.Sample(); + int iTime = (int)cnt.GetMicroseconds(); + srand( (unsigned)iTime ); + + for ( int iTest=VMPI_MASTER_FIRST_PORT; iTest <= VMPI_MASTER_LAST_PORT; iTest++ ) + { + m_iListenPort = iTest; + m_pListenSocket = ThreadedTCP_CreateListener( &m_ConnectionCreator, m_iListenPort ); + if ( m_pListenSocket ) + break; + } + // No need to create the downloader in SDK mode. + if ( m_pListenSocket && !g_bVMPISDKMode ) + { + for ( int iTest=m_iListenPort+1; iTest <= VMPI_MASTER_LAST_PORT; iTest++ ) + { + m_iDownloaderListenPort = iTest; + if ( m_iDownloaderListenPort == m_iListenPort ) + continue; + + m_pDownloaderListenSocket = ThreadedTCP_CreateListener( &m_ConnectionCreator, m_iDownloaderListenPort ); + if ( m_pDownloaderListenSocket ) + break; + } + } + } + + if ( !m_pListenSocket || (!g_bVMPISDKMode && !m_pDownloaderListenSocket) ) + { + Error( "Can't bind a listen socket in port range [%d, %d].", VMPI_MASTER_PORT_FIRST, VMPI_MASTER_PORT_LAST ); + } + + + // Create a socket to broadcast from unless we're in the SDK in which case we don't broadcast. + m_bPatching = false; + if ( m_RunMode == VMPI_RUN_NETWORKED && !g_bVMPISDKMode ) + { + m_pSocket = CreateIPSocket(); + if ( !m_pSocket->BindToAny( 0 ) ) + Error( "MPI_Init_Master: can't bind a socket" ); + + m_BroadcastInfo.m_bForcePatch = false; + if ( bPatchMode ) + { + m_bPatching = true; + if ( VMPI_FindArg( argc, argv, "-mpi_ForcePatch", NULL ) ) + m_BroadcastInfo.m_bForcePatch = true; + + const char *pArg = VMPI_FindArg( argc, argv, "-mpi_PatchVersion", "0" ); + float iPatchVersion = atof( pArg ); + if ( iPatchVersion <= 0 || iPatchVersion >= ((1 << 15) - 1) ) + { + Error( "-mpi_PatchVersion <val> - val must be between 1.0 and 32767.0" ); + } + + V_strncpy( m_BroadcastInfo.m_PatchVersion, pArg, sizeof( m_BroadcastInfo.m_PatchVersion ) ); + } + else + { + m_BroadcastInfo.m_PatchVersion[0] = 0; + } + + // Come up with a unique job ID. + m_BroadcastInfo.m_JobID[0] = GetCurMicrosecondsAndSleep( 1 ); + m_BroadcastInfo.m_JobID[1] = GetCurMicrosecondsAndSleep( 1 ); + m_BroadcastInfo.m_JobID[2] = GetCurMicrosecondsAndSleep( 1 ); + m_BroadcastInfo.m_JobID[3] = GetCurMicrosecondsAndSleep( 1 ); + + const char *pPassword = VMPI_FindArg( argc, argv, "-mpi_pw", "" ); + Q_strncpy( m_BroadcastInfo.m_Password, pPassword ? pPassword : "", sizeof( m_BroadcastInfo.m_Password ) ); + Q_strncpy( m_BroadcastInfo.m_WorkerExeFilename, dependencyInfo.m_OriginalExeFilename, sizeof( m_BroadcastInfo.m_WorkerExeFilename ) ); + + // Store the command-line args. + m_BroadcastInfo.m_Args.Purge(); + for ( int i=1; i < argc; i++ ) + { + m_BroadcastInfo.m_Args.AddToTail( CopyString( argv[i] ) ); + } + // 0th arg is the exe name. + m_BroadcastInfo.m_Args.InsertBefore( 0, CopyString( m_BroadcastInfo.m_WorkerExeFilename ) ); + + // Now add arguments for each file they need to transmit. The service will use this to get all the files from the master before it starts the app. + for ( int i=0; i < dependencyInfo.m_Files.Count(); i++ ) + { + m_BroadcastInfo.m_Args.InsertAfter( 0, "-mpi_file" ); + m_BroadcastInfo.m_Args.InsertAfter( 1, CopyString( dependencyInfo.m_Files[i]->m_Name ) ); + } + + // Add -mpi_filebase so it can use absolute paths with the filesystem so we get the exact right set of files. + m_BroadcastInfo.m_Args.InsertAfter( 0, "-mpi_filebase" ); + m_BroadcastInfo.m_Args.InsertAfter( 1, CopyString( dependencyInfo.m_DependencyFilesDir ) ); + + if ( bPatchMode ) + { + GetPatchWorkerList( argc, argv ); + } + } + + + // Add ourselves as the first process (rank 0). + m_ConnectionCreator.CreateNewHandler(); + + // Initiate as many connections as we can for a few seconds. + m_LastSendTime = Plat_MSTime() - MASTER_BROADCAST_INTERVAL*2; + + + m_hShutdownEvent.Init( false, false ); + m_hShutdownReply.Init( false, false ); + + DWORD dwThreadID = 0; + m_hThread = CreateThread( + NULL, + 0, + &CMasterBroadcaster::StaticThreadFn, + this, + 0, + &dwThreadID ); + + if ( m_hThread ) + { + SetThreadPriority( m_hThread, THREAD_PRIORITY_HIGHEST ); + return true; + } + else + { + return false; + } +} + + +void CMasterBroadcaster::BuildBroadcastPacket( bf_write &buf ) +{ + // Broadcast out to tell all the machines we want workers. + buf.WriteByte( VMPI_PROTOCOL_VERSION ); + + buf.WriteString( m_BroadcastInfo.m_Password ); + + if ( m_BroadcastInfo.m_PatchVersion[0] == 0 ) + buf.WriteByte( VMPI_LOOKING_FOR_WORKERS ); + else + buf.WriteByte( VMPI_SERVICE_PATCH ); + + buf.WriteString( m_BroadcastInfo.m_PatchVersion ); + buf.WriteLong( m_iListenPort ); // Tell the port that we're listening on. + buf.WriteLong( m_BroadcastInfo.m_JobID[0] ); + buf.WriteLong( m_BroadcastInfo.m_JobID[1] ); + buf.WriteLong( m_BroadcastInfo.m_JobID[2] ); + buf.WriteLong( m_BroadcastInfo.m_JobID[3] ); + buf.WriteWord( m_BroadcastInfo.m_Args.Count() + 2 ); + + // Write the alternate exe name. + buf.WriteString( m_BroadcastInfo.m_WorkerExeFilename ); + + // Write the machine name of the master into the command line. It's ignored by the code, but it's useful + // if a job crashes the workers - by looking at the command line in vmpi_service, you can see who ran the job. + buf.WriteString( "-mpi_MasterName" ); + buf.WriteString( VMPI_GetLocalMachineName() ); + + for ( int i=1; i < m_BroadcastInfo.m_Args.Count(); i++ ) + buf.WriteString( m_BroadcastInfo.m_Args[i] ); + + buf.WriteByte( (unsigned char)m_BroadcastInfo.m_bForcePatch ); + buf.WriteShort( m_iDownloaderListenPort ); // Tell the port that we're listening for downloaders on. +} + +bool CMasterBroadcaster::Update() +{ + CCriticalSectionLock connectionsLock( &g_ConnectionsCS ); + connectionsLock.Lock(); + + // Don't accept any more connections when we've hit the limit. + int nActiveConnections, nServiceDownloaders; + CountActiveConnections( &nActiveConnections, &nServiceDownloaders ); + if ( nActiveConnections >= m_nMaxWorkers ) + return false; + + // Only broadcast our presence so often. + if ( m_pSocket ) + { + DWORD curTime = Plat_MSTime(); + if ( curTime - m_LastSendTime >= MASTER_BROADCAST_INTERVAL ) + { + char packetData[512]; + bf_write packetBuf( "packetBuf", packetData, sizeof( packetData ) ); + BuildBroadcastPacket( packetBuf ); + + for ( int iBroadcastPort=VMPI_SERVICE_PORT; iBroadcastPort <= VMPI_LAST_SERVICE_PORT; iBroadcastPort++ ) + { + if ( m_bPatching ) + { + // Only send to this specific list of workers if necessary. + for ( int i=0; i < m_PatchWorkerIPs.Count(); i++ ) + { + CIPAddr addr = m_PatchWorkerIPs[i]; + addr.port = iBroadcastPort; + m_pSocket->SendTo( &addr, packetBuf.GetBasePointer(), packetBuf.GetNumBytesWritten() ); + } + } + else + { + m_pSocket->Broadcast( packetBuf.GetBasePointer(), packetBuf.GetNumBytesWritten(), iBroadcastPort ); + } + } + + // We don't want them to keep patching over and over. + if ( m_PatchWorkerIPs.Count() > 0 && m_BroadcastInfo.m_bForcePatch ) + m_PatchWorkerIPs.Purge(); + + m_LastSendTime = curTime; + } + } + + // First look for normal workers. + IThreadedTCPSocket *pNewConn = NULL; + bool bRet = m_pListenSocket->Update( &pNewConn, 0 ); + + // Now look for downloaders. + if ( !bRet || !pNewConn ) + { + if ( m_pDownloaderListenSocket ) + { + int nDownloadersAllowed = (m_nMaxWorkers - nActiveConnections) + 8; // Don't allow too many downloaders. + if ( nServiceDownloaders < nDownloadersAllowed ) + bRet = m_pDownloaderListenSocket->Update( &pNewConn, 0 ); + } + } + + if ( bRet && pNewConn ) + { + // Mark this guy as a downloader if necessary. + CIPAddr remoteAddr = pNewConn->GetRemoteAddr(); + if ( remoteAddr.port >= VMPI_SERVICE_DOWNLOADER_PORT_FIRST && remoteAddr.port <= VMPI_SERVICE_DOWNLOADER_PORT_LAST ) + { + CVMPIConnection *pVMPIConnection = FindConnectionBySocket( pNewConn, false ); + if ( pVMPIConnection ) + pVMPIConnection->m_bIsAService = true; + } + + // Send this guy all the persistent packets. + CCriticalSectionLock csLock( &g_PersistentPacketsCS ); + csLock.Lock(); + + FOR_EACH_LL( g_PersistentPackets, iPacket ) + { + PersistentPacket *pPacket = g_PersistentPackets[iPacket]; + VMPI_SendData( pPacket->Base(), pPacket->Count(), g_nConnections-1 ); + } + + UpdateActiveConnectionsText(); + return true; + } + else + { + return false; + } +} + + +void CMasterBroadcaster::ThreadFn() +{ + // Update every 100ms or until the main thread tells us to go away. + while ( WaitForSingleObject( m_hShutdownEvent.GetEventHandle(), 20 ) == WAIT_TIMEOUT ) + { + DWORD startTime = GetTickCount(); + while ( Update() && (GetTickCount() - startTime) < 500 ) + { + } + } + m_hShutdownReply.SetEvent(); +} + + +DWORD CMasterBroadcaster::StaticThreadFn( LPVOID lpParameter ) +{ + ((CMasterBroadcaster*)lpParameter)->ThreadFn(); + return 0; +} + + +void CMasterBroadcaster::Term() +{ + // Shutdown the update thread. + if ( m_hThread ) + { + m_hShutdownEvent.SetEvent(); + WaitForSingleObject( m_hThread, INFINITE ); + CloseHandle( m_hThread ); + m_hThread = 0; + } + + if ( m_pSocket ) + { + m_pSocket->Release(); + m_pSocket = NULL; + } + + if ( m_pListenSocket ) + { + m_pListenSocket->Release(); + m_pListenSocket = NULL; + } + + if ( m_pDownloaderListenSocket ) + { + m_pDownloaderListenSocket->Release(); + m_pDownloaderListenSocket = NULL; + } + + m_iListenPort = -1; + m_iDownloaderListenPort = -1; +} + + +int CMasterBroadcaster::GetListenPort() const +{ + return m_iListenPort; +} + + +int CMasterBroadcaster::GetMaxWorkers() const +{ + return m_nMaxWorkers; +} + + +void CMasterBroadcaster::IncreaseMaxWorkers( int count ) +{ + CCriticalSectionLock connectionsLock( &g_ConnectionsCS ); + connectionsLock.Lock(); + + m_nMaxWorkers = min( MAX_VMPI_CONNECTIONS, m_nMaxWorkers + count ); +} + +void CMasterBroadcaster::SetPassword( const char *pPassword ) +{ + CCriticalSectionLock connectionsLock( &g_ConnectionsCS ); + connectionsLock.Lock(); + Q_strncpy( m_BroadcastInfo.m_Password, pPassword, sizeof( m_BroadcastInfo.m_Password ) ); +} + +void CMasterBroadcaster::SetNoTimeoutOption() +{ + CCriticalSectionLock connectionsLock( &g_ConnectionsCS ); + connectionsLock.Lock(); + + // Don't re-add the option if it's already there. + for ( int i=1; i < m_BroadcastInfo.m_Args.Count(); i++ ) + { + if ( Q_stricmp( m_BroadcastInfo.m_Args[i], VMPI_GetParamString( mpi_NoTimeout ) ) == 0 ) + return; + } + + m_BroadcastInfo.m_Args.InsertAfter( 0, (char*)VMPI_GetParamString( mpi_NoTimeout ) ); +} + + +CMasterBroadcaster g_MasterBroadcaster; + + +// ---------------------------------------------------------------------------------------- // +// CDispatchReg. +// ---------------------------------------------------------------------------------------- // + +CDispatchReg::CDispatchReg( int iPacketID, VMPIDispatchFn fn ) +{ + Assert( iPacketID >= 0 && iPacketID < MAX_VMPI_PACKET_IDS ); + Assert( !g_VMPIDispatch[iPacketID] ); + g_VMPIDispatch[iPacketID] = fn; +} + + +void VMPI_HandleTimingWait_Worker() +{ + if ( VMPI_IsParamUsed( mpi_TimingWait ) ) + { + Msg( "-mpi_TimingWait specified. Waiting for master to start..." ); + + // Wait for the signal to go. + while ( !g_bTimingWaitDone ) + { + VMPI_DispatchNextMessage( 50 ); + } + + Msg( "\n "); + } +} + + +void VMPI_HandleTimingWait_Master() +{ + if ( VMPI_IsParamUsed( mpi_TimingWait ) ) + { + Msg( "-mpi_TimingWait specified. Waiting for a keypress to continue... " ); + getch(); + Msg( "\n" ); + + unsigned char cPacket[2] = { VMPI_INTERNAL_PACKET_ID, VMPI_INTERNAL_SUBPACKET_TIMING_WAIT_DONE }; + VMPI_SendData( cPacket, sizeof( cPacket ), VMPI_PERSISTENT ); + } +} + + +// ---------------------------------------------------------------------------------------- // +// Helpers. +// ---------------------------------------------------------------------------------------- // + +bool MPI_Init_Worker( int &argc, char **&argv, const CIPAddr &masterAddr, bool bConnectingAsService ) +{ + g_bMPIMaster = false; + + // Make a connector to try connect to the master. + CVMPIConnectionCreator connectionCreator; + + int iFirstPort = VMPI_WORKER_PORT_FIRST; + int iLastPort = VMPI_WORKER_PORT_LAST; + if ( bConnectingAsService ) + { + iFirstPort = VMPI_SERVICE_DOWNLOADER_PORT_FIRST; + iLastPort = VMPI_SERVICE_DOWNLOADER_PORT_LAST; + } + + // Now wait for a connection. + int nAttempts = 1; +Retry:; + + ITCPConnectSocket *pConnectSocket = NULL; + int iPort; + for ( iPort=iFirstPort; iPort <= iLastPort; iPort++ ) + { + pConnectSocket = ThreadedTCP_CreateConnector( + masterAddr, + CIPAddr( 0, 0, 0, 0, iPort ), + &connectionCreator ); + + if ( pConnectSocket ) + break; + } + if ( !pConnectSocket ) + { + Error( "Can't bind a port in range [%d, %d].", iFirstPort, iLastPort ); + } + + + CWaitTimer wait( 3 ); + while ( 1 ) + { + IThreadedTCPSocket *pSocket = NULL; + if ( pConnectSocket->Update( &pSocket, 100 ) ) + { + if ( pSocket ) + { + // Send the master our machine name. + VMPI_SendMachineNameTo( VMPI_MASTER_ID ); + + // Verify that the exe is correct. + VMPI_ReceiveExeName(); + + if ( g_bVMPISDKMode ) + { + VMPI_ReceiveCommandLine(); + + CommandLine()->CreateCmdLine( g_WorkerCommandLine.Count(), g_WorkerCommandLine.Base() ); + argc = g_WorkerCommandLine.Count(); + argv = g_WorkerCommandLine.Base(); + } + + ParseOptions( g_WorkerCommandLine.Count(), g_WorkerCommandLine.Base() ); + for ( int i=0; i < g_WorkerCommandLine.Count(); i++ ) + { + Msg( "arg %d: %s\n", i, g_WorkerCommandLine[i] ); + } + + VMPI_HandleTimingWait_Worker(); + return true; + } + } + else + { + pConnectSocket->Release(); + Error( "ITCPConnectSocket::Update() errored out" ); + } + + if( wait.ShouldKeepWaiting() ) + Sleep( 100 ); + else + break; + }; + + // Never made a connection, shucks. + pConnectSocket->Release(); + + if ( VMPI_IsParamUsed( mpi_Retry ) ) + { + Msg( "%s found. Retrying connection to %d.%d.%d.%d:%d (attempt %d).\n", VMPI_GetParamString( mpi_Retry ), masterAddr.ip[0], masterAddr.ip[1], masterAddr.ip[2], masterAddr.ip[3], masterAddr.port, nAttempts++ ); + goto Retry; + } + + return false; +} + + +bool SpawnLocalWorker( int argc, char **argv, int iListenPort, bool bShowConsoleWindow ) +{ + char commandLine[4096]; + commandLine[0] = 0; + + // Add the -mpi_worker argument in, then launch the process. + for ( int i=0; i < 9999999; i++ ) + { + char argStr[512]; + + if ( i == 1 ) + { + Q_snprintf( argStr, sizeof( argStr ), "-mpi_worker 127.0.0.1:%d ", iListenPort ); + Q_strncat( commandLine, argStr, sizeof( commandLine ), COPY_ALL_CHARACTERS ); + Q_strncat( commandLine, "-allowdebug ", sizeof( commandLine ), COPY_ALL_CHARACTERS ); + + // Add -mpi_SDKMode if it's needed. This would mostly only occur in a debugging situation + // (someone running out of rel using -mpi_AutoLocalWorker). + if ( VMPI_IsSDKMode() && !VMPI_FindArg( argc, argv, VMPI_GetParamString( mpi_SDKMode ), "" ) ) + { + Q_strncat( commandLine, VMPI_GetParamString( mpi_SDKMode ), sizeof( commandLine ), COPY_ALL_CHARACTERS ); + } + } + + if ( i >= argc ) + break; + + Q_snprintf( argStr, sizeof( argStr ), "\"%s\" ", argv[i] ); + Q_strncat( commandLine, argStr, sizeof( commandLine ), COPY_ALL_CHARACTERS ); + } + + char workingDir[1024]; + if ( !_getcwd( workingDir, sizeof( workingDir ) ) ) + { + Warning( "_getcwd() failed.\n" ); + return false; + } + + STARTUPINFO si; + memset( &si, 0, sizeof( si ) ); + si.cb = sizeof( si ); + + PROCESS_INFORMATION pi; + memset( &pi, 0, sizeof( pi ) ); + + if ( CreateProcess( + NULL, + commandLine, + NULL, // security + NULL, + TRUE, + (bShowConsoleWindow ? CREATE_NEW_CONSOLE : CREATE_NO_WINDOW) | IDLE_PRIORITY_CLASS, // flags + NULL, // environment + workingDir, // current directory (use c:\\ because we don't want it to accidentally share + // DLLs like vstdlib with us). + &si, + &pi ) ) + { + return true; + } + else + { + char errStr[1024]; + IP_GetLastErrorString( errStr, sizeof( errStr ) ); + Warning( " - ERROR in CreateProcess (%s)!\n", errStr ); + return false; + } +} + + +bool InitMaster( int argc, char **argv, const char *pDependencyFilename, VMPIRunMode runMode, bool bPatchMode ) +{ + int nMaxWorkers = -1; + const char *pProcCount = VMPI_FindArg( argc, argv, VMPI_GetParamString( mpi_WorkerCount ) ); + if ( pProcCount ) + { + nMaxWorkers = atoi( pProcCount ); + Warning( "%s: waiting for %d processes to join.\n", VMPI_GetParamString( mpi_WorkerCount ), nMaxWorkers ); + } + else + { + nMaxWorkers = DEFAULT_MAX_WORKERS; + } + nMaxWorkers = clamp( nMaxWorkers, 2, MAX_VMPI_CONNECTIONS ); + + + g_bMPIMaster = true; + g_nMaxWorkerCount = nMaxWorkers; + + if ( argc <= 0 ) + Error( "MPI_Init_Master: argc <= 0!" ); + + ParseOptions( argc, argv ); + + // Send the base filename of the exe we're running. Sometimes if we run vvis followed by vrad + // really quickly, the old vvis workers can connect to the vrad process and mess with it. + VMPI_SendExeName(); + + // In SDK mode, the master sends the command line to the workers since + // the workers weren't given a full command line by vmpi_service. + if ( VMPI_IsSDKMode() ) + { + VMPI_SendCommandLine( argc, argv ); + } + + if ( !g_MasterBroadcaster.Init( argc, argv, pDependencyFilename, nMaxWorkers, runMode, bPatchMode ) ) + return false; + + bool bRet; + if ( runMode == VMPI_RUN_LOCAL ) + { + bRet = SpawnLocalWorker( argc, argv, g_MasterBroadcaster.GetListenPort(), false ); + } + else + { + if ( VMPI_FindArg( argc, argv, VMPI_GetParamString( mpi_AutoLocalWorker ), "" ) ) + { + Msg( "%s found. Spawning a local worker automatically.\n", VMPI_GetParamString( mpi_AutoLocalWorker ) ); + SpawnLocalWorker( 1, argv, g_MasterBroadcaster.GetListenPort(), true ); + } + + bRet = true; + } + + VMPI_HandleTimingWait_Master(); + return bRet; +} + + +void VMPI_InitGlobals( int argc, char **argv, VMPIRunMode runMode ) +{ + g_bUseMPI = true; + g_VMPIRunMode = runMode; + + // Init event objects. + g_VMPIMessagesEvent.Init( false, false ); + g_ErrorSocketsEvent.Init( false, false ); + + // Load this for GetConsoleWindow(). + g_hKernel32DLL = LoadLibrary( "kernel32.dll" ); + if ( g_hKernel32DLL ) + { + g_pConsoleWndFn = (GetConsoleWndFn)GetProcAddress( g_hKernel32DLL, "GetConsoleWindow" ); + } + + #if defined( _DEBUG ) + + for ( int iArg=0; iArg < argc; iArg++ ) + { + Warning( "%s\n", argv[iArg] ); + } + + Warning( "\n" ); + + #endif +} + + +bool VMPI_CheckForNonSDKExecutables() +{ + char baseExeFilename[512]; + if ( !GetModuleFileName( GetModuleHandle( NULL ), baseExeFilename, sizeof( baseExeFilename ) ) ) + Error( "VMPI_CheckSDKMode -> GetModuleFileName failed." ); + + V_StripLastDir( baseExeFilename, sizeof( baseExeFilename ) ); + V_AppendSlash( baseExeFilename, sizeof( baseExeFilename ) ); + V_strncat( baseExeFilename, "mysql_wrapper.dll", sizeof( baseExeFilename ) ); + + // If vmpi_transfer.exe doesn't exist, then we assume we're in SDK mode. + return ( _access( baseExeFilename, 0 ) == 0 ); +} + + +bool IsValidSDKBinPath( CUtlVector< char* > &outStrings, int *pError ) +{ + *pError = 0; + + // Minimum must have drive:/basedir/steamapps/name/sourcesdk/bin/[ep1|orangebox]/bin/exename + if ( outStrings.Count() < 9 ) + { + *pError = 0; + return false; + } + + if ( V_stricmp( outStrings[outStrings.Count()-2], "bin" ) != 0 ) + { + *pError = 1; + return false; + } + + if ( V_stricmp( outStrings[outStrings.Count()-5], "sourcesdk" ) != 0 ) + { + *pError = 2; + return false; + } + + if ( V_stricmp( outStrings[outStrings.Count()-7], "steamapps" ) != 0 ) + { + *pError = 3; + return false; + } + + // Check the last-access date on clientregistry.blob + char baseSteamPath[MAX_PATH]; + V_strncpy( baseSteamPath, outStrings[0], sizeof( baseSteamPath) ); + for ( int i=1; i < outStrings.Count() - 7; i++ ) + { + V_AppendSlash( baseSteamPath, sizeof( baseSteamPath ) ); + V_strncat( baseSteamPath, outStrings[i], sizeof( baseSteamPath ) ); + } + + char blobPath[MAX_PATH]; + V_ComposeFileName( baseSteamPath, "ClientRegistry.blob", blobPath, sizeof( blobPath ) ); + struct _stat results; + if ( _stat( blobPath, &results ) != 0 ) + { + *pError = 4; + return false; + } + + long curTime; + VCRHook_Time( &curTime ); + int nSecondsSinceLastSteamAccess = curTime - results.st_mtime; + int nSecondsPerDay = 60 * 60 * 24; + int nMaxDaysUnaccessed = 10; + if ( nSecondsSinceLastSteamAccess > nSecondsPerDay*nMaxDaysUnaccessed ) + { + *pError = 5; // NOTE: don't change this error code because the outer function checks for it. + return false; + } + + // Check for some of the files under sourcesdk_content. + char sourcesdkContentPath[MAX_PATH]; + V_strncpy( sourcesdkContentPath, outStrings[0], sizeof( sourcesdkContentPath ) ); + for ( int i=1; i < outStrings.Count() - 5; i++ ) + { + V_AppendSlash( sourcesdkContentPath, sizeof( sourcesdkContentPath ) ); + V_strncat( sourcesdkContentPath, outStrings[i], sizeof( sourcesdkContentPath ) ); + } + V_AppendSlash( sourcesdkContentPath, sizeof( sourcesdkContentPath ) ); + V_strncat( sourcesdkContentPath, "sourcesdk_content", sizeof( sourcesdkContentPath ) ); + + char tempFilename[MAX_PATH], mapsrcFilename[MAX_PATH]; + V_snprintf( tempFilename, sizeof( tempFilename ), "cstrike%cmapsrc", CORRECT_PATH_SEPARATOR ); + V_ComposeFileName( sourcesdkContentPath, tempFilename, mapsrcFilename, sizeof( mapsrcFilename ) ); + if ( _access( mapsrcFilename, 0 ) != 0 ) + { + *pError = 6; + return false; + } + + return true; +} + +void VerifyValidSDKMode() +{ + // Make sure we're running out of the SourceSDK directory and that our SDK directories are filled out. + char baseExeFilename[MAX_PATH]; + if ( !GetModuleFileName( GetModuleHandle( NULL ), baseExeFilename, sizeof( baseExeFilename ) ) ) + Error( "VerifyValidSDKMode: GetModuleFileName failed." ); + V_FixSlashes( baseExeFilename ); + + CUtlVector< char* > outStrings; + char strSlash[2] = {CORRECT_PATH_SEPARATOR, 0}; + V_SplitString( baseExeFilename, strSlash, outStrings ); + + int err; + if ( !IsValidSDKBinPath( outStrings, &err ) ) + { + outStrings.PurgeAndDeleteElements(); + + if ( err == 5 ) + Error( "VMPI running in SDK mode but Steam hasn't been run recently. Please run Steam and retry." ); + else + Error( "VMPI running in SDK mode but incorrect SDK install detected (error %d).", err ); + } +} + +void VMPI_CheckSDKMode( int argc, char **argv ) +{ + g_bVMPISDKMode = !VMPI_CheckForNonSDKExecutables(); + g_bVMPISDKModeSet = true; + + // Also check for -mpi_sdkmode (only used in testing). + if ( !g_bVMPISDKMode ) + { + if ( VMPI_FindArg( argc, argv, VMPI_GetParamString( mpi_SDKMode ), "" ) ) + g_bVMPISDKMode = true; + } + + if ( g_bVMPISDKMode ) + { + VerifyValidSDKMode(); + } + + if ( g_bVMPISDKMode ) + { + Msg( "VMPI running in SDK mode.\n" ); + } +} + + +void VMPI_SetupAutoRestartParameters( int argc, char **argv ) +{ + if ( VMPI_FindArg( argc, argv, VMPI_GetParamString( mpi_AutoRestart ) ) ) + { + g_OriginalCommandLineParameters.SetSize( argc ); + for ( int i=0; i < argc; i++ ) + { + g_OriginalCommandLineParameters[i] = CopyString( argv[i] ); + } + } +} + + +bool VMPI_HandleAutoRestart() +{ + if ( g_OriginalCommandLineParameters.Count() == 0 ) + return true; + + Msg( "%s found. Auto-restarting.\n", VMPI_GetParamString( mpi_AutoRestart ) ); + DWORD curPriority = GetPriorityClass( GetCurrentProcess() ); + + char commandLine[1024*8]; + commandLine[0] = 0; + + // Add the -mpi_worker argument in, then launch the process. + for ( int i=0; i < g_OriginalCommandLineParameters.Count(); i++ ) + { + char argStr[512]; + Q_snprintf( argStr, sizeof( argStr ), "\"%s\" ", g_OriginalCommandLineParameters[i] ); + Q_strncat( commandLine, argStr, sizeof( commandLine ), COPY_ALL_CHARACTERS ); + } + + STARTUPINFO si; + memset( &si, 0, sizeof( si ) ); + si.cb = sizeof( si ); + + PROCESS_INFORMATION pi; + memset( &pi, 0, sizeof( pi ) ); + + if ( CreateProcess( + NULL, + commandLine, + NULL, // security + NULL, + TRUE, + CREATE_NEW_CONSOLE | curPriority, // flags + NULL, // environment + NULL, + &si, + &pi ) ) + { + g_OriginalCommandLineParameters.Purge(); + return true; + } + else + { + char errStr[1024]; + IP_GetLastErrorString( errStr, sizeof( errStr ) ); + Warning( " - ERROR in CreateProcess (%s)!\n", errStr ); + return false; + } +} + + +bool VMPI_Init( + int &argc, + char **&argv, + const char *pDependencyFilename, + VMPI_Disconnect_Handler handler, + VMPIRunMode runMode, + bool bConnectingAsService + ) +{ + if ( handler ) + VMPI_AddDisconnectHandler( handler ); + + VMPI_SetupAutoRestartParameters( argc, argv ); + + VMPI_CheckSDKMode( argc, argv ); + VMPI_InitGlobals( argc, argv, runMode ); + + // Were we launched by the vmpi service as a worker? + const char *pMasterIP = VMPI_FindArg( argc, argv, VMPI_GetParamString( mpi_Worker ), NULL ); + if ( pMasterIP ) + { + CIPAddr addr; + addr.port = VMPI_MASTER_FIRST_PORT; + if ( !ConvertStringToIPAddr( pMasterIP, &addr ) ) + Error( "Unable to parse or resolve master IP (%s).\n", pMasterIP ); + + return MPI_Init_Worker( argc, argv, addr, bConnectingAsService ); + } + else + { + if ( !pDependencyFilename ) + { + Error( "VMPI started as master, but no dependency filename specified.\n" ); + return false; + } + + return InitMaster( argc, argv, pDependencyFilename, runMode, false ); + } +} + + +void VMPI_Init_PatchMaster( int argc, char **argv ) +{ + const char *pPatchDirectory = VMPI_FindArg( argc, argv, "-mpi_PatchDirectory", NULL ); + if ( !pPatchDirectory ) + Error( "-mpi_PatchDirectory <dir> must be specified if using -PatchHost mode." ); + + VMPI_InitGlobals( argc, argv, VMPI_RUN_NETWORKED ); + + InitMaster( argc, argv, pPatchDirectory, VMPI_RUN_NETWORKED, true ); +} + + +void VMPI_Finalize() +{ + g_MasterBroadcaster.Term(); + + DistributeWork_Cancel(); + + // Get rid of all the sockets. + for ( int iConn=0; iConn < g_nConnections; iConn++ ) + delete g_Connections[iConn]; + + g_nConnections = 0; + + // Get rid of all the packets. + FOR_EACH_LL( g_VMPIMessages, i ) + { + g_VMPIMessages[i]->Release(); + } + g_VMPIMessages.Purge(); + + g_PersistentPackets.PurgeAndDeleteElements(); + + // Get rid of the message buffers + g_DispatchBuffers.Purge(); + + if ( g_hKernel32DLL ) + { + FreeLibrary( g_hKernel32DLL ); + g_hKernel32DLL = NULL; + } + + g_WorkerCommandLine.PurgeAndDeleteElements(); + + VMPI_HandleAutoRestart(); +} + + +VMPIRunMode VMPI_GetRunMode() +{ + return g_VMPIRunMode; +} + + +VMPIFileSystemMode VMPI_GetFileSystemMode() +{ + return g_VMPIFileSystemMode; +} + + +int VMPI_GetCurrentNumberOfConnections() +{ + return g_nConnections; +} + + +void InternalHandleSocketErrors() +{ + // Copy the list of sockets with errors into a local array so we can handle all the errors outside + // the mutex, thus avoiding potential deadlock if any error handlers call Error(). + CUtlVector<CVMPIConnection*> errorSockets; + + CCriticalSectionLock csLock( &g_ErrorSocketsCS ); + csLock.Lock(); + + errorSockets.SetSize( g_ErrorSockets.Count() ); + int iCur = 0; + FOR_EACH_LL( g_ErrorSockets, i ) + { + errorSockets[iCur++] = g_ErrorSockets[i]; + } + + g_ErrorSockets.Purge(); + + csLock.Unlock(); + + // Handle the errors. + for ( int i=0; i < errorSockets.Count(); i++ ) + { + errorSockets[i]->HandleDisconnect(); + } + + UpdateActiveConnectionsText(); +} + + +void VMPI_HandleSocketErrors( unsigned long timeout ) +{ + DWORD ret = WaitForSingleObject( g_ErrorSocketsEvent.GetEventHandle(), timeout ); + if ( ret == WAIT_OBJECT_0 ) + { + InternalHandleSocketErrors(); + } +} + + +// If bWait is false, then this function returns false immediately if there are no messages waiting. +bool VMPI_GetNextMessage( MessageBuffer *pBuf, int *pSource, unsigned long startTimeout ) +{ + HANDLE handles[2] = { g_ErrorSocketsEvent.GetEventHandle(), g_VMPIMessagesEvent.GetEventHandle() }; + + DWORD startTime = Plat_MSTime(); + DWORD timeout = startTimeout; + + while ( 1 ) + { + DWORD ret = WaitForMultipleObjects( ARRAYSIZE( handles ), handles, FALSE, timeout ); + if ( ret == WAIT_TIMEOUT ) + { + return false; + } + else if ( ret == WAIT_OBJECT_0 ) + { + // A socket had an error. Handle all socket errors. + InternalHandleSocketErrors(); + + // Update the timeout. + DWORD delta = Plat_MSTime() - startTime; + if ( delta >= startTimeout ) + return false; + + timeout = startTimeout - delta; + continue; + } + else if ( ret == (WAIT_OBJECT_0 + 1) ) + { + // Read out the next message. + CCriticalSectionLock csLock( &g_VMPIMessagesCS ); + csLock.Lock(); + +GrabNextMessage:; + int iHead = g_VMPIMessages.Head(); + CTCPPacket *pPacket = g_VMPIMessages[iHead]; + g_VMPIMessages.Remove( iHead ); + + // Set the event again if there are more messages waiting. + const char *pBase = pPacket->GetData(); + if ( pPacket->GetLen() >= 6 && (unsigned char)pBase[0] == VMPI_INTERNAL_PACKET_ID && (unsigned char)pBase[1] == VMPI_INTERNAL_SUBPACKET_GROUPED_PACKET ) + { + // Ok, this is a grouped packet. Split it out into a bunch of separate packets. + CUtlVector<CTCPPacket*> groupedPackets; + int iCurOffset = 2; + while ( (iCurOffset+4) <= pPacket->GetLen() ) + { + int curPacketLen = *((int*)&pBase[iCurOffset]); + if ( iCurOffset + curPacketLen > pPacket->GetLen() ) + Error( "Invalid chunked packet\n" ); + + iCurOffset += 4; + + CTCPPacket *pChunkPacket = (CTCPPacket*)malloc( sizeof( CTCPPacket ) + curPacketLen - 1 ); + pChunkPacket->m_Len = curPacketLen; + pChunkPacket->m_UserData = pPacket->m_UserData; + memcpy( pChunkPacket->m_Data, &pBase[iCurOffset], curPacketLen ); + groupedPackets.AddToTail( pChunkPacket ); + + iCurOffset += curPacketLen; + } + + for ( int i=0; i < groupedPackets.Count(); i++ ) + { + g_VMPIMessages.AddToHead( groupedPackets[groupedPackets.Count() - i - 1] ); + } + pPacket->Release(); + goto GrabNextMessage; + } + else + { + if ( g_VMPIMessages.Count() > 0 ) + g_VMPIMessagesEvent.SetEvent(); + } + + csLock.Unlock(); + + // Copy it into their message buffer. + pBuf->setLen( pPacket->GetLen() ); + memcpy( pBuf->data, pPacket->GetData(), pPacket->GetLen() ); + + *pSource = pPacket->GetUserData(); + Assert( *pSource >= 0 && *pSource < g_nConnections ); + + // Update global stats about how much data we've received. + ++g_nMessagesReceived; + g_nBytesReceived += pPacket->GetLen() + 4; // (4 bytes extra for the packet length) + + // Free the memory associated with the packet. + pPacket->Release(); + return true; + } + else + { + Error( "VMPI_GetNextMessage: WaitForSingleObject returned %lu", ret ); + return false; + } + } +} + + +bool VMPI_InternalDispatch( MessageBuffer *pBuf, int iSource ) +{ + if ( pBuf->getLen() >= 1 && + pBuf->data[0] >= 0 && pBuf->data[0] < MAX_VMPI_PACKET_IDS && + g_VMPIDispatch[pBuf->data[0]] ) + { + return g_VMPIDispatch[ pBuf->data[0] ]( pBuf, iSource, pBuf->data[0] ); + + } + else + { + return false; + } +} + +bool VMPI_DispatchNextMessage( unsigned long timeout ) +{ + MessageBuffer *pBuf = NULL; + if ( !g_DispatchBuffers.PopItem( &pBuf ) ) + { + pBuf = new MessageBuffer(); + } + + bool bRetval = true; + while ( 1 ) + { + int iSource; + if ( VMPI_GetNextMessage( pBuf, &iSource, timeout ) ) + { + if ( VMPI_InternalDispatch( pBuf, iSource ) ) + { + break; + } + else + { + // Workers running in service mode don't hook anything except filesystem stuff, so if they happen to be sent something, no problem. + if ( !VMPI_IsProcAService( iSource ) ) + { + // Oops! What is this packet? + Assert( false ); + } + } + } + else + { + bRetval = false; + break; + } + } + + g_DispatchBuffers.PushItem( pBuf ); + return bRetval; +} + + +bool VMPI_DispatchUntil( MessageBuffer *pBuf, int *pSource, int packetID, int subPacketID, bool bWait ) +{ + while ( 1 ) + { + if ( !VMPI_GetNextMessage( pBuf, pSource, bWait ? VMPI_TIMEOUT_INFINITE : 0 ) ) + return false; + + if ( !VMPI_InternalDispatch( pBuf, *pSource ) ) + { + if ( pBuf->getLen() >= 1 && (unsigned char)pBuf->data[0] == packetID ) + { + if ( subPacketID == -1 ) + return true; + + if ( pBuf->getLen() >= 2 && (unsigned char)pBuf->data[1] == subPacketID ) + return true; + } + + // Oops! What is this packet? + // Note: the most common case where this happens is if it finishes a BuildFaceLights run + // and is in an AppBarrier and one of the workers is still finishing up some work given to it. + // It'll be waiting for a barrier packet, and it'll get results. In that case, the packet should + // be discarded like we do here, so maybe this assert won't be necessary. + //Assert( false ); + } + } +} + + +bool VMPI_SendData( void *pData, int nBytes, int iDest, int fVMPISendFlags ) +{ + return VMPI_SendChunks( &pData, &nBytes, 1, iDest, fVMPISendFlags ); +} + + +inline bool VMPI_FilterPacketsForServiceDownloader( CVMPIConnection *pConnection, void const * const *pChunks, const int *pChunkLengths, int nChunks ) +{ + if ( pConnection->m_bIsAService ) + { + // Find the first byte and treat that as the packet ID. + for ( int i=0; i < nChunks; i++ ) + { + if ( pChunkLengths[i] > 0 ) + { + unsigned char cPacketID = *((unsigned char*)pChunks[i]); + if ( cPacketID == VMPI_INTERNAL_PACKET_ID || cPacketID == VMPI_SHARED_PACKET_ID || cPacketID == VMPI_PACKETID_FILESYSTEM ) + return false; + else + return true; + } + } + } + return false; +} + + +void VMPI_GroupPackets( CVMPIConnection *pConn, void const * const *pChunks, const int *pChunkLengths, int nChunks ) +{ + CCriticalSectionLock connectionsLock( &g_ConnectionsCS ); + connectionsLock.Lock(); + + // First add the header. + if ( pConn->m_GroupedChunks.Count() == 0 ) + { + pConn->m_GroupedChunks.AddToTail( g_GroupedPacketHeader ); + pConn->m_GroupedChunkLengths.AddToTail( sizeof( g_GroupedPacketHeader ) ); + } + + // Collate the chunks. + int nTotalLength = 0; + for ( int i=0; i < nChunks; i++ ) + nTotalLength += pChunkLengths[i]; + + char *pOut = new char[nTotalLength + 4]; + *((int*)pOut) = nTotalLength; + int iOutByte = 4; + for ( int i=0; i < nChunks; i++ ) + { + memcpy( &pOut[iOutByte], pChunks[i], pChunkLengths[i] ); + iOutByte += pChunkLengths[i]; + } + + pConn->m_GroupedChunks.AddToTail( pOut ); + pConn->m_GroupedChunkLengths.AddToTail( nTotalLength + 4 ); +} + + +void VMPI_FlushGroupedPackets( unsigned long msInterval ) +{ + if ( msInterval != 0 ) + { + unsigned long curTime = Plat_MSTime(); + if ( curTime - g_LastFlushGroupedPacketsTime < msInterval ) + return; + g_LastFlushGroupedPacketsTime = curTime; + } + + CCriticalSectionLock connectionsLock( &g_ConnectionsCS ); + connectionsLock.Lock(); + + for ( int i=0; i < g_nConnections; i++ ) + { + CVMPIConnection *pConn = g_Connections[i]; + + if ( !pConn ) + continue; + + IThreadedTCPSocket *pSocket = pConn->GetSocket(); + if ( !pSocket || pConn->m_GroupedChunks.Count() == 0 ) + continue; + + pSocket->SendChunks( pConn->m_GroupedChunks.Base(), pConn->m_GroupedChunkLengths.Base(), pConn->m_GroupedChunks.Count() ); + + // Free the chunks. + for ( int i=1; i < pConn->m_GroupedChunks.Count(); i++ ) + { + free( pConn->m_GroupedChunks[i] ); + } + pConn->m_GroupedChunks.RemoveAll(); + pConn->m_GroupedChunkLengths.RemoveAll(); + } +} + + +bool VMPI_SendChunks( void const * const *pChunks, const int *pChunkLengths, int nChunks, int iDest, int fVMPISendFlags ) +{ + if ( iDest == VMPI_SEND_TO_ALL ) + { + // Don't want new connections while in here! + CCriticalSectionLock connectionsLock( &g_ConnectionsCS ); + connectionsLock.Lock(); + + for ( int i=0; i < g_nConnections; i++ ) + VMPI_SendChunks( pChunks, pChunkLengths, nChunks, i ); + + return true; + } + else if ( iDest == VMPI_PERSISTENT ) + { + // Don't want new connections while in here! + CCriticalSectionLock connectionsLock( &g_ConnectionsCS ); + connectionsLock.Lock(); + + CCriticalSectionLock csLock( &g_PersistentPacketsCS ); + csLock.Lock(); + + // Send the packet to everyone. + for ( int i=0; i < g_nConnections; i++ ) + VMPI_SendChunks( pChunks, pChunkLengths, nChunks, i ); + + // Remember to send it to the new workers. + if ( iDest == VMPI_PERSISTENT ) + { + PersistentPacket *pNew = new PersistentPacket; + for ( int i=0; i < nChunks; i++ ) + pNew->AddMultipleToTail( pChunkLengths[i], (const char*)pChunks[i] ); + + g_PersistentPackets.AddToTail( pNew ); + } + + return true; + } + else + { + g_nMessagesSent++; + g_nBytesSent += 4; // for message tag. + for ( int i=0; i < nChunks; i++ ) + g_nBytesSent += pChunkLengths[i]; + + CVMPIConnection *pConnection = g_Connections[iDest]; + + if ( pConnection ) + { + // If it's a service downloader, only send certain packet IDs. + if ( VMPI_FilterPacketsForServiceDownloader( pConnection, pChunks, pChunkLengths, nChunks ) ) + return true; + + IThreadedTCPSocket *pSocket = pConnection->GetSocket(); + if ( !pSocket ) + return false; + + if ( g_bGroupPackets && (fVMPISendFlags & k_eVMPISendFlags_GroupPackets) ) + { + VMPI_GroupPackets( pConnection, pChunks, pChunkLengths, nChunks ); + return true; + } + else + { + return pSocket->SendChunks( pChunks, pChunkLengths, nChunks ); + } + } + else + { + return false; + } + } +} + + +bool VMPI_Send2Chunks( const void *pChunk1, int chunk1Len, const void *pChunk2, int chunk2Len, int iDest, int fVMPISendFlags ) +{ + const void *pChunks[2] = { pChunk1, pChunk2 }; + int len[2] = { chunk1Len, chunk2Len }; + return VMPI_SendChunks( pChunks, len, ARRAYSIZE( pChunks ), iDest, fVMPISendFlags ); +} + + +bool VMPI_Send3Chunks( const void *pChunk1, int chunk1Len, const void *pChunk2, int chunk2Len, const void *pChunk3, int chunk3Len, int iDest, int fVMPISendFlags ) +{ + const void *pChunks[3] = { pChunk1, pChunk2, pChunk3 }; + int len[3] = { chunk1Len, chunk2Len, chunk3Len }; + return VMPI_SendChunks( pChunks, len, ARRAYSIZE( pChunks ), iDest, fVMPISendFlags ); +} + + +void VMPI_AddDisconnectHandler( VMPI_Disconnect_Handler handler ) +{ + g_DisconnectHandlers.AddToTail( handler ); +} + + +CVMPIConnection* GetConnection( int procID ) +{ + Assert( procID >= 0 && procID < g_nConnections ); + return g_Connections[procID]; +} + + +bool VMPI_IsProcConnected( int procID ) +{ + if ( procID < 0 || procID >= g_nConnections ) + { + Assert( false ); + return false; + } + + return g_Connections[procID]->GetSocket() != NULL; +} + +bool VMPI_IsProcAService( int procID ) +{ + if ( procID < 0 || procID >= g_nConnections ) + { + Assert( false ); + return false; + } + + return g_Connections[procID]->m_bIsAService; +} + +void VMPI_Sleep( unsigned long ms ) +{ + Sleep( ms ); +} + + +const char* VMPI_GetMachineName( int iProc ) +{ + if ( g_bMPIMaster && iProc == VMPI_MASTER_ID ) + return VMPI_GetLocalMachineName(); + + if ( iProc < 0 || iProc >= g_nConnections ) + { + Assert( false ); + return "invalid index"; + } + + return g_Connections[iProc]->GetMachineName(); +} + + +void VMPI_SetMachineName( int iProc, const char *pName ) +{ + if ( iProc < 0 || iProc >= g_nConnections ) + { + Assert( false ); + return; + } + + g_Connections[iProc]->SetMachineName( pName ); +} + + +bool VMPI_HasMachineNameBeenSet( int iProc ) +{ + if ( iProc < 0 || iProc >= g_nConnections ) + { + Assert( false ); + return false; + } + + return g_Connections[iProc]->HasMachineNameBeenSet(); +} + + +const char* VMPI_GetLocalMachineName() +{ + static char cName[MAX_COMPUTERNAME_LENGTH+1]; + DWORD len = sizeof( cName ); + if ( GetComputerName( cName, &len ) ) + return cName; + else + return "(error in GetComputerName)"; +} + + +unsigned long VMPI_GetJobWorkerID( int iProc ) +{ + return GetConnection( iProc )->m_JobWorkerID; +} + + +void VMPI_SetJobWorkerID( int iProc, unsigned long jobWorkerID ) +{ + GetConnection( iProc )->m_JobWorkerID = jobWorkerID; +} + + +void VMPI_GetCurrentStage( char *pOut, int strLen ) +{ + CCriticalSectionLock csLock( &g_CurrentStageCS ); + csLock.Lock(); + Q_strncpy( pOut, g_CurrentStageString, strLen ); +} + + +void VMPI_SetCurrentStage( const char *pCurStage ) +{ + CCriticalSectionLock csLock( &g_CurrentStageCS ); + csLock.Lock(); + Q_strncpy( g_CurrentStageString, pCurStage, sizeof( g_CurrentStageString ) ); +} + + +void VMPI_InviteDebugWorkers() +{ + // Only allow workers with password set to debugworker. + g_MasterBroadcaster.SetPassword( "debugworker" ); + + // Disable timeouts so they can sit in the debugger. + g_MasterBroadcaster.SetNoTimeoutOption(); + ThreadedTCP_EnableTimeouts( false ); + + // Let in some more workers. + g_MasterBroadcaster.IncreaseMaxWorkers( 25 ); +} + + +bool VMPI_IsSDKMode() +{ + if ( g_bVMPISDKModeSet ) + return g_bVMPISDKMode; + else + return !VMPI_CheckForNonSDKExecutables(); +} + + +const char* VMPI_GetParamString( EVMPICmdLineParam eParam ) +{ + if ( eParam <= k_eVMPICmdLineParam_FirstParam || eParam >= k_eVMPICmdLineParam_LastParam ) + { + Assert( false ); + Warning( "Invalid call: VMPI_GetParamString( %d )\n", eParam ); + return "unknown"; + } + else + { + return g_VMPIParams[eParam].m_pName; + } +} + +int VMPI_GetParamFlags( EVMPICmdLineParam eParam ) +{ + if ( eParam <= k_eVMPICmdLineParam_FirstParam || eParam >= k_eVMPICmdLineParam_LastParam ) + { + Assert( false ); + Warning( "Invalid call: VMPI_GetParamString( %d )\n", eParam ); + return 0; + } + else + { + return g_VMPIParams[eParam].m_ParamFlags; + } +} + +bool VMPI_IsParamUsed( EVMPICmdLineParam eParam ) +{ + int iParam = CommandLine()->FindParm( VMPI_GetParamString( eParam ) ); + return iParam != 0; +} + +const char* VMPI_GetParamHelpString( EVMPICmdLineParam eParam ) +{ + if ( eParam <= k_eVMPICmdLineParam_FirstParam || eParam >= k_eVMPICmdLineParam_LastParam ) + { + Assert( false ); + Warning( "Invalid call: VMPI_GetParamHelpString( %d )\n", eParam ); + return "unknown vmpi param"; + } + else + { + return g_VMPIParams[eParam].m_pHelpText; + } +} + + diff --git a/utils/vmpi/vmpi.h b/utils/vmpi/vmpi.h new file mode 100644 index 0000000..cb7316f --- /dev/null +++ b/utils/vmpi/vmpi.h @@ -0,0 +1,217 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#ifndef VMPI_H +#define VMPI_H +#ifdef _WIN32 +#pragma once +#endif + + +#include "vmpi_defs.h" +#include "messbuf.h" +#include "iphelpers.h" + + +// These are called to handle incoming messages. +// Return true if you handled the message and false otherwise. +// Note: the first byte in each message is the packet ID. +typedef bool (*VMPIDispatchFn)( MessageBuffer *pBuf, int iSource, int iPacketID ); + +typedef void (*VMPI_Disconnect_Handler)( int procID, const char *pReason ); + + +// Which machine is the master. +#define VMPI_MASTER_ID 0 + +#define VMPI_SEND_TO_ALL -2 +#define VMPI_PERSISTENT -3 // If this is set as the destination for a packet, it is sent to all + // workers, and also to new workers that connect. + +#define MAX_VMPI_PACKET_IDS 32 + + +#define VMPI_TIMEOUT_INFINITE 0xFFFFFFFF + + +// Instantiate one of these to register a dispatch. +class CDispatchReg +{ +public: + CDispatchReg( int iPacketID, VMPIDispatchFn fn ); +}; + + +// Enums for all the command line parameters. +#define VMPI_PARAM_SDK_HIDDEN 0x0001 // Hidden in SDK mode. + +#define VMPI_PARAM( paramName, paramFlags, helpText ) paramName, +enum EVMPICmdLineParam +{ + k_eVMPICmdLineParam_FirstParam=0, + k_eVMPICmdLineParam_VMPIParam, + #include "vmpi_parameters.h" + k_eVMPICmdLineParam_LastParam +}; +#undef VMPI_PARAM + + +// Shared by all the tools. +extern bool g_bUseMPI; +extern bool g_bMPIMaster; // Set to true if we're the master in a VMPI session. +extern int g_iVMPIVerboseLevel; // Higher numbers make it spit out more data. + +extern bool g_bMPI_Stats; // Send stats to the MySQL database? +extern bool g_bMPI_StatsTextOutput; // Send text output in the stats? + +// These can be watched or modified to check bandwidth statistics. +extern int g_nBytesSent; +extern int g_nMessagesSent; +extern int g_nBytesReceived; +extern int g_nMessagesReceived; + +extern int g_nMulticastBytesSent; +extern int g_nMulticastBytesReceived; + +extern int g_nMaxWorkerCount; + + +enum VMPIRunMode +{ + VMPI_RUN_NETWORKED, + VMPI_RUN_LOCAL // Just make a local process and have it do the work. +}; + + +enum VMPIFileSystemMode +{ + VMPI_FILESYSTEM_MULTICAST, // Multicast out, find workers, have them do work. + VMPI_FILESYSTEM_BROADCAST, // Broadcast out, find workers, have them do work. + VMPI_FILESYSTEM_TCP // TCP filesystem. +}; + + +// If this precedes the dependency filename, then it will transfer all the files in the specified directory. +#define VMPI_DEPENDENCY_DIRECTORY_TOKEN '*' + + +// It's good to specify a disconnect handler here immediately. If you don't have a handler +// and the master disconnects, you'll lockup forever inside a dispatch loop because you +// never handled the master disconnecting. +// +// Note: runMode is only relevant for the VMPI master. The worker always connects to the master +// the same way. +bool VMPI_Init( + int &argc, + char **&argv, + const char *pDependencyFilename, + VMPI_Disconnect_Handler handler = NULL, + VMPIRunMode runMode = VMPI_RUN_NETWORKED, // Networked or local?, + bool bConnectingAsService = false + ); + +// Used when hosting a patch. +void VMPI_Init_PatchMaster( int argc, char **argv ); + +void VMPI_Finalize(); + +VMPIRunMode VMPI_GetRunMode(); +VMPIFileSystemMode VMPI_GetFileSystemMode(); + +// Note: this number can change on the master. +int VMPI_GetCurrentNumberOfConnections(); + + +// Dispatch messages until it gets one with the specified packet ID. +// If subPacketID is not set to -1, then the second byte must match that as well. +// +// Note: this WILL dispatch packets with matching packet IDs and give them a chance to handle packets first. +// +// If bWait is true, then this function either succeeds or Error() is called. If it's false, then if the first available message +// is handled by a dispatch, this function returns false. +bool VMPI_DispatchUntil( MessageBuffer *pBuf, int *pSource, int packetID, int subPacketID = -1, bool bWait = true ); + +// This waits for the next message and dispatches it. +// You can specify a timeout in milliseconds. If the timeout expires, the function returns false. +bool VMPI_DispatchNextMessage( unsigned long timeout=VMPI_TIMEOUT_INFINITE ); + +// This should be called periodically in modal loops that don't call other VMPI functions. This will +// check for disconnected sockets and call disconnect handlers so the app can error out if +// it loses all of its connections. +// +// This can be used in place of a Sleep() call by specifying a timeout value. +void VMPI_HandleSocketErrors( unsigned long timeout=0 ); + + + +enum VMPISendFlags +{ + k_eVMPISendFlags_GroupPackets = 0x0001 +}; + +// Use these to send data to one of the machines. +// If iDest is VMPI_SEND_TO_ALL, then the message goes to all the machines. +// Flags is a combination of the VMPISendFlags enums. +bool VMPI_SendData( void *pData, int nBytes, int iDest, int fVMPISendFlags=0 ); +bool VMPI_SendChunks( void const * const *pChunks, const int *pChunkLengths, int nChunks, int iDest, int fVMPISendFlags=0 ); +bool VMPI_Send2Chunks( const void *pChunk1, int chunk1Len, const void *pChunk2, int chunk2Len, int iDest, int fVMPISendFlags=0 ); // for convenience.. +bool VMPI_Send3Chunks( const void *pChunk1, int chunk1Len, const void *pChunk2, int chunk2Len, const void *pChunk3, int chunk3Len, int iDest, int fVMPISendFlags=0 ); + +// Flush any groups that were queued with k_eVMPISendFlags_GroupPackets. +// If msInterval is > 0, then it will check a timer and only flush that often (so you can call this a lot, and have it check). +void VMPI_FlushGroupedPackets( unsigned long msInterval=0 ); + +// This registers a function that gets called when a connection is terminated ungracefully. +void VMPI_AddDisconnectHandler( VMPI_Disconnect_Handler handler ); + +// Returns false if the process has disconnected ungracefully (disconnect handlers +// would have been called for it too). +bool VMPI_IsProcConnected( int procID ); + +// Returns true if the process is just a service (in which case it should only get file IO traffic). +bool VMPI_IsProcAService( int procID ); + +// Simple wrapper for Sleep() so people can avoid including windows.h +void VMPI_Sleep( unsigned long ms ); + +// VMPI sends machine names around first thing. +const char* VMPI_GetLocalMachineName(); +const char* VMPI_GetMachineName( int iProc ); +bool VMPI_HasMachineNameBeenSet( int iProc ); + +// Returns 0xFFFFFFFF if the ID hasn't been set. +unsigned long VMPI_GetJobWorkerID( int iProc ); +void VMPI_SetJobWorkerID( int iProc, unsigned long jobWorkerID ); + +// Search a command line to find arguments. Looks for pName, and if it finds it, returns the +// argument following it. If pName is the last argument, it returns pDefault. If it doesn't +// find pName, returns NULL. +const char* VMPI_FindArg( int argc, char **argv, const char *pName, const char *pDefault = "" ); + +// (Threadsafe) get and set the current stage. This info winds up in the VMPI database. +void VMPI_GetCurrentStage( char *pOut, int strLen ); +void VMPI_SetCurrentStage( const char *pCurStage ); + +// VMPI is always broadcasting this job in the background. +// This changes the password to 'debugworker' and allows more workers in. +// This can be used if workers are dying on certain work units. Then a programmer +// can run vmpi_service with -superdebug and debug the whole thing. +void VMPI_InviteDebugWorkers(); + +bool VMPI_IsSDKMode(); + +// Lookup a command line parameter string. +const char* VMPI_GetParamString( EVMPICmdLineParam eParam ); +int VMPI_GetParamFlags( EVMPICmdLineParam eParam ); +const char* VMPI_GetParamHelpString( EVMPICmdLineParam eParam ); +bool VMPI_IsParamUsed( EVMPICmdLineParam eParam ); // Returns true if the specified parameter is on the command line. + +// Can be called from error handlers and if -mpi_Restart is used, it'll automatically restart the process. +bool VMPI_HandleAutoRestart(); + + +#endif // VMPI_H diff --git a/utils/vmpi/vmpi.vpc b/utils/vmpi/vmpi.vpc new file mode 100644 index 0000000..2d8fcd5 --- /dev/null +++ b/utils/vmpi/vmpi.vpc @@ -0,0 +1,62 @@ +//----------------------------------------------------------------------------- +// VMPI.VPC +// +// Project Script +//----------------------------------------------------------------------------- + +$Macro SRCDIR "..\.." +$Include "$SRCDIR\vpc_scripts\source_lib_base.vpc" + +$Configuration +{ + $Compiler + { + $AdditionalIncludeDirectories "$BASE,..\common,zlib,.\" + $PreprocessorDefinitions "$BASE;PROTECTED_THINGS_DISABLE;MPI" + } +} + +$Project "Vmpi" +{ + $Folder "Source Files" + { + $File "$SRCDIR\public\filesystem_init.cpp" + $File "..\common\filesystem_tools.cpp" + $File "iphelpers.cpp" + $File "loopback_channel.cpp" + $File "messbuf.cpp" + $File "ThreadedTCPSocket.cpp" + $File "ThreadedTCPSocketEmu.cpp" + $File "threadhelpers.cpp" + $File "vmpi.cpp" + $File "vmpi_distribute_tracker.cpp" + $File "vmpi_distribute_work.cpp" + $File "vmpi_distribute_work_sdk.cpp" + $File "vmpi_distribute_work_default.cpp" + $File "vmpi_filesystem.cpp" + $File "vmpi_filesystem_internal.h" + $File "vmpi_filesystem_master.cpp" + $File "vmpi_filesystem_worker.cpp" + } + + $Folder "Header Files" + { + $File "$SRCDIR\public\tier1\bitbuf.h" + $File "ichannel.h" + $File "iphelpers.h" + $File "IThreadedTCPSocket.h" + $File "loopback_channel.h" + $File "messbuf.h" + $File "tcpsocket.h" + $File "ThreadedTCPSocketEmu.h" + $File "threadhelpers.h" + $File "vmpi.h" + $File "vmpi_defs.h" + $File "vmpi_filesystem.h" + } + + $Folder "Link Libraries" + { + $File "ZLib.lib" + } +} diff --git a/utils/vmpi/vmpi_browser_helpers.cpp b/utils/vmpi/vmpi_browser_helpers.cpp new file mode 100644 index 0000000..fed826f --- /dev/null +++ b/utils/vmpi/vmpi_browser_helpers.cpp @@ -0,0 +1,43 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#include "tier1/strtools.h" +#include "vmpi_browser_helpers.h" + + + +void FormatTimeString( unsigned long nInputSeconds, char *timeStr, int outLen ) +{ + // Make a string to say how long the thing has been running. + unsigned long minutes = nInputSeconds / 60; + unsigned long nSeconds = nInputSeconds - minutes * 60; + + unsigned long hours = minutes / 60; + minutes -= hours * 60; + + unsigned long days = hours / 24; + hours -= days * 24; + + if ( days && hours ) + { + Q_snprintf( timeStr, outLen, "%dd %dh %dm", days, hours, minutes ); + } + else if ( hours ) + { + Q_snprintf( timeStr, outLen, "%dh %dm", hours, minutes ); + } + else if ( minutes ) + { + Q_snprintf( timeStr, outLen, "%dm %ds", minutes, nSeconds ); + } + else + { + Q_snprintf( timeStr, outLen, "%d seconds", nSeconds ); + } +} + + diff --git a/utils/vmpi/vmpi_browser_helpers.h b/utils/vmpi/vmpi_browser_helpers.h new file mode 100644 index 0000000..ecc0daa --- /dev/null +++ b/utils/vmpi/vmpi_browser_helpers.h @@ -0,0 +1,18 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#ifndef VMPI_BROWSER_HELPERS_H +#define VMPI_BROWSER_HELPERS_H +#ifdef _WIN32 +#pragma once +#endif + + +void FormatTimeString( unsigned long nSeconds, char *pOut, int outLen ); + + +#endif // VMPI_BROWSER_HELPERS_H diff --git a/utils/vmpi/vmpi_defs.h b/utils/vmpi/vmpi_defs.h new file mode 100644 index 0000000..7d65508 --- /dev/null +++ b/utils/vmpi/vmpi_defs.h @@ -0,0 +1,147 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#ifndef VMPI_DEFS_H +#define VMPI_DEFS_H +#ifdef _WIN32 +#pragma once +#endif + + +// This goes in front of all packets. +#define VMPI_PROTOCOL_VERSION 5 + +// This represents the protocol between the service and its UI. +#define VMPI_SERVICE_UI_PROTOCOL_VERSION 1 + +// NOTE: the service version (embedded in vmpi_service.exe as a resource) is the version +// that is used to apply patches. +#define VMPI_SERVICE_IDS_VERSION_STRING 102 // This matches IDS_VERSION_STRING in vmpi_service.exe. + +// Known packet IDs in various systems. +#define VMPI_PACKETID_FILESYSTEM 0 // The file system reserves this packet ID. + // All application traffic must set its first byte to something other + // than this value. +#define VMPI_SHARED_PACKET_ID 10 + + +// Turn this on, and the various service apps will log stuff. +//#define VMPI_SERVICE_LOGS + + +// This value is put in the RunningTimeMS until the job is finished. This is how +// the job_search app knows if a job never finished. +#define RUNNINGTIME_MS_SENTINEL 0xFEDCBAFD + + + +#define VMPI_SERVICE_NAME_INTERNAL "VMPI" +#define VMPI_SERVICE_NAME "Valve MPI Service" + +// Stuff in the registry goes under here (in HKEY_LOCAL_MACHINE). +#define VMPI_SERVICE_KEY "Software\\Valve\\VMPI" +#define SERVICE_INSTALL_LOCATION_KEY "InstallLocation" + +// The VMPI service listens on one of these ports to talk to the UI. +#define VMPI_SERVICE_FIRST_UI_PORT 23300 +#define VMPI_SERVICE_LAST_UI_PORT 23310 + +// Port numbers that the master will use to broadcast unless -mpi_port is used. +#define VMPI_MASTER_FIRST_PORT 23311 +#define VMPI_MASTER_LAST_PORT 23330 + + +// Packet IDs for vmpi_service to talk to UI clients. +#define VMPI_SERVICE_TO_UI_CONSOLE_TEXT 0 // Print some text to the UI's console. +#define VMPI_SERVICE_TO_UI_STATE 1 // Updates state reflecting whether it's idle, busy, etc. +#define VMPI_SERVICE_TO_UI_PATCHING 2 // Updates state reflecting whether it's idle, busy, etc. +#define VMPI_SERVICE_TO_UI_EXIT 3 // Updates state reflecting whether it's idle, busy, etc. + + // Application state.. these are communicated between the service and the UI. + enum + { + VMPI_SERVICE_STATE_IDLE=0, + VMPI_SERVICE_STATE_BUSY, + VMPI_SERVICE_STATE_DISABLED + }; +#define VMPI_SERVICE_DISABLE 2 // Stop waiting for jobs.. +#define VMPI_SERVICE_ENABLE 3 +#define VMPI_SERVICE_UPDATE_PASSWORD 4 // New password. +#define VMPI_SERVICE_EXIT 5 // User chose "exit" from the menu. Kill the service. +#define VMPI_SERVICE_SKIP_CSX_JOBS 6 +#define VMPI_SERVICE_SCREENSAVER_MODE 7 + + +// The worker service waits on this range of ports. +#define VMPI_SERVICE_PORT 23397 +#define VMPI_LAST_SERVICE_PORT (VMPI_SERVICE_PORT + 15) + + +#define VMPI_WORKER_PORT_FIRST 22340 +#define VMPI_WORKER_PORT_LAST 22350 + +// The VMPI service downloader is still a worker but it uses this port range so the +// master knows it's just downloading the exes. +#define VMPI_SERVICE_DOWNLOADER_PORT_FIRST 22351 +#define VMPI_SERVICE_DOWNLOADER_PORT_LAST 22360 + +// Give it a small range so they can have multiple masters running. +#define VMPI_MASTER_PORT_FIRST 21140 +#define VMPI_MASTER_PORT_LAST 21145 +#define VMPI_MASTER_FILESYSTEM_BROADCAST_PORT 21146 + + + + +// Protocol. + +// The message format is: +// - VMPI_PROTOCOL_VERSION +// - null-terminated password string (or VMPI_PASSWORD_OVERRIDE followed by a zero to process it regardless of pw). +// - packet ID +// - payload + + +#define VMPI_PASSWORD_OVERRIDE -111 + + +#define VMPI_MESSAGE_BASE 71 + + +// This is the broadcast message from the main (rank 0) process looking for workers. +#define VMPI_LOOKING_FOR_WORKERS (VMPI_MESSAGE_BASE+0) + +// This is so an app can find out what machines are running the service. +#define VMPI_PING_REQUEST (VMPI_MESSAGE_BASE+2) +#define VMPI_PING_RESPONSE (VMPI_MESSAGE_BASE+3) + +// This tells the service to quit. +#define VMPI_STOP_SERVICE (VMPI_MESSAGE_BASE+6) + +// This tells the service to kill any process it has running. +#define VMPI_KILL_PROCESS (VMPI_MESSAGE_BASE+7) + +// This tells the service to patch itself. +#define VMPI_SERVICE_PATCH (VMPI_MESSAGE_BASE+8) + +// Sent back to the master via UDP to tell it if its job has started and ended. +#define VMPI_NOTIFY_START_STATUS (VMPI_MESSAGE_BASE+9) +#define VMPI_NOTIFY_END_STATUS (VMPI_MESSAGE_BASE+10) + +#define VMPI_FORCE_PASSWORD_CHANGE (VMPI_MESSAGE_BASE+11) + + +// These states are sent from the service to the services browser. +#define VMPI_STATE_IDLE 0 +#define VMPI_STATE_BUSY 1 +#define VMPI_STATE_PATCHING 2 +#define VMPI_STATE_DISABLED 3 +#define VMPI_STATE_SCREENSAVER_DISABLED 4 +#define VMPI_STATE_DOWNLOADING 5 + + +#endif // VMPI_DEFS_H diff --git a/utils/vmpi/vmpi_dispatch.cpp b/utils/vmpi/vmpi_dispatch.cpp new file mode 100644 index 0000000..b41ec69 --- /dev/null +++ b/utils/vmpi/vmpi_dispatch.cpp @@ -0,0 +1,13 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#include "vmpi_dispatch.h" +#include "tier0/dbg.h" +#include "mpi/mpi.h" +#include "vmpi.h" + + diff --git a/utils/vmpi/vmpi_dispatch.h b/utils/vmpi/vmpi_dispatch.h new file mode 100644 index 0000000..981d4a2 --- /dev/null +++ b/utils/vmpi/vmpi_dispatch.h @@ -0,0 +1,15 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#ifndef VMPI_DISPATCH_H +#define VMPI_DISPATCH_H +#ifdef _WIN32 +#pragma once +#endif + + +#endif // VMPI_DISPATCH_H diff --git a/utils/vmpi/vmpi_distribute_tracker.cpp b/utils/vmpi/vmpi_distribute_tracker.cpp new file mode 100644 index 0000000..9a112fd --- /dev/null +++ b/utils/vmpi/vmpi_distribute_tracker.cpp @@ -0,0 +1,579 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//=============================================================================// + +#include <windows.h> +#include <conio.h> +#include <io.h> +#include "vmpi.h" +#include "vmpi_distribute_work.h" +#include "tier0/platform.h" +#include "tier0/dbg.h" +#include "utlvector.h" +#include "utllinkedlist.h" + + +#define EVENT_TYPE_SEND_WORK_UNIT 0 +#define EVENT_TYPE_WU_STARTED 1 +#define EVENT_TYPE_WU_COMPLETED 2 + +class CWorkUnitEvent +{ +public: + int m_iEventType; // EVENT_TYPE_ define. + int m_iWorker; + double m_flTime; +}; + + +class CWorkUnit +{ +public: + CWorkUnit() + { + m_iWorkerCompleted = -1; + } + + int m_iWorkerCompleted; // Which worker completed this work unit (-1 if not done yet). + + CUtlVector<CWorkUnitEvent> m_Events; +}; + + +static CUtlVector<CWorkUnit> g_WorkUnits; +static double g_flJobStartTime; +static bool g_bTrackWorkUnitEvents = false; + + +static int CountActiveWorkUnits() +{ + int nActive = 0; + for ( int i=0; i < g_WorkUnits.Count(); i++ ) + { + if ( g_WorkUnits[i].m_iWorkerCompleted == -1 ) + ++nActive; + } + return nActive; +} + + +// ------------------------------------------------------------------------ // +// Graphical functions. +// ------------------------------------------------------------------------ // + +static bool g_bUseGraphics = false; +static HWND g_hWnd = 0; + +static int g_LastSizeX = 600, g_LastSizeY = 600; + +static COLORREF g_StateColors[] = +{ + RGB(50,50,50), + RGB(100,0,0), + RGB(150,0,0), + RGB(0,155,0), + RGB(0,255,0), + RGB(0,0,150), + RGB(0,0,250) +}; + +static HANDLE g_hCreateEvent = 0; +static HANDLE g_hDestroyWindowEvent = 0; +static HANDLE g_hDestroyWindowCompletedEvent = 0; + +static CRITICAL_SECTION g_CS; + +class CWUStatus +{ +public: + CWUStatus() + { + m_iState = 0; + memset( &m_Rect, 0, sizeof( m_Rect ) ); + } + + RECT m_Rect; + int m_iState; // 0 = not sent yet + // 1 = sent, 2 = sent recently + // 3 = done, 4 = done recently + // 5 = started, 6 = started recently + float m_flTransitionTime; +}; +CUtlVector<CWUStatus> g_WUStatus; +int g_nChanges = 0; +int g_nLastDrawnChanges = -1; + +static LRESULT CALLBACK TrackerWindowProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam ) +{ + switch( uMsg ) + { + case WM_PAINT: + { + // Do one pass for each color.. + HBRUSH hStateColors[ARRAYSIZE( g_StateColors )]; + for ( int i=0; i < ARRAYSIZE( hStateColors ); i++ ) + hStateColors[i] = CreateSolidBrush( g_StateColors[i] ); + + // Copy the WU statuses. + CUtlVector<CWUStatus> wuStatus; + EnterCriticalSection( &g_CS ); + + g_nLastDrawnChanges = g_nChanges; + wuStatus.SetSize( g_WUStatus.Count() ); + memcpy( wuStatus.Base(), g_WUStatus.Base(), wuStatus.Count() * sizeof( wuStatus[0] ) ); + + LeaveCriticalSection( &g_CS ); + + PAINTSTRUCT ps; + HDC hDC = BeginPaint( hwnd, &ps ); + for ( int iState=0; iState < ARRAYSIZE( hStateColors ); iState++ ) + { + HGDIOBJ hOldObj = SelectObject( hDC, hStateColors[iState] ); + + for ( int iWU=0; iWU < wuStatus.Count(); iWU++ ) + { + if ( wuStatus[iWU].m_iState != iState ) + continue; + + RECT &rc = wuStatus[iWU].m_Rect; + Rectangle( hDC, rc.left, rc.top, rc.right, rc.bottom ); + } + + SelectObject( hDC, hOldObj ); + DeleteObject( hStateColors[iState] ); + } + EndPaint( hwnd, &ps ); + } + break; + + case WM_SIZE: + { + int width = LOWORD( lParam ); + int height = HIWORD( lParam ); + + g_LastSizeX = width; + g_LastSizeY = height; + + // Figure out the rectangles for everything. + int nWorkUnits = g_WUStatus.Count(); + + // What is the max width of the grid elements so they will fit in the width and height. + int testSize; + for ( testSize=20; testSize > 1; testSize-- ) + { + int nX = width / testSize; + int nY = height / testSize; + if ( nX * nY >= nWorkUnits ) + break; + } + static int minTestSize = 3; + testSize = max( testSize, minTestSize ); + + int xPos=0, yPos=0; + for ( int i=0; i < nWorkUnits; i++ ) + { + g_WUStatus[i].m_Rect.left = xPos; + g_WUStatus[i].m_Rect.top = yPos; + g_WUStatus[i].m_Rect.right = xPos + testSize; + g_WUStatus[i].m_Rect.bottom = yPos + testSize; + + xPos += testSize; + if ( (xPos+testSize) > width ) + { + yPos += testSize; + xPos = 0; + } + } + } + break; + } + + return DefWindowProc( hwnd, uMsg, wParam, lParam ); +} + +static void CheckFlashTimers() +{ + double flCurTime = Plat_FloatTime(); + + EnterCriticalSection( &g_CS ); + + // Check timers for the events that just happened (we show them in a brighter color if they just occurred). + for ( int iWU=0; iWU < g_WUStatus.Count(); iWU++ ) + { + CWUStatus &s = g_WUStatus[iWU]; + + if ( s.m_iState == 2 || s.m_iState == 4 || s.m_iState == 6 ) + { + if ( flCurTime > s.m_flTransitionTime ) + { + s.m_iState -= 1; + ++g_nChanges; + } + } + } + + LeaveCriticalSection( &g_CS ); +} + +static DWORD WINAPI ThreadProc( LPVOID lpParameter ) +{ + // Create the window. + const char *pClassName = "VMPI_Tracker"; + + // Register the application + WNDCLASSEX WndClsEx; + WndClsEx.cbSize = sizeof(WNDCLASSEX); + WndClsEx.style = CS_HREDRAW | CS_VREDRAW; + WndClsEx.lpfnWndProc = TrackerWindowProc; + WndClsEx.cbClsExtra = 0; + WndClsEx.cbWndExtra = 0; + WndClsEx.hIcon = NULL; + WndClsEx.hCursor = LoadCursor(NULL, IDC_ARROW); + WndClsEx.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH); + WndClsEx.lpszMenuName = NULL; + WndClsEx.lpszClassName = pClassName; + WndClsEx.hInstance = (HINSTANCE)GetCurrentProcess(); + WndClsEx.hIconSm = NULL; + RegisterClassEx(&WndClsEx); + + // Create the window. + g_hWnd = CreateWindow( + pClassName, + "VMPI Tracker", + WS_OVERLAPPEDWINDOW, + 0, 0, g_LastSizeX, g_LastSizeY, + NULL, NULL, + (HINSTANCE)GetCurrentProcess(), + NULL ); + + ShowWindow( g_hWnd, SW_SHOW ); + + // Tell the main thread we're ready. + SetEvent( g_hCreateEvent ); + + // Run our main loop. + while ( WaitForSingleObject( g_hDestroyWindowEvent, 200 ) != WAIT_OBJECT_0 ) + { + MSG msg; + while ( PeekMessage( &msg, g_hWnd, 0, 0, PM_REMOVE ) ) + { + TranslateMessage(&msg); + DispatchMessage(&msg); + } + + CheckFlashTimers(); + + if ( g_nChanges != g_nLastDrawnChanges ) + InvalidateRect( g_hWnd, NULL, FALSE ); + } + + // Tell the main thread we're done. + SetEvent( g_hDestroyWindowCompletedEvent ); + return 0; +} + +static void Graphical_Start() +{ + g_bUseGraphics = VMPI_IsParamUsed( mpi_Graphics ); + if ( !g_bUseGraphics ) + return; + + // Setup an event so we'll wait until the window is ready. + if ( !g_hCreateEvent ) + { + g_hCreateEvent = CreateEvent( 0, 0, 0, 0 ); + g_hDestroyWindowEvent = CreateEvent( 0, 0, 0, 0 ); + g_hDestroyWindowCompletedEvent = CreateEvent( 0, 0, 0, 0 ); + InitializeCriticalSection( &g_CS ); + } + ResetEvent( g_hCreateEvent ); + ResetEvent( g_hDestroyWindowCompletedEvent ); + + g_WUStatus.SetSize( g_WorkUnits.Count() ); + for ( int i=0; i < g_WUStatus.Count(); i++ ) + g_WUStatus[i].m_iState = 0; + + // Setup our thread. + CreateThread( NULL, 0, ThreadProc, NULL, 0, NULL ); + + // Wait until the event is signaled. + WaitForSingleObject( g_hCreateEvent, INFINITE ); +} + +static void Graphical_WorkUnitSentToWorker( int iWorkUnit ) +{ + if ( !g_bUseGraphics ) + return; + + EnterCriticalSection( &g_CS ); + + CWUStatus &s = g_WUStatus[iWorkUnit]; + if ( s.m_iState != 3 && s.m_iState != 4 && s.m_iState != 5 && s.m_iState != 6 ) + { + s.m_iState = 2; + s.m_flTransitionTime = Plat_FloatTime() + 0.1f; + ++g_nChanges; + } + + LeaveCriticalSection( &g_CS ); +} + +static void Graphical_WorkUnitStarted( int iWorkUnit ) +{ + if ( !g_bUseGraphics ) + return; + + EnterCriticalSection( &g_CS ); + + if ( g_WUStatus[iWorkUnit].m_iState != 3 && g_WUStatus[iWorkUnit].m_iState != 4 ) + { + g_WUStatus[iWorkUnit].m_iState = 6; + g_WUStatus[iWorkUnit].m_flTransitionTime = Plat_FloatTime() + 0.1f; + ++g_nChanges; + } + + LeaveCriticalSection( &g_CS ); +} + +static void Graphical_WorkUnitCompleted( int iWorkUnit ) +{ + if ( !g_bUseGraphics ) + return; + + EnterCriticalSection( &g_CS ); + g_WUStatus[iWorkUnit].m_iState = 4; + g_WUStatus[iWorkUnit].m_flTransitionTime = Plat_FloatTime() + 0.1f; + ++g_nChanges; + LeaveCriticalSection( &g_CS ); +} + +static void Graphical_End() +{ + if ( !g_bUseGraphics ) + return; + + SetEvent( g_hDestroyWindowEvent ); + WaitForSingleObject( g_hDestroyWindowCompletedEvent, INFINITE ); +} + + +// ------------------------------------------------------------------------ // +// Interface functions. +// ------------------------------------------------------------------------ // + +void VMPITracker_Start( int nWorkUnits ) +{ + g_bTrackWorkUnitEvents = (VMPI_IsParamUsed( mpi_TrackEvents ) || VMPI_IsParamUsed( mpi_Graphics )); + g_flJobStartTime = Plat_FloatTime(); + g_WorkUnits.Purge(); + + if ( g_bTrackWorkUnitEvents ) + { + g_WorkUnits.SetSize( nWorkUnits ); + } + + Graphical_Start(); +} + + +void VMPITracker_WorkUnitSentToWorker( int iWorkUnit, int iWorker ) +{ + if ( g_bTrackWorkUnitEvents ) + { + CWorkUnitEvent event; + event.m_iEventType = EVENT_TYPE_SEND_WORK_UNIT; + event.m_iWorker = iWorker; + event.m_flTime = Plat_FloatTime(); + g_WorkUnits[iWorkUnit].m_Events.AddToTail( event ); + } + + Graphical_WorkUnitSentToWorker( iWorkUnit ); +} + + +void VMPITracker_WorkUnitStarted( int iWorkUnit, int iWorker ) +{ + if ( g_bTrackWorkUnitEvents ) + { + CWorkUnitEvent event; + event.m_iEventType = EVENT_TYPE_WU_STARTED; + event.m_iWorker = iWorker; + event.m_flTime = Plat_FloatTime(); + g_WorkUnits[iWorkUnit].m_Events.AddToTail( event ); + } + + Graphical_WorkUnitStarted( iWorkUnit ); +} + + +void VMPITracker_WorkUnitCompleted( int iWorkUnit, int iWorker ) +{ + if ( g_bTrackWorkUnitEvents ) + { + CWorkUnitEvent event; + event.m_iEventType = EVENT_TYPE_WU_COMPLETED; + event.m_iWorker = iWorker; + event.m_flTime = Plat_FloatTime(); + g_WorkUnits[iWorkUnit].m_Events.AddToTail( event ); + g_WorkUnits[iWorkUnit].m_iWorkerCompleted = iWorker; + } + + Graphical_WorkUnitCompleted( iWorkUnit ); +} + + +void VMPITracker_End() +{ + g_WorkUnits.Purge(); + Graphical_End(); +} + + +bool VMPITracker_WriteDebugFile( const char *pFilename ) +{ + FILE *fp = fopen( pFilename, "wt" ); + if ( fp ) + { + fprintf( fp, "# work units: %d\n", g_WorkUnits.Count() ); + fprintf( fp, "# active work units: %d\n", CountActiveWorkUnits() ); + + fprintf( fp, "\n" ); + fprintf( fp, "--- Events ---" ); + fprintf( fp, "\n" ); + fprintf( fp, "\n" ); + + for ( int i=0; i < g_WorkUnits.Count(); i++ ) + { + CWorkUnit *wu = &g_WorkUnits[i]; + + if ( wu->m_iWorkerCompleted != -1 ) + continue; + + fprintf( fp, " work unit %d\n", i ); + fprintf( fp, "\n" ); + + if ( wu->m_Events.Count() == 0 ) + { + fprintf( fp, " *no events*\n" ); + } + else + { + for ( int iEvent=0; iEvent < wu->m_Events.Count(); iEvent++ ) + { + CWorkUnitEvent *pEvent = &wu->m_Events[iEvent]; + + if ( pEvent->m_iEventType == EVENT_TYPE_WU_STARTED ) + { + fprintf( fp, " started (by worker %s) %.1f seconds ago\n", + VMPI_GetMachineName( wu->m_Events[iEvent].m_iWorker ), + Plat_FloatTime() - wu->m_Events[iEvent].m_flTime ); + } + else if ( pEvent->m_iEventType == EVENT_TYPE_SEND_WORK_UNIT ) + { + fprintf( fp, " sent (to worker %s) %.1f seconds ago\n", + VMPI_GetMachineName( wu->m_Events[iEvent].m_iWorker ), + Plat_FloatTime() - wu->m_Events[iEvent].m_flTime ); + } + else if ( pEvent->m_iEventType == EVENT_TYPE_WU_COMPLETED ) + { + fprintf( fp, " completed (by worker %s) %.1f seconds ago\n", + VMPI_GetMachineName( wu->m_Events[iEvent].m_iWorker ), + Plat_FloatTime() - wu->m_Events[iEvent].m_flTime ); + } + } + } + fprintf( fp, "\n" ); + } + + fclose( fp ); + return true; + } + else + { + return false; + } +} + + +void VMPITracker_HandleDebugKeypresses() +{ + if ( !g_bTrackWorkUnitEvents ) + return; + + if ( !kbhit() ) + return; + + static int iState = 0; + + int key = toupper( getch() ); + if ( iState == 0 ) + { + if ( key == 'D' ) + { + iState = 1; + Warning("\n\n" + "----------------------\n" + "1. Write debug file (ascending filenames).\n" + "2. Write debug file (c:\\vmpi_tracker_0.txt).\n" + "3. Invite debug workers (password: 'debugworker').\n" + "\n" + "0. Exit menu.\n" + "----------------------\n" + "\n" + ); + } + } + else if ( iState == 1 ) + { + if ( key == '1' ) + { + iState = 0; + + int nMaxTries = 128; + char filename[512]; + int iFile = 1; + for ( iFile; iFile < nMaxTries; iFile++ ) + { + Q_snprintf( filename, sizeof( filename ), "c:\\vmpi_tracker_%d.txt", iFile ); + if ( _access( filename, 0 ) != 0 ) + break; + } + if ( iFile == nMaxTries ) + { + Warning( "** Please delete c:\\vmpi_tracker_*.txt and try again.\n" ); + } + else + { + if ( VMPITracker_WriteDebugFile( filename ) ) + Warning( "Wrote %s successfully.\n", filename ); + else + Warning( "Failed to write %s successfully.\n", filename ); + } + } + else if ( key == '2' ) + { + iState = 0; + + const char *filename = "c:\\vmpi_tracker_0.txt"; + if ( VMPITracker_WriteDebugFile( filename ) ) + Warning( "Wrote %s successfully.\n", filename ); + else + Warning( "Failed to write %s successfully.\n", filename ); + } + else if ( key == '3' ) + { + iState = 0; + Warning( "\nInviting debug workers with password 'debugworker'...\nGo ahead and connect them.\n" ); + VMPI_InviteDebugWorkers(); + } + else if ( key == '0' ) + { + iState = 0; + Warning( "\n\nExited menu.\n\n" ); + } + } +} + + diff --git a/utils/vmpi/vmpi_distribute_tracker.h b/utils/vmpi/vmpi_distribute_tracker.h new file mode 100644 index 0000000..98135cb --- /dev/null +++ b/utils/vmpi/vmpi_distribute_tracker.h @@ -0,0 +1,32 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: vmpi_distribute_work sends events to this module, and this module +// can track the events or display them graphically for debugging. +// +//=============================================================================// + +#ifndef VMPI_DISTRIBUTE_TRACKER_H +#define VMPI_DISTRIBUTE_TRACKER_H +#ifdef _WIN32 +#pragma once +#endif + +// If bDebugMode is set, then it will remember all the VMPI events +// in case you call VMPITracker_WriteDebugFile. +void VMPITracker_Start( int nWorkUnits ); + +void VMPITracker_WorkUnitSentToWorker( int iWorkUnit, int iWorker ); +void VMPITracker_WorkUnitStarted( int iWorkUnit, int iWorker ); +void VMPITracker_WorkUnitCompleted( int iWorkUnit, int iWorker ); +void VMPITracker_End(); + +// This will bring up a little menu they can use to +// write a debug file. +void VMPITracker_HandleDebugKeypresses(); + +bool VMPITracker_WriteDebugFile( const char *pFilename ); + + +#endif // VMPI_DISTRIBUTE_TRACKER_H + + diff --git a/utils/vmpi/vmpi_distribute_work.cpp b/utils/vmpi/vmpi_distribute_work.cpp new file mode 100644 index 0000000..f28e07e --- /dev/null +++ b/utils/vmpi/vmpi_distribute_work.cpp @@ -0,0 +1,628 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//=============================================================================// + +#include <windows.h> +#include "vmpi.h" +#include "vmpi_distribute_work.h" +#include "tier0/platform.h" +#include "tier0/dbg.h" +#include "utlvector.h" +#include "utllinkedlist.h" +#include "vmpi_dispatch.h" +#include "pacifier.h" +#include "vstdlib/random.h" +#include "mathlib/mathlib.h" +#include "threadhelpers.h" +#include "threads.h" +#include "tier1/strtools.h" +#include "tier1/utlmap.h" +#include "tier1/smartptr.h" +#include "tier0/icommandline.h" +#include "cmdlib.h" +#include "vmpi_distribute_tracker.h" +#include "vmpi_distribute_work_internal.h" + + +// To catch some bugs with 32-bit vs 64-bit and etc. +#pragma warning( default : 4244 ) +#pragma warning( default : 4305 ) +#pragma warning( default : 4267 ) +#pragma warning( default : 4311 ) +#pragma warning( default : 4312 ) + + +const int MAX_DW_CALLS = 255; +extern bool g_bSetThreadPriorities; + + +// Subpacket IDs owned by DistributeWork. +#define DW_SUBPACKETID_MASTER_READY 0 +#define DW_SUBPACKETID_WORKER_READY 1 +#define DW_SUBPACKETID_MASTER_FINISHED 2 +#define DW_SUBPACKETID_WU_RESULTS 4 +#define DW_SUBPACKETID_WU_STARTED 6 // A worker telling the master it has started processing a work unit. +// NOTE VMPI_DISTRIBUTE_WORK_EXTRA_SUBPACKET_BASE is where the IWorkUnitDistributorX classes start their subpackets. + + +IWorkUnitDistributorCallbacks *g_pDistributeWorkCallbacks = NULL; + + +static CDSInfo g_DSInfo; +static unsigned short g_iCurDSInfo = (unsigned short)-1; // This is incremented each time DistributeWork is called. +static int g_iMasterFinishedDistributeWorkCall = -1; // The worker stores this to know which DistributeWork() calls the master has finished. +static int g_iMasterReadyForDistributeWorkCall = -1; + +// This is only valid if we're a worker and if the worker currently has threads chewing on work units. +static CDSInfo *g_pCurWorkerThreadsInfo = NULL; + +static CUtlVector<uint64> g_wuCountByProcess; +static uint64 g_totalWUCountByProcess[512]; + +static uint64 g_nWUs; // How many work units there were this time around. +static uint64 g_nCompletedWUs; // How many work units completed. +static uint64 g_nDuplicatedWUs; // How many times a worker sent results for a work unit that was already completed. + +// Set to true if Error() is called and we want to exit early. vrad and vvis check for this in their +// thread functions, so the workers quit early when the master is done rather than finishing up +// potentially time-consuming work units they're working on. +bool g_bVMPIEarlyExit = false; + +static bool g_bMasterDistributingWork = false; + +static IWorkUnitDistributorWorker *g_pCurDistributorWorker = NULL; +static IWorkUnitDistributorMaster *g_pCurDistributorMaster = NULL; + +// For the stats database. +WUIndexType g_ThreadWUs[4] = { ~0ull, ~0ull, ~0ull, ~0ull }; + +class CMasterWorkUnitCompletedList +{ +public: + CUtlVector<WUIndexType> m_CompletedWUs; +}; +static CCriticalSectionData<CMasterWorkUnitCompletedList> g_MasterWorkUnitCompletedList; + + +int SortByWUCount( const void *elem1, const void *elem2 ) +{ + uint64 a = g_wuCountByProcess[ *((const int*)elem1) ]; + uint64 b = g_wuCountByProcess[ *((const int*)elem2) ]; + if ( a < b ) + return 1; + else if ( a == b ) + return 0; + else + return -1; +} + + +void PrepareDistributeWorkHeader( MessageBuffer *pBuf, unsigned char cSubpacketID ) +{ + char cPacketID[2] = { g_DSInfo.m_cPacketID, cSubpacketID }; + pBuf->write( cPacketID, 2 ); + pBuf->write( &g_iCurDSInfo, sizeof( g_iCurDSInfo ) ); +} + + +void ShowMPIStats( + double flTimeSpent, + unsigned long nBytesSent, + unsigned long nBytesReceived, + unsigned long nMessagesSent, + unsigned long nMessagesReceived ) +{ + double flKSent = (nBytesSent + 511) / 1024; + double flKRecv = (nBytesReceived + 511) / 1024; + + bool bShowOutput = VMPI_IsParamUsed( mpi_ShowDistributeWorkStats ); + + bool bOldSuppress = g_bSuppressPrintfOutput; + g_bSuppressPrintfOutput = !bShowOutput; + + Msg( "\n\n--------------------------------------------------------------\n"); + Msg( "Total Time : %.2f\n", flTimeSpent ); + Msg( "Total Bytes Sent : %dk (%.2fk/sec, %d messages)\n", (int)flKSent, flKSent / flTimeSpent, nMessagesSent ); + Msg( "Total Bytes Recv : %dk (%.2fk/sec, %d messages)\n", (int)flKRecv, flKRecv / flTimeSpent, nMessagesReceived ); + if ( g_bMPIMaster ) + { + Msg( "Duplicated WUs : %I64u (%.1f%%)\n", g_nDuplicatedWUs, (float)g_nDuplicatedWUs * 100.0f / g_nWUs ); + + Msg( "\nWU count by proc:\n" ); + + int nProcs = VMPI_GetCurrentNumberOfConnections(); + + CUtlVector<int> sortedProcs; + sortedProcs.SetSize( nProcs ); + for ( int i=0; i < nProcs; i++ ) + sortedProcs[i] = i; + + qsort( sortedProcs.Base(), nProcs, sizeof( int ), SortByWUCount ); + + for ( int i=0; i < nProcs; i++ ) + { + const char *pMachineName = VMPI_GetMachineName( sortedProcs[i] ); + Msg( "%s", pMachineName ); + + char formatStr[512]; + Q_snprintf( formatStr, sizeof( formatStr ), "%%%ds %I64u\n", 30 - strlen( pMachineName ), g_wuCountByProcess[ sortedProcs[i] ] ); + Msg( formatStr, ":" ); + } + } + Msg( "--------------------------------------------------------------\n\n "); + + g_bSuppressPrintfOutput = bOldSuppress; +} + + +void VMPI_DistributeWork_DisconnectHandler( int procID, const char *pReason ) +{ + if ( g_bMasterDistributingWork ) + { + // Show the disconnect in the database but not on the screen. + bool bOldSuppress = g_bSuppressPrintfOutput; + g_bSuppressPrintfOutput = true; + Msg( "VMPI_DistributeWork_DisconnectHandler( %d )\n", procID ); + g_bSuppressPrintfOutput = bOldSuppress; + + // Redistribute the WUs from this guy's partition to another worker. + g_pCurDistributorMaster->DisconnectHandler( procID ); + } +} + + +uint64 VMPI_GetNumWorkUnitsCompleted( int iProc ) +{ + Assert( iProc >= 0 && iProc <= ARRAYSIZE( g_totalWUCountByProcess ) ); + return g_totalWUCountByProcess[iProc]; +} + + +void HandleWorkUnitCompleted( CDSInfo *pInfo, int iSource, WUIndexType iWorkUnit, MessageBuffer *pBuf ) +{ + VMPITracker_WorkUnitCompleted( ( int ) iWorkUnit, iSource ); + + if ( g_pCurDistributorMaster->HandleWorkUnitResults( iWorkUnit ) ) + { + if ( g_iVMPIVerboseLevel >= 1 ) + Msg( "-" ); + + ++ g_nCompletedWUs; + ++ g_wuCountByProcess[iSource]; + ++ g_totalWUCountByProcess[iSource]; + + // Let the master process the incoming WU data. + if ( pBuf ) + { + pInfo->m_MasterInfo.m_ReceiveFn( iWorkUnit, pBuf, iSource ); + } + + UpdatePacifier( float( g_nCompletedWUs ) / pInfo->m_nWorkUnits ); + } + else + { + // Ignore it if we already got the results for this work unit. + ++ g_nDuplicatedWUs; + if ( g_iVMPIVerboseLevel >= 1 ) + Msg( "*" ); + } +} + + +bool DistributeWorkDispatch( MessageBuffer *pBuf, int iSource, int iPacketID ) +{ + unsigned short iCurDistributeWorkCall = *((unsigned short*)&pBuf->data[2]); + if ( iCurDistributeWorkCall >= MAX_DW_CALLS ) + Error( "Got an invalid DistributeWork packet (id: %d, sub: %d) (iCurDW: %d).", pBuf->data[0], pBuf->data[1], iCurDistributeWorkCall ); + + CDSInfo *pInfo = &g_DSInfo; + + pBuf->setOffset( 4 ); + + switch ( pBuf->data[1] ) + { + case DW_SUBPACKETID_MASTER_READY: + { + g_iMasterReadyForDistributeWorkCall = iCurDistributeWorkCall; + return true; + } + + case DW_SUBPACKETID_WORKER_READY: + { + if ( iCurDistributeWorkCall > g_iCurDSInfo || !g_bMPIMaster ) + Error( "State incorrect on master for DW_SUBPACKETID_WORKER_READY packet from %s.", VMPI_GetMachineName( iSource ) ); + + if ( iCurDistributeWorkCall == g_iCurDSInfo ) + { + // Ok, give this guy some WUs. + if ( g_pCurDistributorMaster ) + g_pCurDistributorMaster->OnWorkerReady( iSource ); + } + + return true; + } + + case DW_SUBPACKETID_MASTER_FINISHED: + { + g_iMasterFinishedDistributeWorkCall = iCurDistributeWorkCall; + return true; + } + + // Worker sends this to tell the master it has started on a work unit. + case DW_SUBPACKETID_WU_STARTED: + { + if ( iCurDistributeWorkCall != g_iCurDSInfo ) + return true; + + WUIndexType iWU; + pBuf->read( &iWU, sizeof( iWU ) ); + VMPITracker_WorkUnitStarted( ( int ) iWU, iSource ); + return true; + } + + + case DW_SUBPACKETID_WU_RESULTS: + { + // We only care about work results for the iteration we're in. + if ( iCurDistributeWorkCall != g_iCurDSInfo ) + return true; + + WUIndexType iWorkUnit; + pBuf->read( &iWorkUnit, sizeof( iWorkUnit ) ); + if ( iWorkUnit >= pInfo->m_nWorkUnits ) + { + Error( "DistributeWork: got an invalid work unit index (%I64u for WU count of %I64u).", iWorkUnit, pInfo->m_nWorkUnits ); + } + + HandleWorkUnitCompleted( pInfo, iSource, iWorkUnit, pBuf ); + return true; + } + + default: + { + if ( g_pCurDistributorMaster ) + return g_pCurDistributorMaster->HandlePacket( pBuf, iSource, iCurDistributeWorkCall != g_iCurDSInfo ); + else if ( g_pCurDistributorWorker ) + return g_pCurDistributorWorker->HandlePacket( pBuf, iSource, iCurDistributeWorkCall != g_iCurDSInfo ); + else + return false; + } + } +} + + +EWorkUnitDistributor VMPI_GetActiveWorkUnitDistributor() +{ + if ( VMPI_IsParamUsed( mpi_UseSDKDistributor ) ) + { + Msg( "Found %s.\n", VMPI_GetParamString( mpi_UseSDKDistributor ) ); + return k_eWorkUnitDistributor_SDK; + } + else if ( VMPI_IsParamUsed( mpi_UseDefaultDistributor ) ) + { + Msg( "Found %s.\n", VMPI_GetParamString( mpi_UseDefaultDistributor ) ); + return k_eWorkUnitDistributor_Default; + } + else + { + if ( VMPI_IsSDKMode() ) + return k_eWorkUnitDistributor_SDK; + else + return k_eWorkUnitDistributor_Default; + } +} + + +void PreDistributeWorkSync( CDSInfo *pInfo ) +{ + if ( g_bMPIMaster ) + { + // Send a message telling all the workers we're ready to go on this DistributeWork call. + MessageBuffer mb; + PrepareDistributeWorkHeader( &mb, DW_SUBPACKETID_MASTER_READY ); + VMPI_SendData( mb.data, mb.getLen(), VMPI_PERSISTENT ); + } + else + { + if ( g_iVMPIVerboseLevel >= 1 ) + Msg( "PreDistributeWorkSync: waiting for master\n" ); + + // Wait for the master's message saying it's ready to go. + while ( g_iMasterReadyForDistributeWorkCall < g_iCurDSInfo ) + { + VMPI_DispatchNextMessage(); + } + + if ( g_iVMPIVerboseLevel >= 1 ) + Msg( "PreDistributeWorkSync: master ready\n" ); + + // Now tell the master we're ready. + MessageBuffer mb; + PrepareDistributeWorkHeader( &mb, DW_SUBPACKETID_WORKER_READY ); + VMPI_SendData( mb.data, mb.getLen(), VMPI_MASTER_ID ); + } +} + + +void DistributeWork_Master( CDSInfo *pInfo, ProcessWorkUnitFn processFn, ReceiveWorkUnitFn receiveFn ) +{ + pInfo->m_WorkerInfo.m_pProcessFn = processFn; + pInfo->m_MasterInfo.m_ReceiveFn = receiveFn; + + VMPITracker_Start( (int) pInfo->m_nWorkUnits ); + + g_bMasterDistributingWork = true; + g_pCurDistributorMaster->DistributeWork_Master( pInfo ); + g_bMasterDistributingWork = false; + + VMPITracker_End(); + + // Tell all workers to move on. + MessageBuffer mb; + PrepareDistributeWorkHeader( &mb, DW_SUBPACKETID_MASTER_FINISHED ); + VMPI_SendData( mb.data, mb.getLen(), VMPI_PERSISTENT ); + + // Clear the master's local completed work unit list. + CMasterWorkUnitCompletedList *pList = g_MasterWorkUnitCompletedList.Lock(); + pList->m_CompletedWUs.RemoveAll(); + g_MasterWorkUnitCompletedList.Unlock(); +} + + +void NotifyLocalMasterCompletedWorkUnit( WUIndexType iWorkUnit ) +{ + CMasterWorkUnitCompletedList *pList = g_MasterWorkUnitCompletedList.Lock(); + pList->m_CompletedWUs.AddToTail( iWorkUnit ); + g_MasterWorkUnitCompletedList.Unlock(); +} + +void CheckLocalMasterCompletedWorkUnits() +{ + CMasterWorkUnitCompletedList *pList = g_MasterWorkUnitCompletedList.Lock(); + + for ( int i=0; i < pList->m_CompletedWUs.Count(); i++ ) + { + HandleWorkUnitCompleted( &g_DSInfo, 0, pList->m_CompletedWUs[i], NULL ); + } + pList->m_CompletedWUs.RemoveAll(); + + g_MasterWorkUnitCompletedList.Unlock(); +} + + +void TellMasterThatWorkerStartedAWorkUnit( MessageBuffer &mb, CDSInfo *pInfo, WUIndexType iWU ) +{ + mb.setLen( 0 ); + PrepareDistributeWorkHeader( &mb, DW_SUBPACKETID_WU_STARTED ); + mb.write( &iWU, sizeof( iWU ) ); + VMPI_SendData( mb.data, mb.getLen(), VMPI_MASTER_ID, k_eVMPISendFlags_GroupPackets ); +} + + +void VMPI_WorkerThread( int iThread, void *pUserData ) +{ + CDSInfo *pInfo = (CDSInfo*)pUserData; + CWorkerInfo *pWorkerInfo = &pInfo->m_WorkerInfo; + + + // Get our index for running work units + uint64 idxRunningWorkUnit = (uint64) iThread; + { + CCriticalSectionLock csLock( &pWorkerInfo->m_WorkUnitsRunningCS ); + csLock.Lock(); + pWorkerInfo->m_WorkUnitsRunning.ExpandWindow( idxRunningWorkUnit, ~0ull ); + csLock.Unlock(); + } + + + MessageBuffer mb; + PrepareDistributeWorkHeader( &mb, DW_SUBPACKETID_WU_RESULTS ); + + MessageBuffer mbStartedWorkUnit; // Special messagebuffer used to tell the master when we started a work unit. + + while ( g_iMasterFinishedDistributeWorkCall < g_iCurDSInfo && !g_bVMPIEarlyExit ) + { + WUIndexType iWU; + + // Quit out when there are no more work units. + if ( !g_pCurDistributorWorker->GetNextWorkUnit( &iWU ) ) + { + // Wait until there are some WUs to do. This should probably use event handles. + VMPI_Sleep( 10 ); + continue; + } + + CCriticalSectionLock csLock( &pWorkerInfo->m_WorkUnitsRunningCS ); + csLock.Lock(); + + // Check if this WU is not running + WUIndexType const *pBegin = &pWorkerInfo->m_WorkUnitsRunning.Get( 0ull ), *pEnd = pBegin + pWorkerInfo->m_WorkUnitsRunning.PastVisibleIndex(); + WUIndexType const *pRunningWu = GenericFind( pBegin, pEnd, iWU ); + if ( pRunningWu != pEnd ) + continue; + + // We are running it + pWorkerInfo->m_WorkUnitsRunning.Get( idxRunningWorkUnit ) = iWU; + + csLock.Unlock(); + + + // Process this WU and send the results to the master. + mb.setLen( 4 ); + mb.write( &iWU, sizeof( iWU ) ); + + // Set the current WU for the stats database. + if ( iThread >= 0 && iThread < 4 ) + { + g_ThreadWUs[iThread] = iWU; + } + + // Tell the master we're starting on this WU. + TellMasterThatWorkerStartedAWorkUnit( mbStartedWorkUnit, pInfo, iWU ); + + + pWorkerInfo->m_pProcessFn( iThread, iWU, &mb ); + g_pCurDistributorWorker->NoteLocalWorkUnitCompleted( iWU ); + + VMPI_SendData( mb.data, mb.getLen(), VMPI_MASTER_ID, /*k_eVMPISendFlags_GroupPackets*/0 ); + + // Flush grouped packets every once in a while. + //VMPI_FlushGroupedPackets( 1000 ); + } + + if ( g_iVMPIVerboseLevel >= 1 ) + Msg( "Worker thread exiting.\n" ); +} + + +void DistributeWork_Worker( CDSInfo *pInfo, ProcessWorkUnitFn processFn ) +{ + if ( g_iVMPIVerboseLevel >= 1 ) + Msg( "VMPI_DistributeWork call %d started.\n", g_iCurDSInfo+1 ); + + CWorkerInfo *pWorkerInfo = &pInfo->m_WorkerInfo; + pWorkerInfo->m_pProcessFn = processFn; + + g_pCurWorkerThreadsInfo = pInfo; + g_pCurDistributorWorker->Init( pInfo ); + + // Start a couple threads to do the work. + RunThreads_Start( VMPI_WorkerThread, pInfo, g_bSetThreadPriorities ? k_eRunThreadsPriority_Idle : k_eRunThreadsPriority_UseGlobalState ); + if ( g_iVMPIVerboseLevel >= 1 ) + Msg( "RunThreads_Start finished successfully.\n" ); + + if ( VMPI_IsSDKMode() ) + { + Msg( "\n" ); + while ( g_iMasterFinishedDistributeWorkCall < g_iCurDSInfo ) + { + VMPI_DispatchNextMessage( 300 ); + + Msg( "\rThreads status: " ); + for ( int i=0; i < ARRAYSIZE( g_ThreadWUs ); i++ ) + { + if ( g_ThreadWUs[i] != ~0ull ) + Msg( "%d: WU %5d ", i, (int)g_ThreadWUs[i] ); + } + + VMPI_FlushGroupedPackets(); + } + Msg( "\n" ); + } + else + { + while ( g_iMasterFinishedDistributeWorkCall < g_iCurDSInfo ) + { + VMPI_DispatchNextMessage(); + } + } + + + // Close the threads. + g_pCurWorkerThreadsInfo = NULL; + RunThreads_End(); + + if ( g_iVMPIVerboseLevel >= 1 ) + Msg( "VMPI_DistributeWork call %d finished.\n", g_iCurDSInfo+1 ); +} + + +// This is called by VMPI_Finalize in case it's shutting down due to an Error() call. +// In this case, it's important that the worker threads here are shut down before VMPI shuts +// down its sockets. +void DistributeWork_Cancel() +{ + if ( g_pCurWorkerThreadsInfo ) + { + Msg( "\nDistributeWork_Cancel saves the day!\n" ); + g_pCurWorkerThreadsInfo->m_bMasterFinished = true; + g_bVMPIEarlyExit = true; + RunThreads_End(); + } +} + + +// Returns time it took to finish the work. +double DistributeWork( + uint64 nWorkUnits, // how many work units to dole out + char cPacketID, + ProcessWorkUnitFn processFn, // workers implement this to process a work unit and send results back + ReceiveWorkUnitFn receiveFn // the master implements this to receive a work unit + ) +{ + ++g_iCurDSInfo; + + if ( g_iCurDSInfo == 0 ) + { + // Register our disconnect handler so we can deal with it if clients bail out. + if ( g_bMPIMaster ) + { + VMPI_AddDisconnectHandler( VMPI_DistributeWork_DisconnectHandler ); + } + } + else if ( g_iCurDSInfo >= MAX_DW_CALLS ) + { + Error( "DistributeWork: called more than %d times.\n", MAX_DW_CALLS ); + } + + CDSInfo *pInfo = &g_DSInfo; + + pInfo->m_cPacketID = cPacketID; + pInfo->m_nWorkUnits = nWorkUnits; + + // Make all the workers wait until the master is ready. + PreDistributeWorkSync( pInfo ); + + g_nWUs = nWorkUnits; + g_nCompletedWUs = 0ull; + g_nDuplicatedWUs = 0ull; + + // Setup stats info. + double flMPIStartTime = Plat_FloatTime(); + g_wuCountByProcess.SetCount( 512 ); + memset( g_wuCountByProcess.Base(), 0, sizeof( int ) * g_wuCountByProcess.Count() ); + + unsigned long nBytesSentStart = g_nBytesSent; + unsigned long nBytesReceivedStart = g_nBytesReceived; + unsigned long nMessagesSentStart = g_nMessagesSent; + unsigned long nMessagesReceivedStart = g_nMessagesReceived; + + EWorkUnitDistributor eWorkUnitDistributor = VMPI_GetActiveWorkUnitDistributor(); + if ( g_bMPIMaster ) + { + Assert( !g_pCurDistributorMaster ); + g_pCurDistributorMaster = ( eWorkUnitDistributor == k_eWorkUnitDistributor_SDK ? CreateWUDistributor_SDKMaster() : CreateWUDistributor_DefaultMaster() ); + + DistributeWork_Master( pInfo, processFn, receiveFn ); + + g_pCurDistributorMaster->Release(); + g_pCurDistributorMaster = NULL; + } + else + { + Assert( !g_pCurDistributorWorker ); + g_pCurDistributorWorker = ( eWorkUnitDistributor == k_eWorkUnitDistributor_SDK ? CreateWUDistributor_SDKWorker() : CreateWUDistributor_DefaultWorker() ); + + DistributeWork_Worker( pInfo, processFn ); + + g_pCurDistributorWorker->Release(); + g_pCurDistributorWorker = NULL; + } + + double flTimeSpent = Plat_FloatTime() - flMPIStartTime; + ShowMPIStats( + flTimeSpent, + g_nBytesSent - nBytesSentStart, + g_nBytesReceived - nBytesReceivedStart, + g_nMessagesSent - nMessagesSentStart, + g_nMessagesReceived - nMessagesReceivedStart + ); + + // Mark that the threads aren't working on anything at the moment. + for ( int i=0; i < ARRAYSIZE( g_ThreadWUs ); i++ ) + g_ThreadWUs[i] = ~0ull; + + return flTimeSpent; +} diff --git a/utils/vmpi/vmpi_distribute_work.h b/utils/vmpi/vmpi_distribute_work.h new file mode 100644 index 0000000..0435460 --- /dev/null +++ b/utils/vmpi/vmpi_distribute_work.h @@ -0,0 +1,89 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//=============================================================================// + +#ifndef VMPI_DISTRIBUTE_WORK_H +#define VMPI_DISTRIBUTE_WORK_H +#ifdef _WIN32 +#pragma once +#endif + + +#include "messbuf.h" +#include "utlvector.h" + + +class IWorkUnitDistributorCallbacks +{ +public: + // Called every 200ms or so as it does the work. + // Return true to stop distributing work. + virtual bool Update() { return false; } + + // Called when a subsequent number of work units is completed. + // e.g. results received in the following order will trigger + // the following calls to OnWorkUnitsCompleted: + // Work unit numbers: wu2 wu4 wu5 wu1 wu0 wu6 wu3 + // Calling OnWorkUnitsCompleted with arg: - - - - 3 - 7 + // because when wu0 is received we already have { wu0, wu1, wu2 } so we signal + // that 3 subsequent work units completed, like wise by the time when wu3 is + // received we already have a full set { wu0, wu1, wu2, wu3, wu4, wu5, wu6 } + // and signal that 7 work units completed. + virtual void OnWorkUnitsCompleted( uint64 numWorkUnits ) { return; } +}; + + +enum EWorkUnitDistributor +{ + k_eWorkUnitDistributor_Default, + k_eWorkUnitDistributor_SDK +}; + +// Tells which work unit distributor is going to be used. +EWorkUnitDistributor VMPI_GetActiveWorkUnitDistributor(); + + +// Before calling DistributeWork, you can set this and it'll call your virtual functions. +extern IWorkUnitDistributorCallbacks *g_pDistributeWorkCallbacks; + + +// You must append data to pBuf with the work unit results. +// Note: pBuf will be NULL if this is a local thread doing work on the master. +typedef void (*ProcessWorkUnitFn)( int iThread, uint64 iWorkUnit, MessageBuffer *pBuf ); + +// pBuf is ready to read the results written to the buffer in ProcessWorkUnitFn. +typedef void (*ReceiveWorkUnitFn)( uint64 iWorkUnit, MessageBuffer *pBuf, int iWorker ); + + +// Use a CDispatchReg to register this function with whatever packet ID you give to DistributeWork. +bool DistributeWorkDispatch( MessageBuffer *pBuf, int iSource, int iPacketID ); + + + +// This is the function vrad and vvis use to divide the work units and send them out. +// It maintains a sliding window of work units so it can always keep the clients busy. +// +// The workers implement processFn to do the job work in a work unit. +// This function must send back a packet formatted with: +// cPacketID (char), cSubPacketID (char), iWorkUnit (int), (app-specific data for the results) +// +// The masters implement receiveFn to receive a work unit's results. +// +// Returns time it took to finish the work. +double DistributeWork( + uint64 nWorkUnits, // how many work units to dole out + char cPacketID, // This packet ID must be reserved for DistributeWork and DistributeWorkDispatch + // must be registered with it. + ProcessWorkUnitFn processFn, // workers implement this to process a work unit and send results back + ReceiveWorkUnitFn receiveFn // the master implements this to receive a work unit + ); + + +// VMPI calls this before shutting down because any threads that DistributeWork has running must stop, +// otherwise it can crash if a thread tries to send data in the middle of shutting down. +void DistributeWork_Cancel(); + + +#endif // VMPI_DISTRIBUTE_WORK_H diff --git a/utils/vmpi/vmpi_distribute_work_default.cpp b/utils/vmpi/vmpi_distribute_work_default.cpp new file mode 100644 index 0000000..4a0e2c6 --- /dev/null +++ b/utils/vmpi/vmpi_distribute_work_default.cpp @@ -0,0 +1,602 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//============================================================================= + +#include "vmpi.h" +#include "vmpi_distribute_work.h" +#include "tier0/platform.h" +#include "tier0/dbg.h" +#include "utlvector.h" +#include "utllinkedlist.h" +#include "vmpi_dispatch.h" +#include "pacifier.h" +#include "vstdlib/random.h" +#include "mathlib/mathlib.h" +#include "threadhelpers.h" +#include "threads.h" +#include "tier1/strtools.h" +#include "tier1/utlmap.h" +#include "tier1/smartptr.h" +#include "tier0/icommandline.h" +#include "cmdlib.h" +#include "vmpi_distribute_tracker.h" +#include "vmpi_distribute_work_internal.h" + + +#define DW_SUBPACKETID_WU_ASSIGNMENT (VMPI_DISTRIBUTE_WORK_EXTRA_SUBPACKET_BASE+0) + + + +static int s_numWusToDeal = -1; + +void VMPI_SetWorkUnitsPartitionSize( int numWusToDeal ) +{ + s_numWusToDeal = numWusToDeal; +} + + +class CWorkUnitInfo +{ +public: + WUIndexType m_iWorkUnit; +}; + + +class CWULookupInfo +{ +public: + CWULookupInfo() : m_iWUInfo( -1 ), m_iPartition( -222222 ), m_iPartitionListIndex( -1 ) {} + +public: + int m_iWUInfo; // Index into m_WUInfo. + int m_iPartition; // Which partition it's in. + int m_iPartitionListIndex; // Index into its partition's m_WUs. +}; + + +class CPartitionInfo +{ +public: + typedef CUtlLinkedList< WUIndexType, int > PartitionWUs; + +public: + int m_iPartition; // Index into m_Partitions. + int m_iWorker; // Who owns this partition? + PartitionWUs m_WUs; // Which WUs are in this partition? +}; + + +// Work units tracker to track consecutive finished blocks +class CWorkUnitsTracker +{ +public: + CWorkUnitsTracker() {} + +public: + // Initializes the unit tracker to receive numUnits in future + void PrepareForWorkUnits( uint64 numUnits ); + // Signals that a work unit has been finished + // returns a zero-based index of the next pending work unit + // up to which the task list has been processed fully now + // because the received work unit filled the gap or was the next pending work unit. + // returns 0 to indicate that this work unit is a "faster processed future work unit". + uint64 WorkUnitFinished( uint64 iWorkUnit ); + +public: + enum WUInfo { kNone, kTrigger, kDone }; + CVisibleWindowVector< uint8 > m_arrInfo; +}; + +void CWorkUnitsTracker::PrepareForWorkUnits( uint64 numUnits ) +{ + m_arrInfo.Reset( numUnits + 1 ); + + if ( numUnits ) + { + m_arrInfo.ExpandWindow( 2ull, kNone ); + m_arrInfo.Get( 0ull ) = kTrigger; + } +} + +uint64 CWorkUnitsTracker::WorkUnitFinished( uint64 iWorkUnit ) +{ + uint64 uiResult = uint64( 0 ); + + if ( iWorkUnit >= m_arrInfo.FirstPossibleIndex() && iWorkUnit < m_arrInfo.PastPossibleIndex() ) + { + // Need to access the element + m_arrInfo.ExpandWindow( iWorkUnit + 1, kNone ); + + // Set it done + uint8 &rchThere = m_arrInfo.Get( iWorkUnit ), chThere = rchThere; + rchThere = kDone; + + // Should we trigger? + if ( kTrigger == chThere ) + { + // Go along all "done" work units and trigger the last found one + while ( ( ( ++ iWorkUnit ) < m_arrInfo.PastVisibleIndex() ) && + ( kDone == m_arrInfo.Get( iWorkUnit ) ) ) + continue; + + m_arrInfo.Get( iWorkUnit ) = kTrigger; + m_arrInfo.ShrinkWindow( iWorkUnit - 1 ); + uiResult = iWorkUnit; + } + else if( iWorkUnit == m_arrInfo.FirstPossibleIndex() ) + { + // Go along all "done" work units and shrink including the last found one + while ( ( ( ++ iWorkUnit ) < m_arrInfo.PastVisibleIndex() ) && + ( kDone == m_arrInfo.Get( iWorkUnit ) ) ) + continue; + + m_arrInfo.ShrinkWindow( iWorkUnit - 1 ); + } + } + + return uiResult; +} + +CWorkUnitsTracker g_MasterWorkUnitsTracker; + + + +static bool CompareSoonestWorkUnitSets( CPartitionInfo::PartitionWUs * const &x, CPartitionInfo::PartitionWUs * const &y ) +{ + // Compare by fourth/second/first job in the partitions + WUIndexType missing = ~WUIndexType(0); + WUIndexType jobsX[4] = { missing, missing, missing, missing }; + WUIndexType jobsY[4] = { missing, missing, missing, missing }; + int counter = 0; + + counter = 0; + FOR_EACH_LL( (*x), i ) + { + jobsX[ counter ++ ] = (*x)[i]; + if ( counter >= 4 ) + break; + } + + counter = 0; + FOR_EACH_LL( (*y), i ) + { + jobsY[ counter ++ ] = (*y)[i]; + if ( counter >= 4 ) + break; + } + + // Compare + if ( jobsX[3] != jobsY[3] ) + return ( jobsX[3] < jobsY[3] ); + + if ( jobsX[1] != jobsY[1] ) + return ( jobsX[1] < jobsY[1] ); + + return jobsX[0] < jobsY[0]; +} + + + +class CDistributor_DefaultMaster : public IWorkUnitDistributorMaster +{ +public: + virtual void Release() + { + delete this; + } + + virtual void DistributeWork_Master( CDSInfo *pInfo ) + { + m_pInfo = pInfo; + g_MasterWorkUnitsTracker.PrepareForWorkUnits( m_pInfo->m_nWorkUnits ); + + m_WULookup.Reset( pInfo->m_nWorkUnits ); + while ( m_WULookup.FirstPossibleIndex() < m_WULookup.PastPossibleIndex() ) + { + VMPI_DispatchNextMessage( 200 ); + + VMPITracker_HandleDebugKeypresses(); + + if ( g_pDistributeWorkCallbacks && g_pDistributeWorkCallbacks->Update() ) + break; + } + } + + virtual void OnWorkerReady( int iSource ) + { + AssignWUsToWorker( iSource ); + } + + virtual bool HandleWorkUnitResults( WUIndexType iWorkUnit ) + { + CWULookupInfo *pLookup = NULL; + if ( iWorkUnit >= m_WULookup.FirstPossibleIndex() && iWorkUnit < m_WULookup.PastVisibleIndex() ) + pLookup = &m_WULookup.Get( iWorkUnit ); + + if ( !pLookup || pLookup->m_iWUInfo == -1 ) + return false; + + // Mark this WU finished and remove it from the list of pending WUs. + m_WUInfo.Remove( pLookup->m_iWUInfo ); + pLookup->m_iWUInfo = -1; + + + // Get rid of the WU from its partition. + int iPartition = pLookup->m_iPartition; + CPartitionInfo *pPartition = m_Partitions[iPartition]; + pPartition->m_WUs.Remove( pLookup->m_iPartitionListIndex ); + + // Shrink the window of the lookup work units + if ( iWorkUnit == m_WULookup.FirstPossibleIndex() ) + { + WUIndexType kwu = iWorkUnit; + for ( WUIndexType kwuEnd = m_WULookup.PastVisibleIndex(); kwu < kwuEnd; ++ kwu ) + { + if ( -1 != m_WULookup.Get( kwu ).m_iWUInfo && kwu > iWorkUnit ) + break; + } + m_WULookup.ShrinkWindow( kwu - 1 ); + } + + // Give the worker some new work if need be. + if ( pPartition->m_WUs.Count() == 0 ) + { + int iPartitionWorker = pPartition->m_iWorker; + delete pPartition; + m_Partitions.Remove( iPartition ); + + // If there are any more WUs remaining, give the worker from this partition some more of them. + if ( m_WULookup.FirstPossibleIndex() < m_WULookup.PastPossibleIndex() ) + { + AssignWUsToWorker( iPartitionWorker ); + } + } + + uint64 iDoneWorkUnits = g_MasterWorkUnitsTracker.WorkUnitFinished( iWorkUnit ); + if ( iDoneWorkUnits && g_pDistributeWorkCallbacks ) + { + g_pDistributeWorkCallbacks->OnWorkUnitsCompleted( iDoneWorkUnits ); + } + + return true; + } + + virtual void DisconnectHandler( int workerID ) + { + int iPartitionLookup = FindPartitionByWorker( workerID ); + if ( iPartitionLookup != -1 ) + { + // Mark this guy's partition as unowned so another worker can get it. + CPartitionInfo *pPartition = m_Partitions[iPartitionLookup]; + pPartition->m_iWorker = -1; + } + } + + CPartitionInfo* AddPartition( int iWorker ) + { + CPartitionInfo *pNew = new CPartitionInfo; + pNew->m_iPartition = m_Partitions.AddToTail( pNew ); + pNew->m_iWorker = iWorker; + return pNew; + } + + bool SplitWUsPartition( CPartitionInfo *pPartitionLarge, + CPartitionInfo **ppFirstHalf, CPartitionInfo **ppSecondHalf, + int iFirstHalfWorker, int iSecondHalfWorker ) + { + int nCount = pPartitionLarge->m_WUs.Count(); + + if ( nCount > 1 ) // Allocate the partitions for the two workers + { + *ppFirstHalf = AddPartition( iFirstHalfWorker ); + *ppSecondHalf = AddPartition( iSecondHalfWorker ); + } + else // Specially transfer a partition with too few work units + { + *ppFirstHalf = NULL; + *ppSecondHalf = AddPartition( iSecondHalfWorker ); + } + + // Prepare for transfer + CPartitionInfo *arrNewParts[2] = { *ppFirstHalf ? *ppFirstHalf : *ppSecondHalf, *ppSecondHalf }; + + // Transfer the work units: + // alternate first/second halves + // don't put more than "half deal units" tasks into the second half + // e.g. { 1, 2, 3, 4 } + // becomes: 1st half { 1, 2 }, 2nd half { 3, 4 } + for ( int k = 0; k < nCount; ++ k ) + { + int iHead = pPartitionLarge->m_WUs.Head(); + WUIndexType iWU = pPartitionLarge->m_WUs[ iHead ]; + pPartitionLarge->m_WUs.Remove( iHead ); + + /* + int nHalf = !!( ( k % 2 ) || ( k >= nCount - 1 ) ); + if ( k == 5 ) // no more than 2 jobs to branch off + arrNewParts[ 1 ] = arrNewParts[ 0 ]; + */ + int nHalf = !( k < nCount/2 ); + CPartitionInfo *pTo = arrNewParts[ nHalf ]; + + CWULookupInfo &li = m_WULookup.Get( iWU ); + li.m_iPartition = pTo->m_iPartition; + li.m_iPartitionListIndex = pTo->m_WUs.AddToTail( iWU ); + } + + // LogPartitionsWorkUnits( pInfo ); + return true; + } + + void AssignWUsToWorker( int iWorker ) + { + // Get rid of this worker's old partition. + int iPrevious = FindPartitionByWorker( iWorker ); + if ( iPrevious != -1 ) + { + delete m_Partitions[iPrevious]; + m_Partitions.Remove( iPrevious ); + } + + if ( g_iVMPIVerboseLevel >= 1 ) + Msg( "A" ); + + + CVisibleWindowVector< CWULookupInfo > &vlkup = m_WULookup; + if ( CommandLine()->FindParm( "-mpi_NoScheduler" ) ) + { + Warning( "\n\n-mpi_NoScheduler found: Warning - this should only be used for testing and with 1 worker!\n\n" ); + vlkup.ExpandWindow( m_pInfo->m_nWorkUnits ); + CPartitionInfo *pPartition = AddPartition( iWorker ); + for ( int i=0; i < m_pInfo->m_nWorkUnits; i++ ) + { + CWorkUnitInfo info; + info.m_iWorkUnit = i; + + CWULookupInfo &li = vlkup.Get( i ); + li.m_iPartition = pPartition->m_iPartition; + li.m_iPartitionListIndex = pPartition->m_WUs.AddToTail( i ); + li.m_iWUInfo = m_WUInfo.AddToTail( info ); + } + + SendPartitionToWorker( pPartition, iWorker ); + return; + } + + + // Any partitions abandoned by workers? + int iAbandonedPartition = FindPartitionByWorker( -1 ); + if ( -1 != iAbandonedPartition ) + { + CPartitionInfo *pPartition = m_Partitions[ iAbandonedPartition ]; + pPartition->m_iWorker = iWorker; + SendPartitionToWorker( pPartition, iWorker ); + } + + // Any absolutely untouched partitions yet? + else if ( vlkup.PastVisibleIndex() < vlkup.PastPossibleIndex() ) + { + // Figure out how many WUs to include in a batch + int numWusToDeal = s_numWusToDeal; + if ( numWusToDeal <= 0 ) + { + uint64 uiFraction = vlkup.PastPossibleIndex() / g_nMaxWorkerCount; + Assert( uiFraction < INT_MAX/2 ); + + numWusToDeal = int( uiFraction ); + if ( numWusToDeal <= 0 ) + numWusToDeal = 8; + } + + // Allocate room for upcoming work units lookup + WUIndexType iBegin = vlkup.PastVisibleIndex(); + WUIndexType iEnd = min( iBegin + g_nMaxWorkerCount * numWusToDeal, vlkup.PastPossibleIndex() ); + vlkup.ExpandWindow( iEnd - 1 ); + + // Allocate a partition + size_t numPartitions = min( ( size_t )(iEnd - iBegin), ( size_t )g_nMaxWorkerCount ); + CArrayAutoPtr< CPartitionInfo * > spArrPartitions( new CPartitionInfo* [ numPartitions ] ); + CPartitionInfo **arrPartitions = spArrPartitions.Get(); + + arrPartitions[0] = AddPartition( iWorker ); + for ( size_t k = 1; k < numPartitions; ++ k ) + arrPartitions[k] = AddPartition( -1 ); + + // Assign upcoming work units to the partitions. + for ( WUIndexType i = iBegin ; i < iEnd; ++ i ) + { + CWorkUnitInfo info; + info.m_iWorkUnit = i; + + CPartitionInfo *pPartition = arrPartitions[ size_t( (i - iBegin) % numPartitions ) ]; + + CWULookupInfo &li = vlkup.Get( i ); + li.m_iPartition = pPartition->m_iPartition; + li.m_iPartitionListIndex = pPartition->m_WUs.AddToTail( i ); + li.m_iWUInfo = m_WUInfo.AddToTail( info ); + } + + // Now send this guy the WU list in his partition. + SendPartitionToWorker( arrPartitions[0], iWorker ); + } + + // Split one of the last partitions to finish sooner + else + { + // Find a partition to split. + int iPartToSplit = FindSoonestPartition(); + if ( iPartToSplit >= 0 ) + { + CPartitionInfo *pPartition = m_Partitions[ iPartToSplit ]; + + CPartitionInfo *pOldHalf = NULL, *pNewHalf = NULL; + int iOldWorker = pPartition->m_iWorker, iNewWorker = iWorker; + if ( SplitWUsPartition( pPartition, &pOldHalf, &pNewHalf, iOldWorker, iNewWorker ) ) + { + if ( pOldHalf ) + SendPartitionToWorker( pOldHalf, iOldWorker ); + if ( pNewHalf ) + SendPartitionToWorker( pNewHalf, iNewWorker ); + + // Delete the partition that got split + Assert( pPartition->m_WUs.Count() == 0 ); + delete pPartition; + m_Partitions.Remove( iPartToSplit ); + } + } + } + } + + int FindSoonestPartition() + { + CUtlLinkedList < CPartitionInfo *, int > &lst = m_Partitions; + + // Sorted partitions + CUtlMap< CPartitionInfo::PartitionWUs *, int > sortedPartitions ( CompareSoonestWorkUnitSets ); + sortedPartitions.EnsureCapacity( lst.Count() ); + FOR_EACH_LL( lst, i ) + { + sortedPartitions.Insert( &lst[i]->m_WUs, i ); + } + + if ( sortedPartitions.Count() ) + { + return sortedPartitions.Element( sortedPartitions.FirstInorder() ); + } + + return lst.Head(); + } + + int FindPartitionByWorker( int iWorker ) + { + FOR_EACH_LL( m_Partitions, i ) + { + if ( m_Partitions[i]->m_iWorker == iWorker ) + return i; + } + return -1; + } + + void SendPartitionToWorker( CPartitionInfo *pPartition, int iWorker ) + { + // Stuff the next nWUs work units into the buffer. + MessageBuffer mb; + PrepareDistributeWorkHeader( &mb, DW_SUBPACKETID_WU_ASSIGNMENT ); + + FOR_EACH_LL( pPartition->m_WUs, i ) + { + WUIndexType iWU = pPartition->m_WUs[i]; + mb.write( &iWU, sizeof( iWU ) ); + VMPITracker_WorkUnitSentToWorker( ( int ) iWU, iWorker ); + } + + VMPI_SendData( mb.data, mb.getLen(), iWorker ); + } + + virtual bool HandlePacket( MessageBuffer *pBuf, int iSource, bool bIgnoreContents ) + { + return false; + } + +private: + + CDSInfo *m_pInfo; + + CUtlLinkedList<CPartitionInfo*,int> m_Partitions; + CVisibleWindowVector<CWULookupInfo> m_WULookup; // Map work unit index to CWorkUnitInfo. + CUtlLinkedList<CWorkUnitInfo,int> m_WUInfo; // Sorted with most elegible WU at the head. +}; + + + +class CDistributor_DefaultWorker : public IWorkUnitDistributorWorker +{ +public: + virtual void Release() + { + delete this; + } + + virtual void Init( CDSInfo *pInfo ) + { + } + + virtual bool GetNextWorkUnit( WUIndexType *pWUIndex ) + { + CCriticalSectionLock csLock( &m_CS ); + csLock.Lock(); + + // NOTE: this is called from INSIDE worker threads. + if ( m_WorkUnits.Count() == 0 ) + { + return false; + } + else + { + *pWUIndex = m_WorkUnits[ m_WorkUnits.Head() ]; + m_WorkUnits.Remove( m_WorkUnits.Head() ); + return true; + } + } + + virtual void NoteLocalWorkUnitCompleted( WUIndexType iWU ) + { + } + + virtual bool HandlePacket( MessageBuffer *pBuf, int iSource, bool bIgnoreContents ) + { + if ( pBuf->data[1] == DW_SUBPACKETID_WU_ASSIGNMENT ) + { + // If the message wasn't even related to the current DistributeWork() call we're on, ignore it. + if ( bIgnoreContents ) + return true; + + if ( ((pBuf->getLen() - pBuf->getOffset()) % sizeof( WUIndexType )) != 0 ) + { + Error( "DistributeWork: invalid work units packet from master" ); + } + + // Parse out the work unit indices. + CCriticalSectionLock csLock( &m_CS ); + csLock.Lock(); + + m_WorkUnits.Purge(); + + int nIndices = (pBuf->getLen() - pBuf->getOffset()) / sizeof( WUIndexType ); + for ( int i=0; i < nIndices; i++ ) + { + WUIndexType iWU; + pBuf->read( &iWU, sizeof( iWU ) ); + + // Add the index to the list. + m_WorkUnits.AddToTail( iWU ); + } + + csLock.Unlock(); + + return true; + } + else + { + return false; + } + } + + // Threads eat up the list of WUs in here. + CCriticalSection m_CS; + CUtlLinkedList<WUIndexType, int> m_WorkUnits; // A list of work units assigned to this worker +}; + + + + +IWorkUnitDistributorMaster* CreateWUDistributor_DefaultMaster() +{ + return new CDistributor_DefaultMaster; +} +IWorkUnitDistributorWorker* CreateWUDistributor_DefaultWorker() +{ + return new CDistributor_DefaultWorker; +} diff --git a/utils/vmpi/vmpi_distribute_work_internal.h b/utils/vmpi/vmpi_distribute_work_internal.h new file mode 100644 index 0000000..74aa906 --- /dev/null +++ b/utils/vmpi/vmpi_distribute_work_internal.h @@ -0,0 +1,251 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//============================================================================= + +#ifndef VMPI_DISTRIBUTE_WORK_INTERNAL_H +#define VMPI_DISTRIBUTE_WORK_INTERNAL_H +#ifdef _WIN32 +#pragma once +#endif + + +#define VMPI_DISTRIBUTE_WORK_EXTRA_SUBPACKET_BASE 50 + + +typedef uint64 WUIndexType; +class CDSInfo; +extern bool g_bVMPIEarlyExit; + + +// These classes are overridden to handle the details of communicating and scheduling work units. +class IWorkUnitDistributorMaster +{ +public: + virtual void Release() = 0; + + virtual void DistributeWork_Master( CDSInfo *pInfo ) = 0; + + virtual void OnWorkerReady( int iWorker ) = 0; + virtual bool HandlePacket( MessageBuffer *pBuf, int iSource, bool bIgnoreContents ) = 0; + + // Called when the results for a work unit arrive. This function must return false if + // we've already received the results for this work unit. + virtual bool HandleWorkUnitResults( WUIndexType iWorkUnit ) = 0; + + virtual void DisconnectHandler( int workerID ) = 0; +}; + +class IWorkUnitDistributorWorker +{ +public: + virtual void Release() = 0; + + virtual void Init( CDSInfo *pInfo ) = 0; + + // Called by worker threads to get the next work unit to do. + virtual bool GetNextWorkUnit( WUIndexType *pWUIndex ) = 0; + + // Called by the worker threads after a work unit is completed. + virtual void NoteLocalWorkUnitCompleted( WUIndexType iWU ) = 0; + + // Called by the main thread when a packet comes in. + virtual bool HandlePacket( MessageBuffer *pBuf, int iSource, bool bIgnoreContents ) = 0; +}; + + + +template < typename T, typename Derived > +class CVisibleWindowVectorT : protected CUtlVector < T > +{ + typedef CUtlVector< T > BaseClass; + +public: + CVisibleWindowVectorT() : m_uiBase( 0 ), m_uiTotal( 0 ) {} + +public: + inline void PostInitElement( uint64 uiRealIdx, T &newElement ) { /* do nothing */ return; } + inline void PostInitElement( uint64 uiRealIdx, T &newElement, T const &x ) { newElement = x; } + +public: + // Resets the content and makes size "uiTotal" + void Reset( uint64 uiTotal ) { + BaseClass::RemoveAll(); + BaseClass::EnsureCapacity( min( 100, (int)uiTotal ) ); + m_uiBase = 0; + m_uiTotal = uiTotal; + } + + // Gets the element from the window, otherwise NULL + T & Get( uint64 idx ) { + T *pElement = (( idx >= m_uiBase && idx < m_uiBase + BaseClass::Count() ) ? ( BaseClass::Base() + size_t( idx - m_uiBase ) ) : NULL ); + Assert( pElement ); + return *pElement; + } + + // Expands the window to see the element by its index + void ExpandWindow( uint64 idxAccessible ) { + Assert( idxAccessible >= m_uiBase ); + if ( idxAccessible >= m_uiBase + BaseClass::Count() ) { + int iOldCount = BaseClass::Count(); + int iAddElements = int(idxAccessible - m_uiBase) - iOldCount + 1; + Assert( iOldCount + iAddElements <= 100000000 /* really need 100 Mb at once? */ ); + BaseClass::AddMultipleToTail( iAddElements ); + for ( int iNewCount = BaseClass::Count(); iOldCount < iNewCount; ++ iOldCount ) + static_cast< Derived * >( this )->PostInitElement( m_uiBase + iOldCount, BaseClass::Element( iOldCount ) ); + } + } + + // Expands the window and initializes the new elements to a given value + void ExpandWindow( uint64 idxAccessible, T const& x ) { + Assert( idxAccessible >= m_uiBase ); + if ( idxAccessible >= m_uiBase + BaseClass::Count() ) { + int iOldCount = BaseClass::Count(); + int iAddElements = int(idxAccessible - m_uiBase) - iOldCount + 1; + Assert( unsigned(iAddElements) <= 50000000 /* growing 50 Mb at once? */ ); + BaseClass::AddMultipleToTail( iAddElements ); + for ( int iNewCount = BaseClass::Count(); iOldCount < iNewCount; ++ iOldCount ) + static_cast< Derived * >( this )->PostInitElement( m_uiBase + iOldCount, BaseClass::Element( iOldCount ), x ); + } + } + + // Shrinks the window to drop some of the elements from the head + void ShrinkWindow( uint64 idxDrop ) { + Assert( idxDrop >= m_uiBase && idxDrop <= m_uiBase + BaseClass::Count() ); + if ( idxDrop >= m_uiBase && idxDrop <= m_uiBase + BaseClass::Count() ) { + int iDropElements = int( idxDrop - m_uiBase ) + 1; + m_uiBase += iDropElements; + BaseClass::RemoveMultiple( 0, min( iDropElements, BaseClass::Count() ) ); + } + } + + // First possible index in this vector (only past dropped items) + uint64 FirstPossibleIndex() const { return m_uiBase; } + + // Last possible index in this vector + uint64 PastPossibleIndex() const { return m_uiTotal; } + // Past visible window index in this vector + uint64 PastVisibleIndex() const { return m_uiBase + BaseClass::Count(); } + +protected: + uint64 m_uiBase, m_uiTotal; +}; + +template < typename T > +class CVisibleWindowVector : public CVisibleWindowVectorT < T, CVisibleWindowVector< T > > +{ +public: + CVisibleWindowVector() {} +}; + + +template < typename T > +T const * GenericFind( T const *pBegin, T const *pEnd, T const &x ) +{ + for ( ; pBegin != pEnd; ++ pBegin ) + if ( *pBegin == x ) + break; + return pBegin; +} + + +template < typename T > +T * GenericFind( T *pBegin, T *pEnd, T const &x ) +{ + for ( ; pBegin != pEnd; ++ pBegin ) + if ( *pBegin == x ) + break; + return pBegin; +} + + +class CWorkerInfo +{ +public: + ProcessWorkUnitFn m_pProcessFn; + CVisibleWindowVector<WUIndexType> m_WorkUnitsRunning; // A list of work units currently running, index is the thread index + CCriticalSection m_WorkUnitsRunningCS; +}; + + +class CMasterInfo +{ +public: + + // Only used by the master. + ReceiveWorkUnitFn m_ReceiveFn; +}; + + +class CDSInfo +{ +public: + inline void WriteWUIndex( WUIndexType iWU, MessageBuffer *pBuf ) + { + if ( m_nWorkUnits <= 0xFFFF ) + { + Assert( iWU <= 0xFFFF ); + unsigned short val = (unsigned short)iWU; + pBuf->write( &val, sizeof( val ) ); + } + else if ( m_nWorkUnits <= 0xFFFFFFFF ) + { + Assert( iWU <= 0xFFFF ); + unsigned int val = (unsigned int)iWU; + pBuf->write( &val, sizeof( val ) ); + } + else + { + pBuf->write( &iWU, sizeof( iWU ) ); + } + } + + inline void ReadWUIndex( WUIndexType *pWU, MessageBuffer *pBuf ) + { + if ( m_nWorkUnits <= 0xFFFF ) + { + unsigned short val; + pBuf->read( &val, sizeof( val ) ); + *pWU = val; + } + else if ( m_nWorkUnits <= 0xFFFFFFFF ) + { + unsigned int val; + pBuf->read( &val, sizeof( val ) ); + *pWU = val; + } + else + { + pBuf->read( pWU, sizeof( *pWU ) ); + } + } + +public: + CWorkerInfo m_WorkerInfo; + CMasterInfo m_MasterInfo; + + bool m_bMasterReady; // Set to true when the master is ready to go. + bool m_bMasterFinished; + WUIndexType m_nWorkUnits; + char m_cPacketID; +}; + + +// Called to write the packet ID, the subpacket ID, and the ID of which DistributeWork() call we're at. +void PrepareDistributeWorkHeader( MessageBuffer *pBuf, unsigned char cSubpacketID ); + +// Called from threads on the master to process a completed work unit. +void NotifyLocalMasterCompletedWorkUnit( WUIndexType iWorkUnit ); +void CheckLocalMasterCompletedWorkUnits(); + + +// Creation functions for different distributors. +IWorkUnitDistributorMaster* CreateWUDistributor_DefaultMaster(); +IWorkUnitDistributorWorker* CreateWUDistributor_DefaultWorker(); + +IWorkUnitDistributorMaster* CreateWUDistributor_SDKMaster(); +IWorkUnitDistributorWorker* CreateWUDistributor_SDKWorker(); + + +#endif // VMPI_DISTRIBUTE_WORK_INTERNAL_H diff --git a/utils/vmpi/vmpi_distribute_work_sdk.cpp b/utils/vmpi/vmpi_distribute_work_sdk.cpp new file mode 100644 index 0000000..71b03e8 --- /dev/null +++ b/utils/vmpi/vmpi_distribute_work_sdk.cpp @@ -0,0 +1,699 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//============================================================================= + +#include "vmpi.h" +#include "vmpi_distribute_work.h" +#include "tier0/platform.h" +#include "tier0/dbg.h" +#include "utlvector.h" +#include "utllinkedlist.h" +#include "vmpi_dispatch.h" +#include "pacifier.h" +#include "vstdlib/random.h" +#include "mathlib/mathlib.h" +#include "threadhelpers.h" +#include "threads.h" +#include "tier1/strtools.h" +#include "tier1/utlmap.h" +#include "tier1/smartptr.h" +#include "tier0/icommandline.h" +#include "cmdlib.h" +#include "vmpi_distribute_tracker.h" +#include "vmpi_distribute_work_internal.h" + + + +#define DW_SUBPACKETID_SHUFFLE (VMPI_DISTRIBUTE_WORK_EXTRA_SUBPACKET_BASE+0) +#define DW_SUBPACKETID_REQUEST_SHUFFLE (VMPI_DISTRIBUTE_WORK_EXTRA_SUBPACKET_BASE+1) +#define DW_SUBPACKETID_WUS_COMPLETED_LIST (VMPI_DISTRIBUTE_WORK_EXTRA_SUBPACKET_BASE+2) + + + +// This is a pretty simple iterator. Basically, it holds a matrix of numbers. +// Each row is assigned to a worker, and the worker just walks through his row. +// +// When a worker reaches the end of his row, it gets a little trickier. +// They'll start doing their neighbor's row +// starting at the back and continue on. At about this time, the master should reshuffle the +// remaining work units to evenly distribute them amongst the workers. +class CWorkUnitWalker +{ +public: + CWorkUnitWalker() + { + m_nWorkUnits = 0; + } + + // This is all that's needed for it to start assigning work units. + void Init( WUIndexType matrixWidth, WUIndexType matrixHeight, WUIndexType nWorkUnits ) + { + m_nWorkUnits = nWorkUnits; + m_MatrixWidth = matrixWidth; + m_MatrixHeight = matrixHeight; + Assert( m_MatrixWidth * m_MatrixHeight >= nWorkUnits ); + + m_WorkerInfos.RemoveAll(); + m_WorkerInfos.EnsureCount( m_MatrixHeight ); + for ( int i=0; i < m_MatrixHeight; i++ ) + { + m_WorkerInfos[i].m_iStartWorkUnit = matrixWidth * i; + m_WorkerInfos[i].m_iWorkUnitOffset = 0; + } + } + + // This is the main function of the shuffler + bool GetNextWorkUnit( int iWorker, WUIndexType *pWUIndex, bool *bWorkerFinishedHisColumn ) + { + if ( iWorker < 0 || iWorker >= m_WorkerInfos.Count() ) + { + Assert( false ); + return false; + } + + // If this worker has walked through all the work units, then he's done. + CWorkerInfo *pWorker = &m_WorkerInfos[iWorker]; + if ( pWorker->m_iWorkUnitOffset >= m_nWorkUnits ) + return false; + + // If we've gone past the end of our work unit list, then we start at the BACK of the other rows of work units + // in the hopes that we won't collide with the guy working there. We also should tell the master to reshuffle. + WUIndexType iWorkUnitOffset = pWorker->m_iWorkUnitOffset; + if ( iWorkUnitOffset >= m_MatrixWidth ) + { + WUIndexType xOffset = iWorkUnitOffset % m_MatrixWidth; + WUIndexType yOffset = iWorkUnitOffset / m_MatrixWidth; + xOffset = m_MatrixWidth - xOffset - 1; + iWorkUnitOffset = yOffset * m_MatrixWidth + xOffset; + *bWorkerFinishedHisColumn = true; + } + else + { + *bWorkerFinishedHisColumn = false; + } + + *pWUIndex = (pWorker->m_iStartWorkUnit + iWorkUnitOffset) % m_nWorkUnits; + ++pWorker->m_iWorkUnitOffset; + return true; + } + + +private: + class CWorkerInfo + { + public: + WUIndexType m_iStartWorkUnit; + WUIndexType m_iWorkUnitOffset; // Which work unit in my list of work units am I working on? + }; + + WUIndexType m_nWorkUnits; + WUIndexType m_MatrixWidth; + WUIndexType m_MatrixHeight; + CUtlVector<CWorkerInfo> m_WorkerInfos; +}; + + +class IShuffleRequester +{ +public: + virtual void RequestShuffle() = 0; +}; + + +// This is updated every time the master decides to reshuffle. +// In-between shuffles, you can call NoteWorkUnitCompleted when a work unit is completed +// and it'll avoid returning that work unit from GetNextWorkUnit again, but it WON'T +class CShuffledWorkUnitWalker +{ +public: + void Init( WUIndexType nWorkUnits, IShuffleRequester *pRequester ) + { + m_iLastShuffleRequest = 0; + m_iCurShuffle = 1; + m_flLastShuffleTime = Plat_FloatTime(); + m_pShuffleRequester = pRequester; + + int nBytes = PAD_NUMBER( nWorkUnits, 8 ) / 8; + m_CompletedWUBits.SetSize( nBytes ); + m_LocalCompletedWUBits.SetSize( nBytes ); + for ( WUIndexType i=0; i < m_CompletedWUBits.Count(); i++ ) + m_LocalCompletedWUBits[i] = m_CompletedWUBits[i] = 0; + + // Setup our list of work units remaining. + for ( WUIndexType iWU=0; iWU < nWorkUnits; iWU++ ) + { + // Note: we're making an assumption here that if we add entries to a CUtlLinkedList in ascending order, their indices + // will be ascending 1-by-1 as well. If that assumption breaks, we can create an extra array here to map WU indices to the linked list indices. + WUIndexType index = m_WorkUnitsRemaining.AddToTail( iWU ); + if ( index != iWU ) + { + Error( "CShuffledWorkUnitWalker: assumption on CUtlLinkedList indexing failed.\n" ); + } + } + } + + void Shuffle( int nWorkers ) + { + if ( nWorkers == 0 ) + return; + + ++m_iCurShuffle; + m_flLastShuffleTime = Plat_FloatTime(); + + CCriticalSectionLock csLock( &m_CS ); + csLock.Lock(); + + m_WorkUnitsMap.RemoveAll(); + m_WorkUnitsMap.EnsureCount( m_WorkUnitsRemaining.Count() ); + + // Here's the shuffle. The CWorkUnitWalker is going to walk each worker through its own group from 0-W, + // and our job is to interleave it so when worker 0 goes [0,1,2] and worker 1 goes [100,101,102], they're actually + // doing [0,N,2N] and [1,N+1,2N+1] where N=# of workers. + + // The grid is RxW long, and R*W is >= nWorkUnits. + // R = # units per worker = width of the matrix + // W = # workers = height of the matrix + WUIndexType matrixHeight = nWorkers; + WUIndexType matrixWidth = m_WorkUnitsRemaining.Count() / matrixHeight; + if ( (m_WorkUnitsRemaining.Count() % matrixHeight) != 0 ) + ++matrixWidth; + + Assert( matrixWidth * matrixHeight >= m_WorkUnitsRemaining.Count() ); + + WUIndexType iWorkUnit = 0; + FOR_EACH_LL( m_WorkUnitsRemaining, i ) + { + WUIndexType xCoord = iWorkUnit / matrixHeight; + WUIndexType yCoord = iWorkUnit % matrixHeight; + Assert( xCoord < matrixWidth ); + Assert( yCoord < matrixHeight ); + + m_WorkUnitsMap[yCoord*matrixWidth+xCoord] = m_WorkUnitsRemaining[i]; + ++iWorkUnit; + } + + m_Walker.Init( matrixWidth, matrixHeight, m_WorkUnitsRemaining.Count() ); + } + + // Threadsafe. + bool Thread_IsWorkUnitCompleted( WUIndexType iWU ) + { + CCriticalSectionLock csLock( &m_CS ); + csLock.Lock(); + + byte val = m_CompletedWUBits[iWU >> 3] & (1 << (iWU & 7)); + return (val != 0); + } + + WUIndexType Thread_NumWorkUnitsRemaining() + { + CCriticalSectionLock csLock( &m_CS ); + csLock.Lock(); + + return m_WorkUnitsRemaining.Count(); + } + + bool Thread_GetNextWorkUnit( int iWorker, WUIndexType *pWUIndex ) + { + CCriticalSectionLock csLock( &m_CS ); + csLock.Lock(); + + while ( 1 ) + { + WUIndexType iUnmappedWorkUnit; + bool bWorkerFinishedHisColumn; + if ( !m_Walker.GetNextWorkUnit( iWorker, &iUnmappedWorkUnit, &bWorkerFinishedHisColumn ) ) + return false; + + // If we've done all the work units assigned to us in the last shuffle, then request a reshuffle. + if ( bWorkerFinishedHisColumn ) + HandleWorkerFinishedColumn(); + + // Check the pending list. + *pWUIndex = m_WorkUnitsMap[iUnmappedWorkUnit]; + byte bIsCompleted = m_CompletedWUBits[*pWUIndex >> 3] & (1 << (*pWUIndex & 7)); + byte bIsCompletedLocally = m_LocalCompletedWUBits[*pWUIndex >> 3] & (1 << (*pWUIndex & 7)); + if ( !bIsCompleted && !bIsCompletedLocally ) + return true; + } + } + + void HandleWorkerFinishedColumn() + { + if ( m_iLastShuffleRequest != m_iCurShuffle ) + { + double flCurTime = Plat_FloatTime(); + if ( flCurTime - m_flLastShuffleTime > 2.0f ) + { + m_pShuffleRequester->RequestShuffle(); + m_iLastShuffleRequest = m_iCurShuffle; + } + } + } + + void Thread_NoteWorkUnitCompleted( WUIndexType iWU ) + { + CCriticalSectionLock csLock( &m_CS ); + csLock.Lock(); + + byte val = m_CompletedWUBits[iWU >> 3] & (1 << (iWU & 7)); + if ( val == 0 ) + { + m_WorkUnitsRemaining.Remove( iWU ); + m_CompletedWUBits[iWU >> 3] |= (1 << (iWU & 7)); + } + } + + void Thread_NoteLocalWorkUnitCompleted( WUIndexType iWU ) + { + CCriticalSectionLock csLock( &m_CS ); + csLock.Lock(); + m_LocalCompletedWUBits[iWU >> 3] |= (1 << (iWU & 7)); + } + + CRC32_t GetShuffleCRC() + { +#ifdef _DEBUG + static bool bCalcShuffleCRC = true; +#else + static bool bCalcShuffleCRC = VMPI_IsParamUsed( mpi_CalcShuffleCRC ); +#endif + if ( bCalcShuffleCRC ) + { + CCriticalSectionLock csLock( &m_CS ); + csLock.Lock(); + + CRC32_t ret; + CRC32_Init( &ret ); + + FOR_EACH_LL( m_WorkUnitsRemaining, i ) + { + WUIndexType iWorkUnit = m_WorkUnitsRemaining[i]; + CRC32_ProcessBuffer( &ret, &iWorkUnit, sizeof( iWorkUnit ) ); + } + + for ( int i=0; i < m_WorkUnitsMap.Count(); i++ ) + { + WUIndexType iWorkUnit = m_WorkUnitsMap[i]; + CRC32_ProcessBuffer( &ret, &iWorkUnit, sizeof( iWorkUnit ) ); + } + + CRC32_Final( &ret ); + return ret; + } + else + { + return false; + } + } + +private: + // These are PENDING WU completions until we call Shuffle() again, at which point we actually reorder the list + // based on the completed WUs. + CUtlVector<byte> m_CompletedWUBits; // Bit vector of completed WUs. + CUtlLinkedList<WUIndexType, WUIndexType> m_WorkUnitsRemaining; + CUtlVector<WUIndexType> m_WorkUnitsMap; // Maps the 0-N indices in the CWorkUnitWalker to the list of remaining work units. + + // Helps us avoid some duplicates that happen during shuffling if we've completed some WUs and sent them + // to the master, but the master hasn't included them in the DW_SUBPACKETID_WUS_COMPLETED_LIST yet. + CUtlVector<byte> m_LocalCompletedWUBits; // Bit vector of completed WUs. + + // Used to control how frequently we request a reshuffle. + unsigned int m_iCurShuffle; + unsigned int m_iLastShuffleRequest; // The index of the shuffle we last requested a reshuffle on (don't request a reshuffle on the same one). + double m_flLastShuffleTime; + IShuffleRequester *m_pShuffleRequester; + + CWorkUnitWalker m_Walker; + CCriticalSection m_CS; +}; + + + +class CDistributor_SDKMaster : public IWorkUnitDistributorMaster, public IShuffleRequester +{ +public: + virtual void Release() + { + delete this; + } + + static void Master_WorkerThread_Static( int iThread, void *pUserData ) + { + ((CDistributor_SDKMaster*)pUserData)->Master_WorkerThread( iThread ); + } + + void Master_WorkerThread( int iThread ) + { + while ( m_WorkUnitWalker.Thread_NumWorkUnitsRemaining() > 0 && !g_bVMPIEarlyExit ) + { + WUIndexType iWU; + if ( !m_WorkUnitWalker.Thread_GetNextWorkUnit( 0, &iWU ) ) + { + // Wait until there are some WUs to do. + VMPI_Sleep( 10 ); + continue; + } + + // Do this work unit. + m_WorkUnitWalker.Thread_NoteLocalWorkUnitCompleted( iWU ); // We do this before it's completed because otherwise if a Shuffle() occurs, + // the other thread might happen to pickup this work unit and we don't want that. + m_pInfo->m_WorkerInfo.m_pProcessFn( iThread, iWU, NULL ); + NotifyLocalMasterCompletedWorkUnit( iWU ); + } + } + + virtual void DistributeWork_Master( CDSInfo *pInfo ) + { + m_pInfo = pInfo; + m_bForceShuffle = false; + m_bShuffleRequested = false; + m_flLastShuffleRequestServiceTime = Plat_FloatTime(); + + // Spawn idle-priority worker threads right here. + m_bUsingMasterLocalThreads = (pInfo->m_WorkerInfo.m_pProcessFn != 0); + if ( VMPI_IsParamUsed( mpi_NoMasterWorkerThreads ) ) + { + Msg( "%s found. No worker threads will be created.\n", VMPI_GetParamString( mpi_NoMasterWorkerThreads ) ); + m_bUsingMasterLocalThreads = false; + } + m_WorkUnitWalker.Init( pInfo->m_nWorkUnits, this ); + Shuffle(); + + if ( m_bUsingMasterLocalThreads ) + RunThreads_Start( Master_WorkerThread_Static, this, k_eRunThreadsPriority_Idle ); + + uint64 lastShuffleTime = Plat_MSTime(); + while ( m_WorkUnitWalker.Thread_NumWorkUnitsRemaining() > 0 ) + { + VMPI_DispatchNextMessage( 200 ); + CheckLocalMasterCompletedWorkUnits(); + + VMPITracker_HandleDebugKeypresses(); + if ( g_pDistributeWorkCallbacks && g_pDistributeWorkCallbacks->Update() ) + break; + + // Reshuffle the work units optimally every certain interval. + if ( m_bForceShuffle || CheckShuffleRequest() ) + { + Shuffle(); + lastShuffleTime = Plat_MSTime(); + m_bForceShuffle = false; + } + } + + RunThreads_End(); + } + + virtual void RequestShuffle() + { + m_bShuffleRequested = true; + } + + bool CheckShuffleRequest() + { + if ( m_bShuffleRequested ) + { + double flCurTime = Plat_FloatTime(); + if ( flCurTime - m_flLastShuffleRequestServiceTime > 2.0f ) // Only handle shuffle requests every so often. + { + m_flLastShuffleRequestServiceTime = flCurTime; + m_bShuffleRequested = false; + return true; + } + } + + return false; + } + + void Shuffle() + { + // Build a list of who's working. + CUtlVector<unsigned short> whosWorking; + if ( m_bUsingMasterLocalThreads ) + { + whosWorking.AddToTail( VMPI_MASTER_ID ); + Assert( VMPI_MASTER_ID == 0 ); + } + + { + CWorkersReady *pWorkersReady = m_WorkersReadyCS.Lock(); + for ( int i=0; i < pWorkersReady->m_WorkersReady.Count(); i++ ) + { + int iWorker = pWorkersReady->m_WorkersReady[i]; + if ( VMPI_IsProcConnected( iWorker ) ) + whosWorking.AddToTail( iWorker ); + } + m_WorkersReadyCS.Unlock(); + } + + // Before sending the shuffle command, tell any of these active workers about the pending WUs completed. + CWUsCompleted *pWUsCompleted = m_WUsCompletedCS.Lock(); + + m_WUSCompletedMessageBuffer.setLen( 0 ); + if ( BuildWUsCompletedMessage( pWUsCompleted->m_Pending, m_WUSCompletedMessageBuffer ) > 0 ) + { + for ( int i=m_bUsingMasterLocalThreads; i < whosWorking.Count(); i++ ) + { + VMPI_SendData( m_WUSCompletedMessageBuffer.data, m_WUSCompletedMessageBuffer.getLen(), whosWorking[i] ); + } + } + pWUsCompleted->m_Completed.AddMultipleToTail( pWUsCompleted->m_Pending.Count(), pWUsCompleted->m_Pending.Base() ); // Add the pending ones to the full list now. + pWUsCompleted->m_Pending.RemoveAll(); + + m_WUsCompletedCS.Unlock(); + + // Shuffle ourselves. + m_WorkUnitWalker.Shuffle( whosWorking.Count() ); + + // Send the shuffle command to the workers. + MessageBuffer mb; + PrepareDistributeWorkHeader( &mb, DW_SUBPACKETID_SHUFFLE ); + + unsigned short nWorkers = whosWorking.Count(); + mb.write( &nWorkers, sizeof( nWorkers ) ); + + CRC32_t shuffleCRC = m_WorkUnitWalker.GetShuffleCRC(); + mb.write( &shuffleCRC, sizeof( shuffleCRC ) ); + + // Now for each worker, assign him an index in the shuffle and send the shuffle command. + int workerIDPos = mb.getLen(); + unsigned short id = 0; + mb.write( &id, sizeof( id ) ); + for ( int i=m_bUsingMasterLocalThreads; i < whosWorking.Count(); i++ ) + { + id = (unsigned short)i; + mb.update( workerIDPos, &id, sizeof( id ) ); + VMPI_SendData( mb.data, mb.getLen(), whosWorking[i] ); + } + } + + int BuildWUsCompletedMessage( CUtlVector<WUIndexType> &wusCompleted, MessageBuffer &mb ) + { + PrepareDistributeWorkHeader( &mb, DW_SUBPACKETID_WUS_COMPLETED_LIST ); + m_pInfo->WriteWUIndex( wusCompleted.Count(), &mb ); + for ( int i=0; i < wusCompleted.Count(); i++ ) + { + m_pInfo->WriteWUIndex( wusCompleted[i], &mb ); + } + return wusCompleted.Count(); + } + + virtual void OnWorkerReady( int iSource ) + { + CWorkersReady *pWorkersReady = m_WorkersReadyCS.Lock(); + if ( pWorkersReady->m_WorkersReady.Find( iSource ) == -1 ) + { + pWorkersReady->m_WorkersReady.AddToTail( iSource ); + + // Get this guy up to speed on which WUs are done. + { + CWUsCompleted *pWUsCompleted = m_WUsCompletedCS.Lock(); + m_WUSCompletedMessageBuffer.setLen( 0 ); + BuildWUsCompletedMessage( pWUsCompleted->m_Completed, m_WUSCompletedMessageBuffer ); + m_WUsCompletedCS.Unlock(); + } + + VMPI_SendData( m_WUSCompletedMessageBuffer.data, m_WUSCompletedMessageBuffer.getLen(), iSource ); + m_bForceShuffle = true; + } + m_WorkersReadyCS.Unlock(); + } + + virtual bool HandleWorkUnitResults( WUIndexType iWorkUnit ) + { + return Thread_HandleWorkUnitResults( iWorkUnit ); + } + + bool Thread_HandleWorkUnitResults( WUIndexType iWorkUnit ) + { + if ( m_WorkUnitWalker.Thread_IsWorkUnitCompleted( iWorkUnit ) ) + { + return false; + } + else + { + m_WorkUnitWalker.Thread_NoteWorkUnitCompleted( iWorkUnit ); + + // We need the lock on here because our own worker threads can call into here. + CWUsCompleted *pWUsCompleted = m_WUsCompletedCS.Lock(); + pWUsCompleted->m_Pending.AddToTail( iWorkUnit ); + m_WUsCompletedCS.Unlock(); + return true; + } + } + + virtual bool HandlePacket( MessageBuffer *pBuf, int iSource, bool bIgnoreContents ) + { + if ( pBuf->data[1] == DW_SUBPACKETID_REQUEST_SHUFFLE ) + { + if ( bIgnoreContents ) + return true; + + m_bShuffleRequested = true; + } + return false; + } + + virtual void DisconnectHandler( int workerID ) + { + CWorkersReady *pWorkersReady = m_WorkersReadyCS.Lock(); + + if ( pWorkersReady->m_WorkersReady.Find( workerID ) != -1 ) + m_bForceShuffle = true; + + m_WorkersReadyCS.Unlock(); + } + +public: + CDSInfo *m_pInfo; + + class CWorkersReady + { + public: + CUtlVector<int> m_WorkersReady; // The list of workers who have said they're ready to participate. + }; + CCriticalSectionData<CWorkersReady> m_WorkersReadyCS; + + class CWUsCompleted + { + public: + CUtlVector<WUIndexType> m_Completed; // WUs completed that we have sent to workers. + CUtlVector<WUIndexType> m_Pending; // WUs completed that we haven't sent to workers. + }; + CCriticalSectionData<CWUsCompleted> m_WUsCompletedCS; + MessageBuffer m_WUSCompletedMessageBuffer; // Used to send lists of completed WUs. + int m_bUsingMasterLocalThreads; + + bool m_bForceShuffle; + bool m_bShuffleRequested; + double m_flLastShuffleRequestServiceTime; + + CShuffledWorkUnitWalker m_WorkUnitWalker; +}; + + +class CDistributor_SDKWorker : public IWorkUnitDistributorWorker, public IShuffleRequester +{ +public: + virtual void Init( CDSInfo *pInfo ) + { + m_iMyWorkUnitWalkerID = -1; + m_pInfo = pInfo; + m_WorkUnitWalker.Init( pInfo->m_nWorkUnits, this ); + } + + virtual void Release() + { + delete this; + } + + virtual bool GetNextWorkUnit( WUIndexType *pWUIndex ) + { + // If we don't have an ID yet, we haven't received a Shuffle() command, so we're waiting for that before working. + // TODO: we could do some random WUs here while we're waiting, although that could suck if the WUs take forever to do + // and they're duplicates. + if ( m_iMyWorkUnitWalkerID == -1 ) + return false; + + // Look in our current shuffled list of work units for the next one. + return m_WorkUnitWalker.Thread_GetNextWorkUnit( m_iMyWorkUnitWalkerID, pWUIndex ); + } + + virtual void NoteLocalWorkUnitCompleted( WUIndexType iWU ) + { + m_WorkUnitWalker.Thread_NoteLocalWorkUnitCompleted( iWU ); + } + + virtual bool HandlePacket( MessageBuffer *pBuf, int iSource, bool bIgnoreContents ) + { + // If it's a SHUFFLE message, then shuffle.. + if ( pBuf->data[1] == DW_SUBPACKETID_SHUFFLE ) + { + if ( bIgnoreContents ) + return true; + + unsigned short nWorkers, myID; + CRC32_t shuffleCRC; + pBuf->read( &nWorkers, sizeof( nWorkers ) ); + pBuf->read( &shuffleCRC, sizeof( shuffleCRC ) ); + pBuf->read( &myID, sizeof( myID ) ); + m_iMyWorkUnitWalkerID = myID; + + m_WorkUnitWalker.Shuffle( nWorkers ); + if ( m_WorkUnitWalker.GetShuffleCRC() != shuffleCRC ) + { + static int nWarnings = 1; + if ( ++nWarnings <= 2 ) + Warning( "\nShuffle CRC mismatch\n" ); + } + return true; + } + else if ( pBuf->data[1] == DW_SUBPACKETID_WUS_COMPLETED_LIST ) + { + if ( bIgnoreContents ) + return true; + + WUIndexType nCompleted; + m_pInfo->ReadWUIndex( &nCompleted, pBuf ); + for ( WUIndexType i=0; i < nCompleted; i++ ) + { + WUIndexType iWU; + m_pInfo->ReadWUIndex( &iWU, pBuf ); + m_WorkUnitWalker.Thread_NoteWorkUnitCompleted( iWU ); + } + + return true; + } + + return false; + } + + virtual void RequestShuffle() + { + // Ok.. request a reshuffle. + MessageBuffer mb; + PrepareDistributeWorkHeader( &mb, DW_SUBPACKETID_REQUEST_SHUFFLE ); + VMPI_SendData( mb.data, mb.getLen(), VMPI_MASTER_ID ); + } + +private: + CDSInfo *m_pInfo; + CShuffledWorkUnitWalker m_WorkUnitWalker; + int m_iMyWorkUnitWalkerID; +}; + + + +IWorkUnitDistributorMaster* CreateWUDistributor_SDKMaster() +{ + return new CDistributor_SDKMaster; +} + +IWorkUnitDistributorWorker* CreateWUDistributor_SDKWorker() +{ + return new CDistributor_SDKWorker; +} + diff --git a/utils/vmpi/vmpi_filesystem.cpp b/utils/vmpi/vmpi_filesystem.cpp new file mode 100644 index 0000000..815f918 --- /dev/null +++ b/utils/vmpi/vmpi_filesystem.cpp @@ -0,0 +1,366 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// + +#include "vmpi_filesystem_internal.h" +#include "tier1/utlbuffer.h" + + +bool g_bDisableFileAccess = false; + + +CBaseVMPIFileSystem *g_pBaseVMPIFileSystem = NULL; +IFileSystem *g_pOriginalPassThruFileSystem = NULL; + +void* GetVMPIFileSystem() +{ + return (IBaseFileSystem*)g_pBaseVMPIFileSystem; +} + +EXPOSE_INTERFACE_FN( GetVMPIFileSystem, IBaseFileSystem, BASEFILESYSTEM_INTERFACE_VERSION ) + + +IFileSystem* VMPI_FileSystem_Init( int maxMemoryUsage, IFileSystem *pPassThru ) +{ + Assert( g_bUseMPI ); + Assert( !g_pBaseVMPIFileSystem ); + g_pOriginalPassThruFileSystem = pPassThru; + + if ( g_bMPIMaster ) + { + extern CBaseVMPIFileSystem* CreateMasterVMPIFileSystem( int maxMemoryUsage, IFileSystem *pPassThru ); + CreateMasterVMPIFileSystem( maxMemoryUsage, pPassThru ); + } + else + { + extern CBaseVMPIFileSystem* CreateWorkerVMPIFileSystem(); + CreateWorkerVMPIFileSystem(); + } + + // The Create function should have set this. Normally, we'd set g_pBaseVMPIFileSystem right here, but + // the create functions may want to receive some messages, in which case they need to set g_pBaseVMPIFileSystem + // so the packets get routed appropriately. + Assert( g_pBaseVMPIFileSystem ); + return g_pBaseVMPIFileSystem; +} + + +IFileSystem* VMPI_FileSystem_Term() +{ + if ( g_pBaseVMPIFileSystem ) + { + g_pBaseVMPIFileSystem->Release(); + g_pBaseVMPIFileSystem = NULL; + + if ( g_iVMPIVerboseLevel >= 1 ) + { + if ( g_bMPIMaster ) + Msg( "Multicast send: %dk\n", (g_nMulticastBytesSent + 511) / 1024 ); + else + Msg( "Multicast recv: %dk\n", (g_nMulticastBytesReceived + 511) / 1024 ); + } + } + + IFileSystem *pRet = g_pOriginalPassThruFileSystem; + g_pOriginalPassThruFileSystem = NULL; + return pRet; +} + + +void VMPI_FileSystem_DisableFileAccess() +{ + g_bDisableFileAccess = true; +} + + +CreateInterfaceFn VMPI_FileSystem_GetFactory() +{ + return Sys_GetFactoryThis(); +} + + +void VMPI_FileSystem_CreateVirtualFile( const char *pFilename, const void *pData, unsigned long fileLength ) +{ + g_pBaseVMPIFileSystem->CreateVirtualFile( pFilename, pData, fileLength ); +} + + +// Register our packet ID. +bool FileSystemRecv( MessageBuffer *pBuf, int iSource, int iPacketID ) +{ + if ( g_pBaseVMPIFileSystem ) + return g_pBaseVMPIFileSystem->HandleFileSystemPacket( pBuf, iSource, iPacketID ); + else + return false; +} + + +CDispatchReg g_DispatchReg_FileSystem( VMPI_PACKETID_FILESYSTEM, FileSystemRecv ); + + + +// ------------------------------------------------------------------------------------------------------------------------ // +// CVMPIFile_Memory implementation. +// ------------------------------------------------------------------------------------------------------------------------ // + +void CVMPIFile_Memory::Init( const char *pData, long len, char chMode /* = 'b' */ ) +{ + m_pData = pData; + m_DataLen = len; + m_iCurPos = 0; + m_chMode = chMode; +} + +void CVMPIFile_Memory::Close() +{ + delete this; +} + +void CVMPIFile_Memory::Seek( int pos, FileSystemSeek_t seekType ) +{ + if ( seekType == FILESYSTEM_SEEK_HEAD ) + m_iCurPos = pos; + else if ( seekType == FILESYSTEM_SEEK_CURRENT ) + m_iCurPos += pos; + else + m_iCurPos = m_DataLen - pos; +} + +unsigned int CVMPIFile_Memory::Tell() +{ + return m_iCurPos; +} + +unsigned int CVMPIFile_Memory::Size() +{ + return m_DataLen; +} + +void CVMPIFile_Memory::Flush() +{ +} + +int CVMPIFile_Memory::Read( void* pOutput, int size ) +{ + Assert( m_iCurPos >= 0 ); + int nToRead = min( (int)(m_DataLen - m_iCurPos), size ); + + if ( m_chMode != 't' ) + { + memcpy( pOutput, &m_pData[m_iCurPos], nToRead ); + m_iCurPos += nToRead; + + return nToRead; + } + else + { + int iRead = 0; + const char *pData = m_pData + m_iCurPos; + int len = m_DataLen - m_iCurPos; + + // Perform crlf translation + while ( const char *crlf = ( const char * ) memchr( pData, '\r', len ) ) + { + int canCopy = min( size, crlf - pData ); + memcpy( pOutput, pData, canCopy ); + + m_iCurPos += canCopy; + pData += canCopy; + len -= canCopy; + + iRead += canCopy; + ( char * & ) pOutput += canCopy; + size -= canCopy; + + if ( size && len ) + { + if ( ( len > 1 ) && ( pData[1] == '\n' ) ) + { + ++ m_iCurPos; + ++ pData; + -- len; + } + + * ( char * & ) pOutput = *pData; + + ++ m_iCurPos; + ++ pData; + -- len; + + ++ iRead; + ++ ( char * & ) pOutput; + -- size; + } + else + break; + } + + if ( size && len ) + { + // No crlf characters left + int canCopy = min( size, len ); + memcpy( pOutput, pData, canCopy ); + + m_iCurPos += canCopy; + pData += canCopy; + len -= canCopy; + + iRead += canCopy; + ( char * & ) pOutput += canCopy; + size -= canCopy; + } + + return iRead; + } +} + +int CVMPIFile_Memory::Write( void const* pInput, int size ) +{ + Assert( false ); return 0; +} + + +// ------------------------------------------------------------------------------------------------------------------------ // +// CBaseVMPIFileSystem implementation. +// ------------------------------------------------------------------------------------------------------------------------ // + +CBaseVMPIFileSystem::~CBaseVMPIFileSystem() +{ +} + + +void CBaseVMPIFileSystem::Release() +{ + delete this; +} + + +void CBaseVMPIFileSystem::Close( FileHandle_t file ) +{ + if ( file ) + ((IVMPIFile*)file)->Close(); +} + +int CBaseVMPIFileSystem::Read( void* pOutput, int size, FileHandle_t file ) +{ + return ((IVMPIFile*)file)->Read( pOutput, size ); +} + +int CBaseVMPIFileSystem::Write( void const* pInput, int size, FileHandle_t file ) +{ + return ((IVMPIFile*)file)->Write( pInput, size ); +} + +void CBaseVMPIFileSystem::Seek( FileHandle_t file, int pos, FileSystemSeek_t seekType ) +{ + ((IVMPIFile*)file)->Seek( pos, seekType ); +} + +unsigned int CBaseVMPIFileSystem::Tell( FileHandle_t file ) +{ + return ((IVMPIFile*)file)->Tell(); +} + +unsigned int CBaseVMPIFileSystem::Size( FileHandle_t file ) +{ + return ((IVMPIFile*)file)->Size(); +} + +unsigned int CBaseVMPIFileSystem::Size( const char *pFilename, const char *pathID = 0 ) +{ + FileHandle_t hFile = Open( pFilename, "rb", NULL ); + if ( hFile == FILESYSTEM_INVALID_HANDLE ) + { + return 0; + } + else + { + unsigned int ret = Size( hFile ); + Close( hFile ); + return ret; + } +} + +bool CBaseVMPIFileSystem::FileExists( const char *pFileName, const char *pPathID ) +{ + FileHandle_t hFile = Open( pFileName, "rb", NULL ); + if ( hFile ) + { + Close( hFile ); + return true; + } + else + { + return false; + } +} + +void CBaseVMPIFileSystem::Flush( FileHandle_t file ) +{ + ((IVMPIFile*)file)->Flush(); +} + +bool CBaseVMPIFileSystem::Precache( const char* pFileName, const char *pPathID ) +{ + return false; +} + + +//----------------------------------------------------------------------------- +// NOTE: This is an exact copy of code in BaseFileSystem.cpp which +// has to be here because they want to call +// the implementation of Open/Size/Read/Write in CBaseVMPIFileSystem +//----------------------------------------------------------------------------- +bool CBaseVMPIFileSystem::ReadFile( const char *pFileName, const char *pPath, CUtlBuffer &buf, int nMaxBytes, int nStartingByte, FSAllocFunc_t pfnAlloc ) +{ + const char *pReadFlags = "rb"; + if ( buf.IsText() && !buf.ContainsCRLF() ) + { + pReadFlags = "rt"; + } + + FileHandle_t fp = Open( pFileName, buf.IsText() ? "rt" : "rb", pPath ); + if ( !fp ) + return false; + + int nBytesToRead = Size( fp ); + if ( nMaxBytes > 0 ) + { + nBytesToRead = min( nMaxBytes, nBytesToRead ); + } + buf.EnsureCapacity( nBytesToRead + buf.TellPut() ); + + if ( nStartingByte != 0 ) + { + Seek( fp, nStartingByte, FILESYSTEM_SEEK_HEAD ); + } + + int nBytesRead = Read( buf.PeekPut(), nBytesToRead, fp ); + buf.SeekPut( CUtlBuffer::SEEK_CURRENT, nBytesRead ); + + Close( fp ); + return (nBytesRead != 0); +} + +bool CBaseVMPIFileSystem::WriteFile( const char *pFileName, const char *pPath, CUtlBuffer &buf ) +{ + const char *pWriteFlags = "wb"; + if ( buf.IsText() && !buf.ContainsCRLF() ) + { + pWriteFlags = "wt"; + } + + FileHandle_t fp = Open( pFileName, buf.IsText() ? "wt" : "wb", pPath ); + if ( !fp ) + return false; + + int nBytesWritten = Write( buf.Base(), buf.TellPut(), fp ); + + Close( fp ); + return (nBytesWritten != 0); +} + diff --git a/utils/vmpi/vmpi_filesystem.h b/utils/vmpi/vmpi_filesystem.h new file mode 100644 index 0000000..f3c3c8a --- /dev/null +++ b/utils/vmpi/vmpi_filesystem.h @@ -0,0 +1,53 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#ifndef VMPI_FILESYSTEM_H +#define VMPI_FILESYSTEM_H +#ifdef _WIN32 +#pragma once +#endif + + +#include "interface.h" + + +class IFileSystem; +class MessageBuffer; + + +// Use this to read virtual files. +#define VMPI_VIRTUAL_FILES_PATH_ID "VMPI_VIRTUAL_FILES_PATH_ID" + + +// When you hook the file system with VMPI and are a worker, it blocks on file reads +// and uses MPI to communicate with the master to transfer files it needs over. +// +// The filesystem, by default (and it maxFileSystemMemoryUsage is left at zero), +// keeps the contents of the files that get opened in memory. You can pass in a +// value here to put a cap on it, in which case it'll unload the least-recently-used +// files when it hits the limit. +IFileSystem* VMPI_FileSystem_Init( int maxFileSystemMemoryUsage, IFileSystem *pPassThru ); + +// On the master machine, this really should be called before the app shuts down and +// global destructors are called. If it isn't, it might lock up waiting for a thread to exit. +// +// This returns the original filesystem you passed into VMPI_FileSystem_Init so you can uninitialize it. +IFileSystem* VMPI_FileSystem_Term(); + +// Causes it to error out on any Open() calls. +void VMPI_FileSystem_DisableFileAccess(); + +// Returns a factory that will hand out BASEFILESYSTEM_INTERFACE_VERSION when asked for it. +CreateInterfaceFn VMPI_FileSystem_GetFactory(); + +// This function creates a virtual file that workers can then open and read out of. +// NOTE: when reading from the file, you must use VMPI_VIRTUAL_FILES_PATH_ID as the path ID +// or else it won't find the file. +void VMPI_FileSystem_CreateVirtualFile( const char *pFilename, const void *pData, unsigned long fileLength ); + + +#endif // VMPI_FILESYSTEM_H diff --git a/utils/vmpi/vmpi_filesystem_internal.h b/utils/vmpi/vmpi_filesystem_internal.h new file mode 100644 index 0000000..25ba2af --- /dev/null +++ b/utils/vmpi/vmpi_filesystem_internal.h @@ -0,0 +1,129 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//=============================================================================// + +#ifndef VMPI_FILESYSTEM_INTERNAL_H +#define VMPI_FILESYSTEM_INTERNAL_H +#ifdef _WIN32 +#pragma once +#endif + + +#include "vmpi_filesystem.h" +#include "filesystem.h" +#include "messbuf.h" +#include "iphelpers.h" +#include "vmpi.h" +#include "utlvector.h" +#include "utllinkedlist.h" +#include "filesystem_passthru.h" + + +// Sub packet IDs specific to the VMPI file system. +#define VMPI_FSPACKETID_FILE_REQUEST 1 // Sent by the worker to request a file. +#define VMPI_FSPACKETID_FILE_RESPONSE 2 // Master's response to a file request. +#define VMPI_FSPACKETID_CHUNK_RECEIVED 3 // Sent by workers to tell the master they received a chunk. +#define VMPI_FSPACKETID_FILE_RECEIVED 4 // Sent by workers to tell the master they received the whole file. +#define VMPI_FSPACKETID_MULTICAST_ADDR 5 +#define VMPI_FSPACKETID_FILE_CHUNK 6 // Used to send file data when using TCP. + + +// In TCP mode, we send larger chunks in a sliding window. +#define TCP_CHUNK_QUEUE_LEN 16 + +#define TCP_CHUNK_PAYLOAD_SIZE (16*1024) +#define MULTICAST_CHUNK_PAYLOAD_SIZE (1024*1) +#define MAX_CHUNK_PAYLOAD_SIZE MAX( TCP_CHUNK_PAYLOAD_SIZE, MULTICAST_CHUNK_PAYLOAD_SIZE ) + + +class CMulticastFileInfo +{ +public: + unsigned long m_CompressedSize; + unsigned long m_UncompressedSize; + unsigned short m_FileID; + unsigned short m_nChunks; +}; + + +class CBaseVMPIFileSystem : public CFileSystemPassThru +{ +public: + virtual ~CBaseVMPIFileSystem(); + virtual void Release(); + + virtual void CreateVirtualFile( const char *pFilename, const void *pData, int fileLength ) = 0; + virtual bool HandleFileSystemPacket( MessageBuffer *pBuf, int iSource, int iPacketID ) = 0; + + virtual void Close( FileHandle_t file ); + virtual int Read( void* pOutput, int size, FileHandle_t file ); + virtual int Write( void const* pInput, int size, FileHandle_t file ); + virtual void Seek( FileHandle_t file, int pos, FileSystemSeek_t seekType ); + virtual unsigned int Tell( FileHandle_t file ); + virtual unsigned int Size( FileHandle_t file ); + virtual unsigned int Size( const char *pFilename, const char *pathID ); + virtual bool FileExists( const char *pFileName, const char *pPathID ); + virtual void Flush( FileHandle_t file ); + virtual bool Precache( const char* pFileName, const char *pPathID ); + virtual bool ReadFile( const char *pFileName, const char *pPath, CUtlBuffer &buf, int nMaxBytes = 0, int nStartingByte = 0, FSAllocFunc_t pfnAlloc = 0 ); + virtual bool WriteFile( const char *pFileName, const char *pPath, CUtlBuffer &buf ); + +// All the IFileSystem-specific ones pass the calls through. +// The worker opens its own filesystem_stdio fthrough. + +protected: + CIPAddr m_MulticastIP; +}; + + +class IVMPIFile +{ +public: + virtual void Close() = 0; + virtual void Seek( int pos, FileSystemSeek_t seekType ) = 0; + virtual unsigned int Tell() = 0; + virtual unsigned int Size() = 0; + virtual void Flush() = 0; + virtual int Read( void* pOutput, int size ) = 0; + virtual int Write( void const* pInput, int size ) = 0; +}; + + +// Both the workers and masters use this to hand out the file data. +class CVMPIFile_Memory : public IVMPIFile +{ +public: + void Init( const char *pData, long len, char chMode = 'b' ); + virtual void Close(); + virtual void Seek( int pos, FileSystemSeek_t seekType ); + virtual unsigned int Tell(); + virtual unsigned int Size(); + virtual void Flush(); + virtual int Read( void* pOutput, int size ) ; + virtual int Write( void const* pInput, int size ); + +private: + const char *m_pData; + long m_DataLen; + int m_iCurPos; + char m_chMode; // 'b' or 't' +}; + + +// We use different payload sizes if we're using TCP mode vs. multicast/broadcast mode. +inline int VMPI_GetChunkPayloadSize() +{ + if ( VMPI_GetFileSystemMode() == VMPI_FILESYSTEM_TCP ) + return TCP_CHUNK_PAYLOAD_SIZE; + else + return MULTICAST_CHUNK_PAYLOAD_SIZE; +} + + +extern bool g_bDisableFileAccess; +extern CBaseVMPIFileSystem *g_pBaseVMPIFileSystem; + + +#endif // VMPI_FILESYSTEM_INTERNAL_H diff --git a/utils/vmpi/vmpi_filesystem_master.cpp b/utils/vmpi/vmpi_filesystem_master.cpp new file mode 100644 index 0000000..f047bf7 --- /dev/null +++ b/utils/vmpi/vmpi_filesystem_master.cpp @@ -0,0 +1,1606 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//=============================================================================// + +#include <winsock2.h> +#include "vmpi_filesystem_internal.h" +#include "zlib.h" +#include "vstdlib/random.h" + + +#define MINIMUM_SLEEP_MS 1 + +// NOTE: This number comes from measurements on our network to find out how fast +// we can broadcast without the network freaking out. +// +// This number can be changed on the command line with the -mpi_FileTransmitRate parameter. +int MULTICAST_TRANSMIT_RATE = (1024*1000); // N megs per second + +// Defines when we'll stop transmitting a file to a client. +// (After we've transmitted the file to the client N times and we haven't heard an ack back for M seconds). +#define MIN_FILE_CYCLE_COUNT 5 +#define CLIENT_FILE_ACK_TIMEOUT 20 + + + +// ------------------------------------------------------------------------------------------------------------------------ // +// Global helpers. +// ------------------------------------------------------------------------------------------------------------------------ // + +static void SendMulticastIP( const CIPAddr *pAddr ) +{ + unsigned char packetID[2] = { VMPI_PACKETID_FILESYSTEM, VMPI_FSPACKETID_MULTICAST_ADDR }; + VMPI_Send2Chunks( + packetID, sizeof( packetID ), + pAddr, sizeof( *pAddr ), + VMPI_PERSISTENT ); +} + + +static bool IsOpeningForWriteAccess( const char *pOptions ) +{ + return strchr( pOptions, 'w' ) || strchr( pOptions, 'a' ) || strchr( pOptions, '+' ); +} + + +// This does a fast zlib compression of the source data into the 'out' buffer. +static bool ZLibCompress( const void *pData, int len, CUtlVector<char> &out ) +{ + if ( len == 0 ) + { + out.Purge(); + return true; + } + + int outStartLen = len; +RETRY:; + + // Prepare the compression stream. + z_stream zs; + memset( &zs, 0, sizeof( zs ) ); + + if ( deflateInit( &zs, 1 ) != Z_OK ) + return false; + + + // Now compress it into the output buffer. + out.SetSize( outStartLen ); + + zs.next_in = (unsigned char*)pData; + zs.avail_in = len; + + zs.next_out = (unsigned char*)out.Base(); + zs.avail_out = out.Count(); + + int ret = deflate( &zs, Z_FINISH ); + deflateEnd( &zs ); + + if ( ret == Z_STREAM_END ) + { + // Get rid of whatever was left over. + out.RemoveMultiple( zs.total_out, out.Count() - zs.total_out ); + return true; + } + else if ( ret == Z_OK ) + { + // Need more space in the output buffer. + outStartLen += 1024 * 128; + goto RETRY; + } + else + { + return false; + } +} + + +// ------------------------------------------------------------------------------------------------------------------------ // +// CVMPIFile_PassThru +// ------------------------------------------------------------------------------------------------------------------------ // + +class CVMPIFile_PassThru : public IVMPIFile +{ +public: + void Init( IBaseFileSystem *pPassThru, FileHandle_t fp ) + { + m_pPassThru = pPassThru; + m_fp = fp; + } + + virtual void Close() + { + m_pPassThru->Close( m_fp ); + delete this; + } + + virtual void Seek( int pos, FileSystemSeek_t seekType ) + { + m_pPassThru->Seek( m_fp, pos, seekType ); + } + + virtual unsigned int Tell() + { + return m_pPassThru->Tell( m_fp ); + } + + virtual unsigned int Size() + { + return m_pPassThru->Size( m_fp ); + } + + virtual void Flush() + { + m_pPassThru->Flush( m_fp ); + } + + virtual int Read( void* pOutput, int size ) + { + return m_pPassThru->Read( pOutput, size, m_fp ); + } + + virtual int Write( void const* pInput, int size ) + { + return m_pPassThru->Write( pInput, size, m_fp ); + } + + +private: + IBaseFileSystem *m_pPassThru; + FileHandle_t m_fp; +}; + + + +// ---------------------------------------------------------------------------------------------------- // +// CTransmitRateMgr coordinates with any other currently-running VMPI jobs, and they all will cut +// down their transmission rate to stay within MULTICAST_TRANSMIT_RATE. +// ---------------------------------------------------------------------------------------------------- // + +#define TRANSMITRATEMGR_BROADCAST_INVERVAL (1.0 / 3.0) // How many times per second we broadcast our presence. +#define TRANSMITRATEMGR_EXPIRE_TIME 0.7 // How long it'll go before deciding a guy is not transmitting anymore. + +static char s_cTransmitRateMgrPacket[] = {2,6,-3,2,1,-66}; + +class CTransmitRateMgr +{ +public: + CTransmitRateMgr(); + + void ReadPackets(); + void BroadcastPresence(); + + double GetMicrosecondsPerByte() const; + +private: + class CMachineRecord + { + public: + unsigned long m_UniqueID; + float m_flLastTime; + }; + CUtlVector<CMachineRecord> m_MachineRecords; + + unsigned long m_UniqueID; + float m_flLastBroadcastTime; + double m_nMicrosecondsPerByte; + ISocket *m_pSocket; +}; + +CTransmitRateMgr::CTransmitRateMgr() +{ + m_nMicrosecondsPerByte = 1000000.0 / (double)MULTICAST_TRANSMIT_RATE; + m_flLastBroadcastTime = 0; + + // Build a (hopefully) unique ID. + m_UniqueID = (unsigned long)this; + CCycleCount cnt; + cnt.Sample(); + m_UniqueID += cnt.GetMicroseconds(); + Sleep( 1 ); + m_UniqueID += cnt.GetMicroseconds(); + + m_pSocket = CreateIPSocket(); + if ( m_pSocket ) + { + m_pSocket->BindToAny( VMPI_MASTER_FILESYSTEM_BROADCAST_PORT ); + } +} + +void CTransmitRateMgr::ReadPackets() +{ + if ( !m_pSocket ) + return; + + float flCurTime = Plat_FloatTime(); + + // First, update/add records. + while ( 1 ) + { + char data[512]; + CIPAddr ipFrom; + int len = m_pSocket->RecvFrom( data, sizeof( data ), &ipFrom ); + if ( len == -1 ) + break; + + if ( len == sizeof( s_cTransmitRateMgrPacket ) + sizeof( unsigned long ) && + memcmp( data, s_cTransmitRateMgrPacket, sizeof( s_cTransmitRateMgrPacket ) ) == 0 ) + { + unsigned long id = *((unsigned long*)&data[sizeof(s_cTransmitRateMgrPacket)]); + if ( id == m_UniqueID ) + continue; + + int i; + for ( i=0; i < m_MachineRecords.Count(); i++ ) + { + if ( m_MachineRecords[i].m_UniqueID == id ) + { + m_MachineRecords[i].m_flLastTime = flCurTime; + break; + } + } + + if ( i == m_MachineRecords.Count() ) + { + int index = m_MachineRecords.AddToTail(); + m_MachineRecords[index].m_UniqueID = id; + m_MachineRecords[index].m_flLastTime = flCurTime; + } + } + } + + // Now, expire any old records. + for ( int i=0; i < m_MachineRecords.Count(); i++ ) + { + if ( (flCurTime - m_MachineRecords[i].m_flLastTime) > TRANSMITRATEMGR_EXPIRE_TIME ) + { + m_MachineRecords.Remove( i ); + --i; + } + } + + // Recalculate our transmit rate (assuming we're receiving our own broadcast packets). + m_nMicrosecondsPerByte = 1000000.0 / (double)(MULTICAST_TRANSMIT_RATE / (m_MachineRecords.Count() + 1)); +} + +void CTransmitRateMgr::BroadcastPresence() +{ + if ( !m_pSocket ) + return; + + float flCurTime = Plat_FloatTime(); + if ( (flCurTime - m_flLastBroadcastTime) < TRANSMITRATEMGR_BROADCAST_INVERVAL ) + return; + + m_flLastBroadcastTime = flCurTime; + + char cData[sizeof( s_cTransmitRateMgrPacket ) + sizeof( unsigned long )]; + memcpy( cData, s_cTransmitRateMgrPacket, sizeof( s_cTransmitRateMgrPacket ) ); + *((unsigned long*)&cData[ sizeof( s_cTransmitRateMgrPacket ) ] ) = m_UniqueID; + + m_pSocket->Broadcast( cData, sizeof( cData ), VMPI_MASTER_FILESYSTEM_BROADCAST_PORT ); +} + +inline double CTransmitRateMgr::GetMicrosecondsPerByte() const +{ + return m_nMicrosecondsPerByte; +} + + +// ---------------------------------------------------------------------------------------------------- // +// CRateLimiter manages waiting for small periods of time between packets so the rate is +// whatever we want it to be. +// +// It also will give up some CPU time to other processes every 50 milliseconds. +// ---------------------------------------------------------------------------------------------------- // + +class CRateLimiter +{ +public: + + CRateLimiter(); + + void GiveUpTimeSlice(); + void NoteExcessTimeTaken( unsigned long excessTimeInMicroseconds ); + + +public: + + DWORD m_SleepIntervalMS; // Give up a timeslice every N milliseconds. + + // Since we sleep once in a while, we time how long the sleep took and we beef + // up the transmit rate until we've accounted for the time lost during the sleep. + DWORD m_AccumulatedSleepMicroseconds; + + // When was the last time we gave up a little bit of CPU to other programs. + CCycleCount m_LastSleepTime; +}; + +CRateLimiter::CRateLimiter() +{ + m_SleepIntervalMS = 50; + m_AccumulatedSleepMicroseconds = 0; + m_LastSleepTime.Sample(); +} + +void CRateLimiter::GiveUpTimeSlice() +{ + // Sleep again? + CCycleCount currentTime, dtSinceLastSleep; + currentTime.Sample(); + CCycleCount::Sub( currentTime, m_LastSleepTime, dtSinceLastSleep ); + + if ( dtSinceLastSleep.GetMilliseconds() >= m_SleepIntervalMS ) + { + CFastTimer sleepTimer; + + sleepTimer.Start(); + Sleep( 10 ); + sleepTimer.End(); + + m_AccumulatedSleepMicroseconds += sleepTimer.GetDuration().GetMicroseconds(); + m_LastSleepTime.Sample(); + } +} + + +void CRateLimiter::NoteExcessTimeTaken( unsigned long excessTimeInMicroseconds ) +{ + // Note: we give up time slices above. + if ( excessTimeInMicroseconds > m_AccumulatedSleepMicroseconds ) + { + excessTimeInMicroseconds -= m_AccumulatedSleepMicroseconds; + m_AccumulatedSleepMicroseconds = 0; + + CCycleCount startCount; + startCount.Sample(); + while ( 1 ) + { + CCycleCount curCount, diff; + curCount.Sample(); + + CCycleCount::Sub( curCount, startCount, diff ); + if ( diff.GetMicroseconds() >= excessTimeInMicroseconds ) + break; + } + } + else + { + m_AccumulatedSleepMicroseconds -= excessTimeInMicroseconds; + excessTimeInMicroseconds = 0; + } +} + + +// ------------------------------------------------------------------------------------------------------------------------ // +// CMasterMulticastThread. +// ------------------------------------------------------------------------------------------------------------------------ // + +class CMasterMulticastThread +{ +public: + + CMasterMulticastThread(); + ~CMasterMulticastThread(); + + // This creates the socket and starts the thread (initially in an idle state since it doesn't + // know of any files anyone wants). + bool Init( IBaseFileSystem *pPassThru, unsigned short localPort, const CIPAddr *pAddr, int maxFileSystemMemoryUsage ); + void Term(); + + // Returns -1 if there is an error. + int FindOrAddFile( const char *pFilename, const char *pPathID ); + const CUtlVector<char>& GetFileData( int iFile ) const; + + // When a client requests a files, this is called to tell the thread to start + // adding chunks from the specified file into the queue it's multicasting. + // + // Returns -1 if the file isn't there. Otherwise, it returns the file ID + // that will be sent along with the file's chunks in the multicast packets. + int AddFileRequest( const char *pFilename, const char *pPathID, int clientID, bool *bZeroLength ); + + // As each client receives multicasted chunks, they ack them so the master can + // stop transmitting any chunks it knows nobody wants. + void OnChunkReceived( int fileID, int clientID, int iChunk ); + void OnFileReceived( int fileID, int clientID ); + + // Call this if a client disconnects so it can stop sending anything this client wants. + void OnClientDisconnect( int clientID, bool bGrabCriticalSection=true ); + + void CreateVirtualFile( const char *pFilename, const void *pData, unsigned long fileLength ); + +private: + + class CChunkInfo + { + public: + unsigned short m_iChunk; + unsigned short m_RefCount; // How many clients want this chunk. + unsigned short m_iActiveChunksIndex; // Index into m_ActiveChunks. + }; + + + // This stores a client's reference to a file so it knows which pieces of the file the client needs. + class CClientFileInfo + { + public: + bool NeedsChunk( int i ) const { return (m_ChunksToSend[i>>3] & (1 << (i&7))) != 0; } + + public: + int m_ClientID; + CUtlVector<unsigned char> m_ChunksToSend; // One bit for each chunk that this client still wants. + int m_nChunksLeft; + + // TCP transmission only. + int m_TCP_LastChunkAcked; + int m_TCP_LastChunkSent; + + float m_flTransmitStartTime; + + float m_flLastAckTime; // Last time we heard an ack back from this client about this file. + // If this goes for too long, then we assume that the client is + // in a screwed state, and we stop sending the file to him. + int m_nTimesFileCycled; // How many times has the master multicast thread cycled over this file? + // We won't kick the client until we've cycled over the file a few times + // after the client asked for it. + }; + + + class CMulticastFile + { + public: + ~CMulticastFile() + { + m_Clients.PurgeAndDeleteElements(); + } + + const char* GetFilename() { return m_Filename.Base(); } + const char* GetPathID() { return m_PathID.Base(); } + + + public: + int m_nCycles; // How many times has the multicast thread visited this file? + + // This is sent along with every packet. If a client gets a chunk and doesn't have that file's + // info, the client will receive that file too. + CUtlVector<char> m_Filename; + CUtlVector<char> m_PathID; + + CMulticastFileInfo m_Info; + + // This is stored so the app can read out the uncompressed data. + CUtlVector<char> m_UncompressedData; + + // zlib-compressed file data + CUtlVector<char> m_Data; + + // This gets set to false if we run over our memory limit and start caching file data out. + // Then it'll reload the data if a client requests the file. + bool m_bDataLoaded; + + // m_Chunks holds the chunks by index. + // m_ActiveChunks holds them sorted by whether they're active or not. + // + // Each chunk has a refcount. While the refcount is > 0, the chunk is in the first + // half of m_ActiveChunks. When the refcount gets to 0, the chunk is moved to the end of + // m_ActiveChunks. That way, we can iterate through the chunks that need to be sent and + // stop iterating the first time we hit one with a refcount of 0. + CUtlVector<CChunkInfo> m_Chunks; + CUtlLinkedList<CChunkInfo*,int> m_ActiveChunks; + + // This tells which clients want pieces of this file. + CUtlLinkedList<CClientFileInfo*,int> m_Clients; + }; + + +private: + + static DWORD WINAPI StaticMulticastThread( LPVOID pParameter ); + DWORD MulticastThread(); + + bool CheckClientTimeouts(); + bool Thread_SendFileChunk_Multicast( int *pnBytesSent ); + void Thread_SeekToNextActiveChunk(); + + // In TCP mode, we send new chunks as they are acked. + void TCP_SendNextChunk( CMulticastFile *pFile, CClientFileInfo *pClient ); + + void EnsureMemoryLimit( CMulticastFile *pIgnore ); + + // Called after pFile->m_UncompressedData has been setup. This compresses the data, prepares the header, + // copies the filename, and adds it into the queue for the multicast thread. + int FinishFileSetup( CMulticastFile *pFile, const char *pFilename, const char *pPathID, bool bFileAlreadyExisted ); + + void IncrementChunkRefCount( CMasterMulticastThread::CMulticastFile *pFile, int iChunk ); + void DecrementChunkRefCount( int iFile, int iChunk ); + + int FindFile( const char *pFilename, const char *pPathID ); + + bool FindWarningSuppression( const char *pFilename ); + void AddWarningSuppression( const char *pFilename ); + +private: + + CUtlLinkedList<CMulticastFile*,int> m_Files; + + unsigned long m_nCurMemoryUsage; // Total of all the file data we have loaded. + unsigned long m_nMaxMemoryUsage; // 0 means that there is no limit. + + // This tracks how many chunks we have that want to be sent. + int m_nTotalActiveChunks; + + SOCKET m_Socket; + sockaddr_in m_MulticastAddr; + + HANDLE m_hMainThread; + IBaseFileSystem *m_pPassThru; + + HANDLE m_hThread; + CRITICAL_SECTION m_CS; + + // Events used to communicate with our thread. + HANDLE m_hTermEvent; + + // The thread walks through this as it spews chunks of data. + volatile int m_iCurFile; // Index into m_Files. + volatile int m_iCurActiveChunk; // Current index into CMulticastFile::m_ActiveChunks. + + CUtlLinkedList<char*,int> m_WarningSuppressions; +}; + + +CMasterMulticastThread::CMasterMulticastThread() +{ + m_hThread = m_hMainThread = NULL; + m_Socket = INVALID_SOCKET; + m_nTotalActiveChunks = 0; + m_iCurFile = m_iCurActiveChunk = -1; + m_pPassThru = NULL; + + m_hTermEvent = CreateEvent( NULL, FALSE, FALSE, NULL ); + InitializeCriticalSection( &m_CS ); + m_nCurMemoryUsage = m_nMaxMemoryUsage = 0; +} + + +CMasterMulticastThread::~CMasterMulticastThread() +{ + Term(); + + CloseHandle( m_hTermEvent ); + + DeleteCriticalSection( &m_CS ); +} + + +bool CMasterMulticastThread::Init( IBaseFileSystem *pPassThru, unsigned short localPort, const CIPAddr *pAddr, int maxMemoryUsage ) +{ + Term(); + + m_nMaxMemoryUsage = maxMemoryUsage; + Assert( m_nCurMemoryUsage == 0 ); + m_nCurMemoryUsage = 0; + + if ( VMPI_GetFileSystemMode() == VMPI_FILESYSTEM_TCP ) + { + // No need for an extra socket in this mode. + m_Socket = INVALID_SOCKET; + } + else + { + // First, create our socket. + m_Socket = socket( AF_INET, SOCK_DGRAM, IPPROTO_IP ); + if ( m_Socket == INVALID_SOCKET ) + { + Warning( "CMasterMulticastThread::Init - socket() failed\n" ); + return false; + } + + // Bind to INADDR_ANY. + CIPAddr localAddr( 0, 0, 0, 0, localPort ); + + sockaddr_in addr; + IPAddrToSockAddr( &localAddr, &addr ); + + int status = bind( m_Socket, (sockaddr*)&addr, sizeof(addr) ); + if ( status != 0 ) + { + Term(); + Warning( "CMasterMulticastThread::Init - bind( %d.%d.%d.%d:%d ) failed\n", EXPAND_ADDR( *pAddr ) ); + return false; + } + + if ( VMPI_GetFileSystemMode() == VMPI_FILESYSTEM_BROADCAST ) + { + // Set up for broadcast + BOOL bBroadcast = TRUE; + if ( setsockopt( m_Socket, SOL_SOCKET, SO_BROADCAST, (char*)&bBroadcast, bBroadcast ) == SOCKET_ERROR ) + { + Term(); + Warning( "CMasterMulticastThread::Init - setsockopt() failed to set broadcast mode\n" ); + return false; + } + } + + // Remember the address we want to send to. + IPAddrToSockAddr( pAddr, &m_MulticastAddr ); + + // Now create our thread. + DWORD dwThreadID = 0; + m_hThread = CreateThread( NULL, 0, &CMasterMulticastThread::StaticMulticastThread, this, 0, &dwThreadID ); + if ( !m_hThread ) + { + Term(); + Warning( "CMasterMulticastThread::Init - CreateThread failed\n" ); + return false; + } + + SetThreadPriority( m_hThread, THREAD_PRIORITY_LOWEST ); + } + + // For debug mode to verify that we don't try to open files while in another thread. + m_hMainThread = GetCurrentThread(); + + m_pPassThru = pPassThru; + return true; +} + + +void CMasterMulticastThread::Term() +{ + // Stop the thread if it is running. + if ( m_hThread ) + { + SetEvent( m_hTermEvent ); + WaitForSingleObject( m_hThread, INFINITE ); + CloseHandle( m_hThread ); + + m_hThread = NULL; + } + + // Close the socket. + if ( m_Socket != INVALID_SOCKET ) + { + closesocket( m_Socket ); + m_Socket = INVALID_SOCKET; + } + + // Free up other data. + m_Files.PurgeAndDeleteElements(); + m_nCurMemoryUsage = m_nMaxMemoryUsage = 0; +} + + +void CMasterMulticastThread::TCP_SendNextChunk( CMulticastFile *pFile, CClientFileInfo *pClient ) +{ + // No more chunks to send? + if ( (pClient->m_TCP_LastChunkSent+1) >= pFile->m_Info.m_nChunks ) + return; + + // Figure out what data we'd be sending. + int iChunkToSend = pClient->m_TCP_LastChunkSent + 1; + int iStartByte = iChunkToSend * TCP_CHUNK_PAYLOAD_SIZE; + int iEndByte = min( iStartByte + TCP_CHUNK_PAYLOAD_SIZE, pFile->m_Data.Count() ); + + // If the start point is past the end, then we're done sending the file to this client. + if ( iStartByte >= pFile->m_Data.Count() ) + return; + + // Record that we sent this data. + pClient->m_TCP_LastChunkSent = iChunkToSend; + + // Assemble the packet. + unsigned char cPacket[2] = { VMPI_PACKETID_FILESYSTEM, VMPI_FSPACKETID_FILE_CHUNK }; + + const void *chunks[5] = + { + cPacket, + &pFile->m_Info, + &iChunkToSend, + pFile->GetFilename(), + &pFile->m_Data[iStartByte] + }; + + int chunkLengths[5] = + { + sizeof( cPacket ), + sizeof( pFile->m_Info ), + sizeof( m_iCurActiveChunk ), + strlen( pFile->GetFilename() ) + 1, + iEndByte - iStartByte + }; + + VMPI_SendChunks( chunks, chunkLengths, 5, pClient->m_ClientID ); +} + + +int CMasterMulticastThread::AddFileRequest( const char *pFilename, const char *pPathID, int clientID, bool *bZeroLength ) +{ + // Firstly, do we already have this file? + int iFile = FindOrAddFile( pFilename, pPathID ); + if ( iFile == -1 ) + return -1; + + CMulticastFile *pFile = m_Files[iFile]; + + // Now that we have a file setup, merge in this client's info. + EnterCriticalSection( &m_CS ); + + CClientFileInfo *pClient = new CClientFileInfo; + pClient->m_TCP_LastChunkAcked = -1; + pClient->m_TCP_LastChunkSent = -1; + pClient->m_ClientID = clientID; + pClient->m_flLastAckTime = Plat_FloatTime(); + pClient->m_flTransmitStartTime = pClient->m_flLastAckTime; + pClient->m_nTimesFileCycled = 0; + pClient->m_nChunksLeft = pFile->m_Info.m_nChunks; + pClient->m_ChunksToSend.SetSize( PAD_NUMBER( pFile->m_Info.m_nChunks, 8 ) / 8 ); + memset( pClient->m_ChunksToSend.Base(), 0xFF, pClient->m_ChunksToSend.Count() ); + pFile->m_Clients.AddToTail( pClient ); + + for ( int i=0; i < pFile->m_Chunks.Count(); i++ ) + { + IncrementChunkRefCount( pFile, i ); + } + + // In TCP mode, let's get the sliding window started.. + if ( VMPI_GetFileSystemMode() == VMPI_FILESYSTEM_TCP ) + { + for ( int iDepth=0; iDepth < TCP_CHUNK_QUEUE_LEN; iDepth++ ) + TCP_SendNextChunk( pFile, pClient ); + } + + LeaveCriticalSection( &m_CS ); + + *bZeroLength = (pFile->m_Info.m_UncompressedSize == 0); + + return iFile; +} + + +void CMasterMulticastThread::OnChunkReceived( int fileID, int clientID, int iChunk ) +{ + if ( !m_Files.IsValidIndex( fileID ) ) + { + Warning( "CMasterMulticastThread::OnChunkReceived: invalid file (%d) from client %d\n", fileID, clientID ); + return; + } + + CMulticastFile *pFile = m_Files[fileID]; + CClientFileInfo *pClient = NULL; + FOR_EACH_LL( pFile->m_Clients, iClient ) + { + if ( pFile->m_Clients[iClient]->m_ClientID == clientID ) + { + pClient = pFile->m_Clients[iClient]; + break; + } + } + if ( !pClient ) + { + // This will spam sometimes if a worker stops responding and we timeout on it, + // but then it comes back alive and starts responding. So let's ignore its packets silently. + //Warning( "CMasterMulticastThread::OnChunkReceived: invalid client ID (%d) for file %s\n", clientID, pFile->GetFilename() ); + return; + } + + if ( VMPI_GetFileSystemMode() == VMPI_FILESYSTEM_TCP ) + { + // Send the next chunk, if there is one. + EnterCriticalSection( &m_CS ); + TCP_SendNextChunk( pFile, pClient ); + LeaveCriticalSection( &m_CS ); + } + else + { + if ( !pFile->m_Chunks.IsValidIndex( iChunk ) ) + { + Warning( "CMasterMulticastThread::OnChunkReceived: invalid chunk index (%d) for file %s\n", iChunk, pFile->GetFilename() ); + return; + } + + // Mark that this client doesn't need this chunk anymore. + pClient->m_ChunksToSend[iChunk >> 3] &= ~(1 << (iChunk & 7)); + pClient->m_nChunksLeft--; + + pClient->m_flLastAckTime = Plat_FloatTime(); + if ( pClient->m_nChunksLeft == 0 && g_iVMPIVerboseLevel >= 2 ) + Warning( "Client %d got file %s\n", clientID, pFile->GetFilename() ); + + EnterCriticalSection( &m_CS ); + DecrementChunkRefCount( fileID, iChunk ); + LeaveCriticalSection( &m_CS ); + } +} + + +void CMasterMulticastThread::OnFileReceived( int fileID, int clientID ) +{ + if ( !m_Files.IsValidIndex( fileID ) ) + { + Warning( "CMasterMulticastThread::OnChunkReceived: invalid file (%d) from client %d\n", fileID, clientID ); + return; + } + + CMulticastFile *pFile = m_Files[fileID]; + for ( int i=0; i < pFile->m_Info.m_nChunks; i++ ) + OnChunkReceived( fileID, clientID, i ); +} + + +void CMasterMulticastThread::OnClientDisconnect( int clientID, bool bGrabCriticalSection ) +{ + if ( bGrabCriticalSection ) + EnterCriticalSection( &m_CS ); + + // Remove all references from this client. + FOR_EACH_LL( m_Files, iFile ) + { + CMulticastFile *pFile = m_Files[iFile]; + + FOR_EACH_LL( pFile->m_Clients, iClient ) + { + CClientFileInfo *pClient = pFile->m_Clients[iClient]; + + if ( pClient->m_ClientID != clientID ) + continue; + + // Ok, this is our man. Decrement the refcount of any chunks this client wanted. + for ( int iChunk=0; iChunk < pFile->m_Info.m_nChunks; iChunk++ ) + { + if ( pClient->NeedsChunk( iChunk ) ) + { + DecrementChunkRefCount( iFile, iChunk ); + } + } + + delete pClient; + pFile->m_Clients.Remove( iClient ); + + break; + } + } + + if ( bGrabCriticalSection ) + LeaveCriticalSection( &m_CS ); +} + + +void CMasterMulticastThread::CreateVirtualFile( const char *pFilename, const void *pData, unsigned long fileLength ) +{ + const char *pPathID = VMPI_VIRTUAL_FILES_PATH_ID; + + int iFile = FindFile( pFilename, pPathID ); + if ( iFile != -1 ) + Error( "CMasterMulticastThread::CreateVirtualFile( %s ) - file already exists!", pFilename ); + + CMulticastFile *pFile = new CMulticastFile; + pFile->m_UncompressedData.CopyArray( (const char*)pData, fileLength ); + + FinishFileSetup( pFile, pFilename, pPathID, false ); +} + + +DWORD WINAPI CMasterMulticastThread::StaticMulticastThread( LPVOID pParameter ) +{ + return ((CMasterMulticastThread*)pParameter)->MulticastThread(); +} + + +bool CMasterMulticastThread::CheckClientTimeouts() +{ + bool bRet = false; + CMulticastFile *pFile = m_Files[m_iCurFile]; + + float flCurTime = Plat_FloatTime(); + + int iNext; + for( int iCur=pFile->m_Clients.Head(); iCur != pFile->m_Clients.InvalidIndex(); iCur=iNext ) + { + iNext = pFile->m_Clients.Next( iCur ); + CClientFileInfo *pInfo = pFile->m_Clients[iCur]; + + // If the client has already fully received this file, don't bother timing out on it. + if ( pInfo->m_nChunksLeft == 0 ) + continue; + + ++pInfo->m_nTimesFileCycled; + if ( pInfo->m_nTimesFileCycled >= MIN_FILE_CYCLE_COUNT && (flCurTime - pInfo->m_flLastAckTime) > CLIENT_FILE_ACK_TIMEOUT ) + { + // For debug output, get the most recent time we heard any ack from this client at all. + float flMostRecentTime = pInfo->m_flLastAckTime; + FOR_EACH_LL( m_Files, iTestFile ) + { + CMulticastFile *pTestFile = m_Files[iTestFile]; + FOR_EACH_LL( pTestFile->m_Clients, iTestClient ) + { + if ( pTestFile->m_Clients[iTestClient]->m_ClientID == pInfo->m_ClientID ) + { + flMostRecentTime = max( flMostRecentTime, pTestFile->m_Clients[iTestClient]->m_flLastAckTime ); + } + } + } + + Warning( "\nClient %s timed out on file %s (latest: %.2f / cur: %.2f).\n", + VMPI_GetMachineName( pInfo->m_ClientID ), pFile->GetFilename(), flMostRecentTime, flCurTime ); + OnClientDisconnect( pInfo->m_ClientID, false ); + bRet = true; // yes, we booted a client. + } + } + + return bRet; +} + +inline bool CMasterMulticastThread::Thread_SendFileChunk_Multicast( int *pnBytesSent ) +{ + // Send the next chunk (file, size, time, chunk data). + CMulticastFile *pFile = m_Files[m_iCurFile]; + + int iStartByte = m_iCurActiveChunk * MULTICAST_CHUNK_PAYLOAD_SIZE; + int iEndByte = min( iStartByte + MULTICAST_CHUNK_PAYLOAD_SIZE, pFile->m_Data.Count() ); + + WSABUF bufs[4]; + bufs[0].buf = (char*)&pFile->m_Info; + bufs[0].len = sizeof( pFile->m_Info ); + + bufs[1].buf = (char*)&m_iCurActiveChunk; + bufs[1].len = sizeof( m_iCurActiveChunk ); + + bufs[2].buf = (char*)pFile->GetFilename(); + bufs[2].len = strlen( pFile->GetFilename() ) + 1; + + bufs[3].buf = &pFile->m_Data[iStartByte]; + bufs[3].len = iEndByte - iStartByte; + + DWORD nBytesSent = 0; + DWORD nWantedBytes = ( bufs[0].len + bufs[1].len + bufs[2].len + bufs[3].len ); + bool bSuccess; + + if ( m_MulticastAddr.sin_addr.S_un.S_un_b.s_b1 == 127 && + m_MulticastAddr.sin_addr.S_un.S_un_b.s_b2 == 0 && + m_MulticastAddr.sin_addr.S_un.S_un_b.s_b3 == 0 && + m_MulticastAddr.sin_addr.S_un.S_un_b.s_b4 == 1 ) + { + // For some mysterious reason, WSASendTo only sends the first buffer + // if we're sending to 127.0.0.1 (ie: in local mode). + char allData[1024*8]; + if ( nWantedBytes > sizeof( allData ) ) + Error( "nWantedBytes > sizeof( allData )" ); + + memcpy( &allData[0], bufs[0].buf, bufs[0].len ); + memcpy( &allData[bufs[0].len], bufs[1].buf, bufs[1].len ); + memcpy( &allData[bufs[0].len+bufs[1].len], bufs[2].buf, bufs[2].len ); + memcpy( &allData[bufs[0].len+bufs[1].len+bufs[2].len], bufs[3].buf, bufs[3].len ); + int ret = sendto( m_Socket, allData, nWantedBytes, 0, (sockaddr*)&m_MulticastAddr, sizeof( m_MulticastAddr ) ); + bSuccess = (ret == (int)nWantedBytes); + } + else + { + WSASendTo( + m_Socket, + bufs, + ARRAYSIZE( bufs ), + &nBytesSent, + 0, + (sockaddr*)&m_MulticastAddr, + sizeof( m_MulticastAddr ), + NULL, + NULL ); + bSuccess = (nBytesSent == nWantedBytes); + } + + // Handle errors.. let it get a few errors, then quit. + if ( bSuccess ) + { + *pnBytesSent = (int)nBytesSent; + } + else + { + static int nWarnings = 0; + ++nWarnings; + if ( nWarnings < 10 ) + { + Warning( "\nMulticastThread: WSASendTo with %d bytes sent %d bytes.\n", nWantedBytes, nBytesSent ); + + char *lpMsgBuf; + if ( FormatMessage( + FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + GetLastError(), + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language + (char*)&lpMsgBuf, + 0, + NULL + ) ) + { + Warning( "%s", lpMsgBuf ); + LocalFree( lpMsgBuf ); + } + } + else if ( nWarnings == 10 ) + { + Warning( "\nThis machine's ability to multicast may be broken. Please reboot and try again.\n" ); + } + } + + return bSuccess; +} + + +void CMasterMulticastThread::Thread_SeekToNextActiveChunk() +{ + // Make sure we're on a valid chunk. + if ( m_iCurFile == -1 ) + { + Assert( m_Files.Count() > 0 ); + m_iCurFile = m_Files.Head(); + m_iCurActiveChunk = m_Files[m_iCurFile]->m_ActiveChunks.Head(); + } + + while ( 1 ) + { + if ( m_iCurActiveChunk == m_Files[m_iCurFile]->m_ActiveChunks.InvalidIndex() || + m_Files[m_iCurFile]->m_ActiveChunks[m_iCurActiveChunk]->m_RefCount == 0 ) + { + // Now check for client timeouts. + // (This is kicking clients unjustly for some reason.. need to debug). + if ( CheckClientTimeouts() && m_nTotalActiveChunks == 0 ) + break; + + // Finished with that file. Send the next one. + m_iCurFile = m_Files.Next( m_iCurFile ); + if ( m_iCurFile == m_Files.InvalidIndex() ) + m_iCurFile = m_Files.Head(); + + m_iCurActiveChunk = m_Files[m_iCurFile]->m_ActiveChunks.Head(); + } + + if ( m_iCurActiveChunk != m_Files[m_iCurFile]->m_ActiveChunks.InvalidIndex() ) + { + // Only break if we're on an active chunk. + if ( m_Files[m_iCurFile]->m_ActiveChunks[m_iCurActiveChunk]->m_RefCount != 0 ) + { + break; + } + + m_iCurActiveChunk = m_Files[m_iCurFile]->m_ActiveChunks.Next( m_iCurActiveChunk ); + } + } +} + + +DWORD CMasterMulticastThread::MulticastThread() +{ + CTransmitRateMgr transmitRateMgr; + CRateLimiter rateLimiter; + + + DWORD msToWait = 0; // Only temporarily used if we don't have any data to send. + + while ( WaitForSingleObject( m_hTermEvent, msToWait ) != WAIT_OBJECT_0 ) + { + rateLimiter.GiveUpTimeSlice(); + msToWait = 0; + + EnterCriticalSection( &m_CS ); + + transmitRateMgr.ReadPackets(); + + // If we have nothing to send then kick back for a while. + if ( m_nTotalActiveChunks == 0 ) + { + LeaveCriticalSection( &m_CS ); + msToWait = 50; + continue; + } + + // Ok, now we're active, so send out our presence to other CTransmitRateMgrs on the network. + transmitRateMgr.BroadcastPresence(); + + + // We're going to time how long this chunk took to send. + CFastTimer timer; + timer.Start(); + + Thread_SeekToNextActiveChunk(); + + // We have to do this check a second time here because the CheckClientTimeouts() call may have + // booted our last client. If we don't check it here, we might be transmitting + // something we don't want to transmit. Also, if we don't break out of the loop above, + // it can prevent the process from ever exiting because it'll never exit that while() loop. + if ( m_nTotalActiveChunks == 0 ) + { + LeaveCriticalSection( &m_CS ); + msToWait = 50; + continue; + } + + int nBytesSent = 0; + + bool bSuccess; + bSuccess = Thread_SendFileChunk_Multicast( &nBytesSent ); + + g_nMulticastBytesSent += (int)nBytesSent; + + // Move to the next chunk. + m_iCurActiveChunk = m_Files[m_iCurFile]->m_ActiveChunks.Next( m_iCurActiveChunk ); + + LeaveCriticalSection( &m_CS ); + + + // Measure how long it took to send this. + timer.End(); + unsigned long timeTaken = timer.GetDuration().GetMicroseconds(); + + + // Measure how long it should have taken. + unsigned long estimatedPacketHeaderSize = 32; + unsigned long optimalTimeTaken = (unsigned long)( transmitRateMgr.GetMicrosecondsPerByte() * (nBytesSent + estimatedPacketHeaderSize) ); + + + // If we went faster than we should have, then wait for the difference in time. + if ( timeTaken < optimalTimeTaken ) + { + rateLimiter.NoteExcessTimeTaken( optimalTimeTaken - timeTaken ); + } + } + + return 0; +} + + +void CMasterMulticastThread::IncrementChunkRefCount( CMasterMulticastThread::CMulticastFile *pFile, int iChunk ) +{ + CChunkInfo *pChunk = &pFile->m_Chunks[iChunk]; + + if ( pChunk->m_RefCount == 0 ) + { + ++m_nTotalActiveChunks; + + // Move the chunk to the head of the list since it is now active. + pFile->m_ActiveChunks.Remove( pChunk->m_iActiveChunksIndex ); + pChunk->m_iActiveChunksIndex = pFile->m_ActiveChunks.AddToHead( pChunk ); + } + + pChunk->m_RefCount++; +} + + +void CMasterMulticastThread::DecrementChunkRefCount( int iFile, int iChunk ) +{ + CMulticastFile *pFile = m_Files[iFile]; + CChunkInfo *pChunk = &pFile->m_Chunks[iChunk]; + + if ( pChunk->m_RefCount == 0 ) + { + Error( "CMasterMulticastThread::DecrementChunkRefCount - refcount already zero!\n" ); + } + + pChunk->m_RefCount--; + if ( pChunk->m_RefCount == 0 ) + { + --m_nTotalActiveChunks; + + // If this is the current chunk the thread is reading on, seek up to the next chunk so + // the thread doesn't spin off into the next file and skip its current file's contents. + if ( iFile == m_iCurFile && pChunk->m_iActiveChunksIndex == m_iCurActiveChunk ) + { + m_iCurActiveChunk = pFile->m_ActiveChunks.Next( pChunk->m_iActiveChunksIndex ); + } + + // Move the chunk to the end of the list since it is now inactive. + pFile->m_ActiveChunks.Remove( pChunk->m_iActiveChunksIndex ); + pChunk->m_iActiveChunksIndex = pFile->m_ActiveChunks.AddToTail( pChunk ); + } +} + + +int CMasterMulticastThread::FindFile( const char *pName, const char *pPathID ) +{ + FOR_EACH_LL( m_Files, i ) + { + CMulticastFile *pFile = m_Files[i]; + if ( stricmp( pFile->GetFilename(), pName ) == 0 && stricmp( pFile->GetPathID(), pPathID ) == 0 ) + return i; + } + return -1; +} + + +bool CMasterMulticastThread::FindWarningSuppression( const char *pFilename ) +{ + FOR_EACH_LL( m_WarningSuppressions, i ) + { + if ( Q_stricmp( m_WarningSuppressions[i], pFilename ) == 0 ) + return true; + } + return false; +} + + +void CMasterMulticastThread::AddWarningSuppression( const char *pFilename ) +{ + char *pBlah = new char[ strlen( pFilename ) + 1 ]; + strcpy( pBlah, pFilename ); + m_WarningSuppressions.AddToTail( pBlah ); +} + + +int CMasterMulticastThread::FindOrAddFile( const char *pFilename, const char *pPathID ) +{ + CMulticastFile *pFile = NULL; + bool bFileAlreadyExisted = false; + + // See if we've already opened this file. + int iFile = FindFile( pFilename, pPathID ); + if ( iFile != -1 ) + { + pFile = m_Files[iFile]; + if ( pFile->m_bDataLoaded ) + { + return iFile; + } + else + { + // Ok, we have the file entry, but its data has been freed, so we need to reload it. + EnterCriticalSection( &m_CS ); + bFileAlreadyExisted = true; + } + } + + // Can't open a file outside our main thread, because we have to talk to the filesystem + // and the filesystem doesn't support that. + Assert( GetCurrentThread() == m_hMainThread ); + + // When the worker originally asked for the path ID, they could pass NULL and it would come through as "". + // Now set it back to null for the filesystem we're passing the call to. + FileHandle_t fp = m_pPassThru->Open( pFilename, "rb", pPathID[0] == 0 ? NULL : pPathID ); + if ( !fp ) + { + if ( bFileAlreadyExisted ) + LeaveCriticalSection( &m_CS ); + + return -1; + } + + if ( !bFileAlreadyExisted ) + pFile = new CMulticastFile; + + pFile->m_UncompressedData.SetSize( m_pPassThru->Size( fp ) ); + m_pPassThru->Read( pFile->m_UncompressedData.Base(), pFile->m_UncompressedData.Count(), fp ); + m_pPassThru->Close( fp ); + + int iRet = FinishFileSetup( pFile, pFilename, pPathID, bFileAlreadyExisted ); + if ( bFileAlreadyExisted ) + LeaveCriticalSection( &m_CS ); + + return iRet; +} + + +int CMasterMulticastThread::FinishFileSetup( CMulticastFile *pFile, const char *pFilename, const char *pPathID, bool bFileAlreadyExisted ) +{ + // Compress the file's contents. + if ( !ZLibCompress( pFile->m_UncompressedData.Base(), pFile->m_UncompressedData.Count(), pFile->m_Data ) ) + { + delete pFile; + return -1; + } + + pFile->m_bDataLoaded = true; + int chunkSize = VMPI_GetChunkPayloadSize(); + + // Get this file in the queue. + if ( !bFileAlreadyExisted ) + { + pFile->m_Filename.SetSize( strlen( pFilename ) + 1 ); + strcpy( pFile->m_Filename.Base(), pFilename ); + + pFile->m_PathID.SetSize( strlen( pPathID ) + 1 ); + strcpy( pFile->m_PathID.Base(), pPathID ); + + pFile->m_nCycles = 0; + + pFile->m_Info.m_CompressedSize = pFile->m_Data.Count(); + pFile->m_Info.m_UncompressedSize = pFile->m_UncompressedData.Count(); + + pFile->m_Info.m_nChunks = PAD_NUMBER( pFile->m_Info.m_CompressedSize, chunkSize ) / chunkSize; + + // Initialize the chunks. + pFile->m_Chunks.SetSize( pFile->m_Info.m_nChunks ); + for ( int i=0; i < pFile->m_Chunks.Count(); i++ ) + { + CChunkInfo *pChunk = &pFile->m_Chunks[i]; + + pChunk->m_iChunk = (unsigned short)i; + pChunk->m_RefCount = 0; + pChunk->m_iActiveChunksIndex = pFile->m_ActiveChunks.AddToTail( pChunk ); + } + + EnterCriticalSection( &m_CS ); + } + + // Boot some other file out of memory if we're out of space. + m_nCurMemoryUsage += ( pFile->m_Info.m_CompressedSize + pFile->m_Info.m_UncompressedSize ); + EnsureMemoryLimit( pFile ); + + if ( !bFileAlreadyExisted ) + { + pFile->m_Info.m_FileID = m_Files.AddToTail( pFile ); + LeaveCriticalSection( &m_CS ); + } + + return pFile->m_Info.m_FileID; +} + + +void CMasterMulticastThread::EnsureMemoryLimit( CMulticastFile *pIgnore ) +{ + if ( m_nMaxMemoryUsage != 0 && m_nCurMemoryUsage > m_nMaxMemoryUsage ) + { + // Free all the files that we can. + FOR_EACH_LL( m_Files, iFile ) + { + CMulticastFile *pFile = m_Files[iFile]; + if ( pFile == pIgnore || !pFile->m_bDataLoaded ) + continue; + + if ( pFile->m_ActiveChunks.Count() == 0 ) + { + m_nCurMemoryUsage -= ( pFile->m_Info.m_CompressedSize + pFile->m_Info.m_UncompressedSize ); + + pFile->m_Data.Purge(); + pFile->m_UncompressedData.Purge(); + pFile->m_bDataLoaded = false; + } + } + } +} + + +const CUtlVector<char>& CMasterMulticastThread::GetFileData( int iFile ) const +{ + return m_Files[iFile]->m_UncompressedData; +} + + +// ------------------------------------------------------------------------------------------------------------------------ // +// CMasterVMPIFileSystem implementation. +// ------------------------------------------------------------------------------------------------------------------------ // + +class CMasterVMPIFileSystem : public CBaseVMPIFileSystem +{ +public: + CMasterVMPIFileSystem(); + virtual ~CMasterVMPIFileSystem(); + + bool Init( int maxMemoryUsage, IFileSystem *pPassThru ); + virtual void Term(); + + virtual FileHandle_t Open( const char *pFilename, const char *pOptions, const char *pathID ); + virtual bool HandleFileSystemPacket( MessageBuffer *pBuf, int iSource, int iPacketID ); + + virtual void CreateVirtualFile( const char *pFilename, const void *pData, int fileLength ); + + virtual CSysModule *LoadModule( const char *pFileName, const char *pPathID, bool bValidatedDllOnly ); + virtual void UnloadModule( CSysModule *pModule ); + + +private: + + static void OnClientDisconnect( int procID, const char *pReason ); + + +private: + CMasterMulticastThread m_MasterThread; + IFileSystem *m_pMasterVMPIFileSystemPassThru; + + static CMasterVMPIFileSystem *s_pMasterVMPIFileSystem; +}; + + +CMasterVMPIFileSystem *CMasterVMPIFileSystem::s_pMasterVMPIFileSystem = NULL; + + +CBaseVMPIFileSystem* CreateMasterVMPIFileSystem( int maxMemoryUsage, IFileSystem *pPassThru ) +{ + CMasterVMPIFileSystem *pRet = new CMasterVMPIFileSystem; + g_pBaseVMPIFileSystem = pRet; + if ( pRet->Init( maxMemoryUsage, pPassThru ) ) + { + return pRet; + } + else + { + delete pRet; + g_pBaseVMPIFileSystem = NULL; + return NULL; + } +} + + +CMasterVMPIFileSystem::CMasterVMPIFileSystem() +{ + Assert( !s_pMasterVMPIFileSystem ); + s_pMasterVMPIFileSystem = this; +} + + +CMasterVMPIFileSystem::~CMasterVMPIFileSystem() +{ + Assert( s_pMasterVMPIFileSystem == this ); + s_pMasterVMPIFileSystem = NULL; +} + + +bool CMasterVMPIFileSystem::Init( int maxMemoryUsage, IFileSystem *pPassThru ) +{ + // Only init the BASE filesystem passthru. Leave the IFileSystem passthru using NULL so it'll crash + // immediately if they try to use a function we don't support. + InitPassThru( pPassThru, true ); + m_pMasterVMPIFileSystemPassThru = pPassThru; + + // Pick a random IP in the multicast range (224.0.0.2 to 239.255.255.255); + CCycleCount cnt; + cnt.Sample(); + RandomSeed( (int)cnt.GetMicroseconds() ); + + int localPort = 23412; // This can be anything. + + unsigned short port = RandomInt( 22000, 25000 ); + if ( VMPI_GetRunMode() == VMPI_RUN_NETWORKED ) + { + if ( VMPI_GetFileSystemMode() == VMPI_FILESYSTEM_MULTICAST ) + { + m_MulticastIP.port = port; + m_MulticastIP.ip[0] = (unsigned char)RandomInt( 225, 238 ); + m_MulticastIP.ip[1] = (unsigned char)RandomInt( 0, 255 ); + m_MulticastIP.ip[2] = (unsigned char)RandomInt( 0, 255 ); + m_MulticastIP.ip[3] = (unsigned char)RandomInt( 3, 255 ); + } + else if ( VMPI_GetFileSystemMode() == VMPI_FILESYSTEM_BROADCAST ) + { + m_MulticastIP.Init( 0xFF, 0xFF, 0xFF, 0xFF, port ); + } + } + else + { + // Doesn't matter.. we don't use the multicast IP in TCP mode. + m_MulticastIP.Init( 0, 0, 0, 0, 0 ); + } + + if ( !m_MasterThread.Init( pPassThru, localPort, &m_MulticastIP, maxMemoryUsage ) ) + return false; + + // Send out the multicast addr to all the clients. + SendMulticastIP( &m_MulticastIP ); + + // Make sure we're notified when a client disconnects so we can unlink them from the + // multicast thread's structures. + VMPI_AddDisconnectHandler( &CMasterVMPIFileSystem::OnClientDisconnect ); + return true; +} + + +void CMasterVMPIFileSystem::Term() +{ + m_MasterThread.Term(); +} + + +FileHandle_t CMasterVMPIFileSystem::Open( const char *pFilename, const char *pOptions, const char *pPathID ) +{ + Assert( g_bUseMPI ); + + if ( g_bDisableFileAccess ) + Error( "Open( %s, %s ) - file access has been disabled.", pFilename, pOptions ); + + // Use a stdio file if they want to write to it. + bool bWriteAccess = IsOpeningForWriteAccess( pOptions ); + if ( bWriteAccess ) + { + FileHandle_t fp = m_pBaseFileSystemPassThru->Open( pFilename, pOptions, pPathID ); + if ( fp == FILESYSTEM_INVALID_HANDLE ) + return FILESYSTEM_INVALID_HANDLE; + + CVMPIFile_PassThru *pFile = new CVMPIFile_PassThru; + pFile->Init( m_pBaseFileSystemPassThru, fp ); + return (FileHandle_t)pFile; + } + + // Internally, we require path IDs to be non-null. We'll convert it back to null whenever we make filesystem calls though. + if ( !pPathID ) + pPathID = ""; + + // Have our multicast thread load all the data so it's there when workers want it. + int iFile = m_MasterThread.FindOrAddFile( pFilename, pPathID ); + if ( iFile == -1 ) + return FILESYSTEM_INVALID_HANDLE; + + const CUtlVector<char> &data = m_MasterThread.GetFileData( iFile ); + + CVMPIFile_Memory *pFile = new CVMPIFile_Memory; + pFile->Init( data.Base(), data.Count(), strchr( pOptions, 't' ) ? 't' : 'b' ); + return (FileHandle_t)pFile; +} + + +void CMasterVMPIFileSystem::OnClientDisconnect( int procID, const char *pReason ) +{ + s_pMasterVMPIFileSystem->m_MasterThread.OnClientDisconnect( procID ); +} + + +void CMasterVMPIFileSystem::CreateVirtualFile( const char *pFilename, const void *pData, int fileLength ) +{ + m_MasterThread.CreateVirtualFile( pFilename, pData, fileLength ); +} + +bool CMasterVMPIFileSystem::HandleFileSystemPacket( MessageBuffer *pBuf, int iSource, int iPacketID ) +{ + // Handle this packet. + int subPacketID = pBuf->data[1]; + switch( subPacketID ) + { + case VMPI_FSPACKETID_FILE_REQUEST: + { + int requestID = *((int*)&pBuf->data[2]); + const char *pFilename = (const char*)&pBuf->data[6]; + const char *pPathID = (const char*)pFilename + strlen( pFilename ) + 1; + + if ( g_iVMPIVerboseLevel >= 2 ) + Msg( "Client %d requested '%s'\n", iSource, pFilename ); + + bool bZeroLength; + int fileID = m_MasterThread.AddFileRequest( pFilename, pPathID, iSource, &bZeroLength ); + + // Send back the file ID. + unsigned char cPacket[2] = { VMPI_PACKETID_FILESYSTEM, VMPI_FSPACKETID_FILE_RESPONSE }; + void *pChunks[4] = { cPacket, &requestID, &fileID, &bZeroLength }; + int chunkLen[4] = { sizeof( cPacket ), sizeof( requestID ), sizeof( fileID ), sizeof( bZeroLength ) }; + + VMPI_SendChunks( pChunks, chunkLen, ARRAYSIZE( pChunks ), iSource ); + } + return true; + + case VMPI_FSPACKETID_CHUNK_RECEIVED: + { + unsigned short *pFileID = (unsigned short*)&pBuf->data[2]; + unsigned short *pChunkID = pFileID+1; + + int nChunks = (pBuf->getLen() - 2) / 4; + for ( int i=0; i < nChunks; i++ ) + { + m_MasterThread.OnChunkReceived( *pFileID, iSource, *pChunkID ); + pFileID += 2; + pChunkID += 2; + } + } + return true; + + case VMPI_FSPACKETID_FILE_RECEIVED: + { + unsigned short *pFileID = (unsigned short*)&pBuf->data[2]; + m_MasterThread.OnFileReceived( *pFileID, iSource ); + } + return true; + + default: + return false; + } +} + + +CSysModule* CMasterVMPIFileSystem::LoadModule( const char *pFileName, const char *pPathID, bool bValidatedDllOnly ) +{ + return m_pMasterVMPIFileSystemPassThru->LoadModule( pFileName, pPathID, bValidatedDllOnly ); +} + +void CMasterVMPIFileSystem::UnloadModule( CSysModule *pModule ) +{ + m_pMasterVMPIFileSystemPassThru->UnloadModule( pModule ); +} + diff --git a/utils/vmpi/vmpi_filesystem_worker.cpp b/utils/vmpi/vmpi_filesystem_worker.cpp new file mode 100644 index 0000000..ef5820d --- /dev/null +++ b/utils/vmpi/vmpi_filesystem_worker.cpp @@ -0,0 +1,815 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//=============================================================================// + +#include <winsock2.h> +#include "vmpi_filesystem_internal.h" +#include "threadhelpers.h" +#include "zlib.h" + + +#define NUM_BUFFERED_CHUNK_ACKS 512 +#define ACK_FLUSH_INTERVAL 500 // Flush the ack queue twice per second. + + +static bool g_bReceivedMulticastIP = false; +static CIPAddr g_MulticastIP; + + +CCriticalSection g_FileResponsesCS; + +class CFileResponse +{ +public: + int m_RequestID; + int m_Response; + bool m_bZeroLength; +}; + +CUtlVector<CFileResponse> g_FileResponses; +int g_RequestID = 0; + + +class CFileChunkPacket +{ +public: + int m_Len; + char m_Data[1]; +}; +CUtlLinkedList<CFileChunkPacket*, int> g_FileChunkPackets; // This is also protected by g_FileResponsesCS. + + +// ------------------------------------------------------------------------------------------------------------------------ // +// Classes. +// ------------------------------------------------------------------------------------------------------------------------ // + +class CWorkerFile +{ +public: + const char* GetFilename() { return m_Filename.Base(); } + const char* GetPathID() { return m_PathID.Base(); } + bool IsReadyToRead() const { return m_nChunksToReceive == 0; } + + +public: + CFastTimer m_Timer; // To see how long it takes to download the file. + + // This has to be sent explicitly as part of the file info or else the protocol + // breaks on empty files. + bool m_bZeroLength; + + // This is false until we get any packets about the file. In the packets, + // we find out what the size is supposed to be. + bool m_bGotCompressedSize; + + // The ID the master uses to refer to this file. + int m_FileID; + + CUtlVector<char> m_Filename; + CUtlVector<char> m_PathID; + + // First data comes in here, then when it's all there, it is inflated into m_UncompressedData. + CUtlVector<char> m_CompressedData; + + // 1 bit for each chunk. + CUtlVector<unsigned char> m_ChunksReceived; + + // When this is zero, the file is done being received and m_UncompressedData is valid. + int m_nChunksToReceive; + CUtlVector<char> m_UncompressedData; +}; + + + +// ------------------------------------------------------------------------------------------------------------------------ // +// Global helpers. +// ------------------------------------------------------------------------------------------------------------------------ // + +static void RecvMulticastIP( CIPAddr *pAddr ) +{ + while ( !g_bReceivedMulticastIP ) + VMPI_DispatchNextMessage(); + + *pAddr = g_MulticastIP; +} + + +static bool ZLibDecompress( const void *pInput, int inputLen, void *pOut, int outLen ) +{ + if ( inputLen == 0 ) + { + // Zero-length file? + return true; + } + + z_stream decompressStream; + + // Initialize the decompression stream. + memset( &decompressStream, 0, sizeof( decompressStream ) ); + if ( inflateInit( &decompressStream ) != Z_OK ) + return false; + + // Decompress all this stuff and write it to the file. + decompressStream.next_in = (unsigned char*)pInput; + decompressStream.avail_in = inputLen; + + char *pOutChar = (char*)pOut; + while ( decompressStream.avail_in ) + { + decompressStream.total_out = 0; + decompressStream.next_out = (unsigned char*)pOutChar; + decompressStream.avail_out = outLen - (pOutChar - (char*)pOut); + + int ret = inflate( &decompressStream, Z_NO_FLUSH ); + if ( ret != Z_OK && ret != Z_STREAM_END ) + return false; + + + pOutChar += decompressStream.total_out; + + if ( ret == Z_STREAM_END ) + { + if ( (pOutChar - (char*)pOut) == outLen ) + { + return true; + } + else + { + Assert( false ); + return false; + } + } + } + + Assert( false ); // Should have gotten to Z_STREAM_END. + return false; +} + + +// ------------------------------------------------------------------------------------------------------------------------ // +// CWorkerMulticastListener implementation. +// ------------------------------------------------------------------------------------------------------------------------ // + +class CWorkerMulticastListener +{ +public: + CWorkerMulticastListener() + { + m_nUnfinishedFiles = 0; + } + + ~CWorkerMulticastListener() + { + Term(); + } + + bool Init( const CIPAddr &mcAddr ) + { + m_MulticastAddr = mcAddr; + m_hMainThread = GetCurrentThread(); + return true; + } + + void Term() + { + m_WorkerFiles.PurgeAndDeleteElements(); + } + + + CWorkerFile* RequestFileFromServer( const char *pFilename, const char *pPathID ) + { + Assert( pPathID ); + Assert( FindWorkerFile( pFilename, pPathID ) == NULL ); + + // Send a request to the master to find out if this file even exists. + CCriticalSectionLock csLock( &g_FileResponsesCS ); + csLock.Lock(); + int requestID = g_RequestID++; + csLock.Unlock(); + + unsigned char packetID[2] = { VMPI_PACKETID_FILESYSTEM, VMPI_FSPACKETID_FILE_REQUEST }; + const void *pChunks[4] = { packetID, &requestID, (void*)pFilename, pPathID }; + int chunkLengths[4] = { sizeof( packetID ), sizeof( requestID ), strlen( pFilename ) + 1, strlen( pPathID ) + 1 }; + VMPI_SendChunks( pChunks, chunkLengths, ARRAYSIZE( pChunks ), 0 ); + + // Wait for the file ID to come back. + CFileResponse response; + response.m_Response = -1; + response.m_bZeroLength = true; + + // We're in a worker thread.. the main thread should be dispatching all the messages, so let it + // do that until we get our response. + while ( 1 ) + { + bool bGotIt = false; + csLock.Lock(); + for ( int iResponse=0; iResponse < g_FileResponses.Count(); iResponse++ ) + { + if ( g_FileResponses[iResponse].m_RequestID == requestID ) + { + response = g_FileResponses[iResponse]; + g_FileResponses.Remove( iResponse ); + bGotIt = true; + break; + } + } + csLock.Unlock(); + + if ( bGotIt ) + break; + + if ( GetCurrentThread() == m_hMainThread ) + VMPI_DispatchNextMessage( 20 ); + else + Sleep( 20 ); + } + + // If we get -1 back, it means the file doesn't exist. + int fileID = response.m_Response; + if ( fileID == -1 ) + return NULL; + + CWorkerFile *pTestFile = new CWorkerFile; + + pTestFile->m_Filename.SetSize( strlen( pFilename ) + 1 ); + strcpy( pTestFile->m_Filename.Base(), pFilename ); + + pTestFile->m_PathID.SetSize( strlen( pPathID ) + 1 ); + strcpy( pTestFile->m_PathID.Base(), pPathID ); + + pTestFile->m_FileID = fileID; + pTestFile->m_nChunksToReceive = 9999; + pTestFile->m_Timer.Start(); + m_WorkerFiles.AddToTail( pTestFile ); + pTestFile->m_bGotCompressedSize = false; + pTestFile->m_bZeroLength = response.m_bZeroLength; + + ++m_nUnfinishedFiles; + + return pTestFile; + } + + void FlushAckChunks( unsigned short chunksToAck[NUM_BUFFERED_CHUNK_ACKS][2], int &nChunksToAck, DWORD &lastAckTime ) + { + if ( nChunksToAck ) + { + // Tell the master we received this chunk. + unsigned char packetID[2] = { VMPI_PACKETID_FILESYSTEM, VMPI_FSPACKETID_CHUNK_RECEIVED }; + void *pChunks[2] = { packetID, chunksToAck }; + int chunkLengths[2] = { sizeof( packetID ), nChunksToAck * 4 }; + VMPI_SendChunks( pChunks, chunkLengths, 2, 0 ); + nChunksToAck = 0; + } + + lastAckTime = GetTickCount(); + } + + void MaybeFlushAckChunks( unsigned short chunksToAck[NUM_BUFFERED_CHUNK_ACKS][2], int &nChunksToAck, DWORD &lastAckTime ) + { + if ( nChunksToAck && GetTickCount() - lastAckTime > ACK_FLUSH_INTERVAL ) + FlushAckChunks( chunksToAck, nChunksToAck, lastAckTime ); + } + + void AddAckChunk( + unsigned short chunksToAck[NUM_BUFFERED_CHUNK_ACKS][2], + int &nChunksToAck, + DWORD &lastAckTime, + int fileID, + int iChunk ) + { + chunksToAck[nChunksToAck][0] = (unsigned short)fileID; + chunksToAck[nChunksToAck][1] = (unsigned short)iChunk; + + // TCP filesystem acks all chunks immediately so it'll send more. + ++nChunksToAck; + if ( nChunksToAck == NUM_BUFFERED_CHUNK_ACKS || VMPI_GetFileSystemMode() == VMPI_FILESYSTEM_TCP ) + { + FlushAckChunks( chunksToAck, nChunksToAck, lastAckTime ); + } + } + + // Returns the length of the packet's data or -1 if there is nothing. + int CheckFileChunkPackets( char *data, int dataSize ) + { + // Using TCP.. pop the next received packet off the stack. + CCriticalSectionLock csLock( &g_FileResponsesCS ); + csLock.Lock(); + if ( g_FileChunkPackets.Count() <= 0 ) + return -1; + + CFileChunkPacket *pPacket = g_FileChunkPackets[ g_FileChunkPackets.Head() ]; + g_FileChunkPackets.Remove( g_FileChunkPackets.Head() ); + + // Yes, this is inefficient, but the amount of data we're handling here is tiny so the + // effect is negligible. + int len; + if ( pPacket->m_Len > dataSize ) + { + len = -1; + Warning( "CWorkerMulticastListener::ListenFor: Got a section of data too long (%d bytes).", pPacket->m_Len ); + } + else + { + memcpy( data, pPacket->m_Data, pPacket->m_Len ); + len = pPacket->m_Len; + } + + free( pPacket ); + return len; + } + + void ShowSDKWorkerMsg( const char *pMsg, ... ) + { + if ( !g_bMPIMaster && VMPI_IsSDKMode() ) + { + va_list marker; + va_start( marker, pMsg ); + char str[4096]; + V_vsnprintf( str, sizeof( str ), pMsg, marker ); + va_end( marker ); + Msg( "%s", str ); + } + } + + // This is the main function the workers use to pick files out of the multicast stream. + // The app is waiting for a specific file, but we receive and ack any files we can until + // we get the file they're looking for, then we return. + // + // NOTE: ideally, this would be in a thread, but it adds lots of complications and may + // not be worth it. + CWorkerFile* ListenFor( const char *pFilename, const char *pPathID ) + { + CWorkerFile *pFile = FindWorkerFile( pFilename, pPathID ); + if ( !pFile ) + { + // Ok, we haven't requested this file yet. Create an entry for it and + // tell the master we'd like this file. + pFile = RequestFileFromServer( pFilename, pPathID ); + if ( !pFile ) + return NULL; + + // If it's zero-length, we can return right now. + if ( pFile->m_bZeroLength ) + { + --m_nUnfinishedFiles; + return pFile; + } + } + + // Setup a filename to print some debug spew with. + char printableFilename[58]; + if ( V_strlen( pFilename ) > ARRAYSIZE( printableFilename ) - 1 ) + { + V_strncpy( printableFilename, "[...]", sizeof( printableFilename ) ); + V_strncat( printableFilename, &pFilename[V_strlen(pFilename) - ARRAYSIZE(printableFilename) + 1 + V_strlen(printableFilename)], sizeof( printableFilename ) ); + } + else + { + V_strncpy( printableFilename, pFilename, sizeof( printableFilename ) ); + } + ShowSDKWorkerMsg( "\rRecv %s (0%%) ", printableFilename ); + int iChunkPayloadSize = VMPI_GetChunkPayloadSize(); + + // Now start listening to the stream. + // Note: no need to setup anything when in TCP mode - we just use the regular + // VMPI dispatch stuff to handle that. + ISocket *pSocket = NULL; + if ( VMPI_GetFileSystemMode() == VMPI_FILESYSTEM_MULTICAST ) + { + pSocket = CreateMulticastListenSocket( m_MulticastAddr ); + + if ( !pSocket ) + { + char str[512]; + IP_GetLastErrorString( str, sizeof( str ) ); + Warning( "CreateMulticastListenSocket (%d.%d.%d.%d:%d) failed\n%s\n", EXPAND_ADDR( m_MulticastAddr ), str ); + return NULL; + } + } + else if ( VMPI_GetFileSystemMode() == VMPI_FILESYSTEM_BROADCAST ) + { + pSocket = CreateIPSocket(); + if ( !pSocket->BindToAny( m_MulticastAddr.port ) ) + { + pSocket->Release(); + pSocket = NULL; + } + } + + unsigned short chunksToAck[NUM_BUFFERED_CHUNK_ACKS][2]; + int nChunksToAck = 0; + DWORD lastAckTime = GetTickCount(); + + // Now just receive multicast data until this file has been received. + while ( m_nUnfinishedFiles > 0 ) + { + char data[MAX_CHUNK_PAYLOAD_SIZE+1024]; + int len = -1; + + if ( pSocket ) + { + CIPAddr ipFrom; + len = pSocket->RecvFrom( data, sizeof( data ), &ipFrom ); + } + else + { + len = CheckFileChunkPackets( data, sizeof( data ) ); + } + + if ( len == -1 ) + { + // Sleep for 10ms and also handle socket errors. + Sleep( 0 ); + VMPI_DispatchNextMessage( 10 ); + continue; + } + + g_nMulticastBytesReceived += len; + + // Alrighty. Figure out what the deal is with this file. + CMulticastFileInfo *pInfo = (CMulticastFileInfo*)data; + int *piChunk = (int*)( pInfo + 1 ); + const char *pTestFilename = (const char*)( piChunk + 1 ); + const char *pPayload = pTestFilename + strlen( pFilename ) + 1; + int payloadLen = len - ( pPayload - data ); + if ( payloadLen < 0 ) + { + Warning( "CWorkerMulticastListener::ListenFor: invalid packet received on multicast group\n" ); + continue; + } + + + if ( pInfo->m_FileID != pFile->m_FileID ) + continue; + + CWorkerFile *pTestFile = FindWorkerFile( pInfo->m_FileID ); + if ( !pTestFile ) + Error( "FindWorkerFile( %s ) failed\n", pTestFilename ); + + // TODO: reenable this code and disable the if right above here. + // We always get "invalid payload length" errors on the workers when using this, but + // I haven't been able to figure out why yet. + /* + // Put the data into whatever file it belongs in. + if ( !pTestFile ) + { + pTestFile = RequestFileFromServer( pTestFilename ); + if ( !pTestFile ) + continue; + } + */ + + // Is this the first packet about this file? + if ( !pTestFile->m_bGotCompressedSize ) + { + pTestFile->m_bGotCompressedSize = true; + pTestFile->m_CompressedData.SetSize( pInfo->m_CompressedSize ); + pTestFile->m_UncompressedData.SetSize( pInfo->m_UncompressedSize ); + pTestFile->m_ChunksReceived.SetSize( PAD_NUMBER( pInfo->m_nChunks, 8 ) / 8 ); + pTestFile->m_nChunksToReceive = pInfo->m_nChunks; + memset( pTestFile->m_ChunksReceived.Base(), 0, pTestFile->m_ChunksReceived.Count() ); + } + + // Validate the chunk index and uncompressed size. + int iChunk = *piChunk; + if ( iChunk < 0 || iChunk >= pInfo->m_nChunks ) + { + Error( "ListenFor(): invalid chunk index (%d) for file '%s'\n", iChunk, pTestFilename ); + } + + // Only handle this if we didn't already received the chunk. + if ( !(pTestFile->m_ChunksReceived[iChunk >> 3] & (1 << (iChunk & 7))) ) + { + // Make sure the file is properly setup to receive the data into. + if ( (int)pInfo->m_UncompressedSize != pTestFile->m_UncompressedData.Count() || + (int)pInfo->m_CompressedSize != pTestFile->m_CompressedData.Count() ) + { + Error( "ListenFor(): invalid compressed or uncompressed size.\n" + "pInfo = '%s', pTestFile = '%s'\n" + "Compressed (pInfo = %d, pTestFile = %d)\n" + "Uncompressed (pInfo = %d, pTestFile = %d)\n", + pTestFilename, + pTestFile->GetFilename(), + pInfo->m_CompressedSize, + pTestFile->m_CompressedData.Count(), + pInfo->m_UncompressedSize, + pTestFile->m_UncompressedData.Count() + ); + } + + int iChunkStart = iChunk * iChunkPayloadSize; + int iChunkEnd = min( iChunkStart + iChunkPayloadSize, pTestFile->m_CompressedData.Count() ); + int chunkLen = iChunkEnd - iChunkStart; + + if ( chunkLen != payloadLen ) + { + Error( "ListenFor(): invalid payload length for '%s' (%d should be %d)\n" + "pInfo = '%s', pTestFile = '%s'\n" + "Chunk %d out of %d. Compressed size: %d\n", + pTestFile->GetFilename(), + payloadLen, + chunkLen, + pTestFilename, + pTestFile->GetFilename(), + iChunk, + pInfo->m_nChunks, + pInfo->m_CompressedSize + ); + } + + memcpy( &pTestFile->m_CompressedData[iChunkStart], pPayload, chunkLen ); + pTestFile->m_ChunksReceived[iChunk >> 3] |= (1 << (iChunk & 7)); + + --pTestFile->m_nChunksToReceive; + + if ( pTestFile == pFile ) + { + int percent = 100 - (100 * pFile->m_nChunksToReceive) / pInfo->m_nChunks; + ShowSDKWorkerMsg( "\rRecv %s (%d%%) [chunk %d/%d] ", printableFilename, percent, pInfo->m_nChunks - pFile->m_nChunksToReceive, pInfo->m_nChunks ); + } + + // Remember to ack what we received. + AddAckChunk( chunksToAck, nChunksToAck, lastAckTime, pInfo->m_FileID, iChunk ); + + // If we're done receiving the data, unpack it. + if ( pTestFile->m_nChunksToReceive == 0 ) + { + // Ack the file. + FlushAckChunks( chunksToAck, nChunksToAck, lastAckTime ); + + pTestFile->m_Timer.End(); + + pTestFile->m_UncompressedData.SetSize( pInfo->m_UncompressedSize ); + --m_nUnfinishedFiles; + + if ( !ZLibDecompress( + pTestFile->m_CompressedData.Base(), + pTestFile->m_CompressedData.Count(), + pTestFile->m_UncompressedData.Base(), + pTestFile->m_UncompressedData.Count() ) ) + { + if ( pSocket ) + pSocket->Release(); + FlushAckChunks( chunksToAck, nChunksToAck, lastAckTime ); + Error( "ZLibDecompress failed.\n" ); + return NULL; + } + + char str[512]; + V_snprintf( str, sizeof( str ), "Got %s (%dk) in %.2fs", + printableFilename, + (pTestFile->m_UncompressedData.Count() + 511) / 1024, + pTestFile->m_Timer.GetDuration().GetSeconds() + ); + Msg( "\r%-79s\n", str ); + + // Won't be needing this anymore. + pTestFile->m_CompressedData.Purge(); + } + } + + MaybeFlushAckChunks( chunksToAck, nChunksToAck, lastAckTime ); + } + + Assert( pFile->IsReadyToRead() ); + FlushAckChunks( chunksToAck, nChunksToAck, lastAckTime ); + if ( pSocket ) + pSocket->Release(); + + return pFile; + } + + CWorkerFile* FindWorkerFile( const char *pFilename, const char *pPathID ) + { + FOR_EACH_LL( m_WorkerFiles, i ) + { + CWorkerFile *pWorkerFile = m_WorkerFiles[i]; + + if ( stricmp( pWorkerFile->GetFilename(), pFilename ) == 0 && stricmp( pWorkerFile->GetPathID(), pPathID ) == 0 ) + return pWorkerFile; + } + return NULL; + } + + CWorkerFile* FindWorkerFile( int fileID ) + { + FOR_EACH_LL( m_WorkerFiles, i ) + { + if ( m_WorkerFiles[i]->m_FileID == fileID ) + return m_WorkerFiles[i]; + } + return NULL; + } + + +private: + CIPAddr m_MulticastAddr; + + CUtlLinkedList<CWorkerFile*, int> m_WorkerFiles; + + HANDLE m_hMainThread; + + // How many files do we have open that we haven't finished receiving from the server yet? + // We always keep waiting for data until this is zero. + int m_nUnfinishedFiles; +}; + + + +// ------------------------------------------------------------------------------------------------------------------------ // +// CWorkerVMPIFileSystem implementation. +// ------------------------------------------------------------------------------------------------------------------------ // + +class CWorkerVMPIFileSystem : public CBaseVMPIFileSystem +{ +public: + InitReturnVal_t Init(); + virtual void Term(); + + virtual FileHandle_t Open( const char *pFilename, const char *pOptions, const char *pathID ); + virtual bool HandleFileSystemPacket( MessageBuffer *pBuf, int iSource, int iPacketID ); + + virtual void CreateVirtualFile( const char *pFilename, const void *pData, int fileLength ); + virtual long GetFileTime( const char *pFileName, const char *pathID ); + virtual bool IsFileWritable( const char *pFileName, const char *pPathID ); + virtual bool SetFileWritable( char const *pFileName, bool writable, const char *pPathID ); + + virtual CSysModule *LoadModule( const char *pFileName, const char *pPathID, bool bValidatedDllOnly ); + virtual void UnloadModule( CSysModule *pModule ); + +private: + CWorkerMulticastListener m_Listener; +}; + + +CBaseVMPIFileSystem* CreateWorkerVMPIFileSystem() +{ + CWorkerVMPIFileSystem *pRet = new CWorkerVMPIFileSystem; + g_pBaseVMPIFileSystem = pRet; + if ( pRet->Init() ) + { + return pRet; + } + else + { + delete pRet; + g_pBaseVMPIFileSystem = NULL; + return NULL; + } +} + + +InitReturnVal_t CWorkerVMPIFileSystem::Init() +{ + // Get the multicast addr to listen on. + CIPAddr mcAddr; + RecvMulticastIP( &mcAddr ); + + return m_Listener.Init( mcAddr ) ? INIT_OK : INIT_FAILED; +} + + +void CWorkerVMPIFileSystem::Term() +{ + m_Listener.Term(); +} + + +FileHandle_t CWorkerVMPIFileSystem::Open( const char *pFilename, const char *pOptions, const char *pathID ) +{ + Assert( g_bUseMPI ); + + // When it finally asks the filesystem for a file, it'll pass NULL for pathID if it's "". + if ( !pathID ) + pathID = ""; + + if ( g_bDisableFileAccess ) + Error( "Open( %s, %s ) - file access has been disabled.", pFilename, pOptions ); + + // Workers can't open anything for write access. + bool bWriteAccess = (Q_stristr( pOptions, "w" ) != 0); + if ( bWriteAccess ) + return FILESYSTEM_INVALID_HANDLE; + + // Do we have this file's data already? + CWorkerFile *pFile = m_Listener.FindWorkerFile( pFilename, pathID ); + if ( !pFile || !pFile->IsReadyToRead() ) + { + // Ok, start listening to the multicast stream until we get the file we want. + + // NOTE: it might make sense here to have the client ask for a list of ALL the files that + // the master currently has and wait to receive all of them (so we don't come back a bunch + // of times and listen + + // NOTE NOTE: really, the best way to do this is to have a thread on the workers that sits there + // and listens to the multicast stream. Any time the master opens a new file up, it assumes + // all the workers need the file, and it starts to send it on the multicast stream until + // the worker threads respond that they all have it. + // + // (NOTE: this probably means that the clients would have to ack the chunks on a UDP socket that + // the thread owns). + // + // This would simplify all the worries about a client missing half the stream and having to + // wait for another cycle through it. + pFile = m_Listener.ListenFor( pFilename, pathID ); + + if ( !pFile ) + { + return FILESYSTEM_INVALID_HANDLE; + } + } + + // Ok! Got the file. now setup a memory stream they can read out of it with. + CVMPIFile_Memory *pOut = new CVMPIFile_Memory; + pOut->Init( pFile->m_UncompressedData.Base(), pFile->m_UncompressedData.Count(), strchr( pOptions, 't' ) ? 't' : 'b' ); + return (FileHandle_t)pOut; +} + + +void CWorkerVMPIFileSystem::CreateVirtualFile( const char *pFilename, const void *pData, int fileLength ) +{ + Error( "CreateVirtualFile not supported in VMPI worker filesystem." ); +} + + +long CWorkerVMPIFileSystem::GetFileTime( const char *pFileName, const char *pathID ) +{ + Error( "GetFileTime not supported in VMPI worker filesystem." ); + return 0; +} + + +bool CWorkerVMPIFileSystem::IsFileWritable( const char *pFileName, const char *pPathID ) +{ + Error( "GetFileTime not supported in VMPI worker filesystem." ); + return false; +} + + +bool CWorkerVMPIFileSystem::SetFileWritable( char const *pFileName, bool writable, const char *pPathID ) +{ + Error( "GetFileTime not supported in VMPI worker filesystem." ); + return false; +} + +bool CWorkerVMPIFileSystem::HandleFileSystemPacket( MessageBuffer *pBuf, int iSource, int iPacketID ) +{ + // Handle this packet. + int subPacketID = pBuf->data[1]; + switch( subPacketID ) + { + case VMPI_FSPACKETID_MULTICAST_ADDR: + { + char *pInPos = &pBuf->data[2]; + + g_MulticastIP = *((CIPAddr*)pInPos); + pInPos += sizeof( g_MulticastIP ); + + g_bReceivedMulticastIP = true; + } + return true; + + case VMPI_FSPACKETID_FILE_RESPONSE: + { + CCriticalSectionLock csLock( &g_FileResponsesCS ); + csLock.Lock(); + + CFileResponse res; + res.m_RequestID = *((int*)&pBuf->data[2]); + res.m_Response = *((int*)&pBuf->data[6]); + res.m_bZeroLength = *((bool*)&pBuf->data[10]); + + g_FileResponses.AddToTail( res ); + } + return true; + + case VMPI_FSPACKETID_FILE_CHUNK: + { + int nDataBytes = pBuf->getLen() - 2; + + CFileChunkPacket *pPacket = (CFileChunkPacket*)malloc( sizeof( CFileChunkPacket ) + nDataBytes - 1 ); + memcpy( pPacket->m_Data, &pBuf->data[2], nDataBytes ); + pPacket->m_Len = nDataBytes; + + CCriticalSectionLock csLock( &g_FileResponsesCS ); + csLock.Lock(); + g_FileChunkPackets.AddToTail( pPacket ); + } + return true; + + default: + return false; + } +} + +CSysModule* CWorkerVMPIFileSystem::LoadModule( const char *pFileName, const char *pPathID, bool bValidatedDllOnly ) +{ + return Sys_LoadModule( pFileName ); +} + +void CWorkerVMPIFileSystem::UnloadModule( CSysModule *pModule ) +{ + Sys_UnloadModule( pModule ); +} diff --git a/utils/vmpi/vmpi_job_search/JobSearchDlg.cpp b/utils/vmpi/vmpi_job_search/JobSearchDlg.cpp new file mode 100644 index 0000000..e98b726 --- /dev/null +++ b/utils/vmpi/vmpi_job_search/JobSearchDlg.cpp @@ -0,0 +1,473 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// JobSearchDlg.cpp : implementation file +// + +#include "stdafx.h" +#include "JobSearchDlg.h" +#include "imysqlwrapper.h" +#include "tier1/strtools.h" +#include "utllinkedlist.h" +#include "vmpi_browser_helpers.h" +#include "vmpi_defs.h" +#include "net_view_thread.h" + + +#ifdef _DEBUG +#define new DEBUG_NEW +#undef THIS_FILE +static char THIS_FILE[] = __FILE__; +#endif + + +// These are stored with jobs to help with sorting and to remember the job ID. +class CJobInfo +{ +public: + unsigned long m_JobID; + CString m_StartTimeUnformatted; + CString m_MachineName; + CString m_BSPFilename; + DWORD m_RunningTimeMS; +}; + + + +///////////////////////////////////////////////////////////////////////////// +// CJobSearchDlg dialog + + +CJobSearchDlg::CJobSearchDlg(CWnd* pParent /*=NULL*/) + : CDialog(CJobSearchDlg::IDD, pParent) +{ + //{{AFX_DATA_INIT(CJobSearchDlg) + //}}AFX_DATA_INIT + m_pSQL = NULL; + m_hMySQLDLL = NULL; +} + + +CJobSearchDlg::~CJobSearchDlg() +{ + if ( m_pSQL ) + { + m_pSQL->Release(); + } + + if ( m_hMySQLDLL ) + { + Sys_UnloadModule( m_hMySQLDLL ); + } +} + + +void CJobSearchDlg::DoDataExchange(CDataExchange* pDX) +{ + CDialog::DoDataExchange(pDX); + //{{AFX_DATA_MAP(CJobSearchDlg) + DDX_Control(pDX, IDC_WORKER_LIST, m_WorkerList); + DDX_Control(pDX, IDC_USER_LIST, m_UserList); + DDX_Control(pDX, IDC_JOBS_LIST, m_JobsList); + //}}AFX_DATA_MAP +} + + +BEGIN_MESSAGE_MAP(CJobSearchDlg, CDialog) + //{{AFX_MSG_MAP(CJobSearchDlg) + ON_NOTIFY(NM_DBLCLK, IDC_JOBS_LIST, OnDblclkJobsList) + ON_LBN_DBLCLK(IDC_USER_LIST, OnDblclkUserList) + ON_LBN_DBLCLK(IDC_WORKER_LIST, OnDblclkWorkerList) + ON_BN_CLICKED(IDC_QUIT, OnQuit) + ON_WM_SIZE() + //}}AFX_MSG_MAP +END_MESSAGE_MAP() + + +int CJobSearchDlg::GetSelectedJobIndex() +{ + POSITION pos = m_JobsList.GetFirstSelectedItemPosition(); + if ( pos ) + return m_JobsList.GetNextSelectedItem( pos ); + else + return -1; +} + + +///////////////////////////////////////////////////////////////////////////// +// CJobSearchDlg message handlers + +void CJobSearchDlg::OnDblclkJobsList(NMHDR* pNMHDR, LRESULT* pResult) +{ + int iItem = GetSelectedJobIndex(); + if ( iItem != -1 ) + { + CJobInfo *pInfo = (CJobInfo*)m_JobsList.GetItemData( iItem ); + + CString cmdLine; + cmdLine.Format( "vmpi_job_watch -JobID %d -dbname \"%s\" -hostname \"%s\" -username \"%s\"", + pInfo->m_JobID, (const char*)m_DBName, (const char*)m_HostName, (const char*)m_UserName ); + + STARTUPINFO si; + memset( &si, 0, sizeof( si ) ); + si.cb = sizeof( si ); + + PROCESS_INFORMATION pi; + memset( &pi, 0, sizeof( pi ) ); + + if ( !CreateProcess( + NULL, + (char*)(const char*)cmdLine, + NULL, // security + NULL, + TRUE, + 0, // flags + NULL, // environment + NULL, // current directory + &si, + &pi ) ) + { + CString errStr; + errStr.Format( "Error launching '%s'", cmdLine.GetBuffer() ); + MessageBox( errStr, "Error", MB_OK ); + } + } + + *pResult = 0; +} + + +static int CALLBACK JobsSortFn( LPARAM iItem1, LPARAM iItem2, LPARAM lpParam ) +{ + CJobInfo *pInfo1 = (CJobInfo*)iItem1; + CJobInfo *pInfo2 = (CJobInfo*)iItem2; + + return strcmp( pInfo2->m_StartTimeUnformatted, pInfo1->m_StartTimeUnformatted ); +} + + +void CJobSearchDlg::ClearJobsList() +{ + // First, delete all the JobInfo structures we have in it. + int nItems = m_JobsList.GetItemCount(); + for ( int i=0; i < nItems; i++ ) + { + CJobInfo *pInfo = (CJobInfo*)m_JobsList.GetItemData( i ); + delete pInfo; + } + + m_JobsList.DeleteAllItems(); +} + + +void CJobSearchDlg::RepopulateJobsList() +{ + // It's assumed coming into this routine that the caller just executed a query that we can iterate over. + ClearJobsList(); + + CUtlLinkedList<CJobInfo*, int> jobInfos; + while ( GetMySQL()->NextRow() ) + { + CJobInfo *pInfo = new CJobInfo; + pInfo->m_StartTimeUnformatted = GetMySQL()->GetColumnValue( "StartTime" ).String(); + pInfo->m_JobID = GetMySQL()->GetColumnValue( "JobID" ).Int32(); + pInfo->m_MachineName = GetMySQL()->GetColumnValue( "MachineName" ).String(); + pInfo->m_BSPFilename = GetMySQL()->GetColumnValue( "BSPFilename" ).String(); + pInfo->m_RunningTimeMS = GetMySQL()->GetColumnValue( "RunningTimeMS" ).Int32(); + + jobInfos.AddToTail( pInfo ); + } + + + FOR_EACH_LL( jobInfos, j ) + { + CJobInfo *pInfo = jobInfos[j]; + + // Add the item. + int iItem = m_JobsList.InsertItem( 0, "", NULL ); + + // Associate it with the job structure. + m_JobsList.SetItemData( iItem, (DWORD)pInfo ); + + char dateStr[128]; + const char *pDate = pInfo->m_StartTimeUnformatted; + if ( strlen( pDate ) == 14 ) // yyyymmddhhmmss + { + Q_snprintf( dateStr, sizeof( dateStr ), "%c%c/%c%c %c%c:%c%c:00", + pDate[4], pDate[5], + pDate[6], pDate[7], + pDate[8], pDate[9], + pDate[10], pDate[11] ); + } + + m_JobsList.SetItemText( iItem, 0, dateStr ); + m_JobsList.SetItemText( iItem, 1, pInfo->m_MachineName ); + m_JobsList.SetItemText( iItem, 2, pInfo->m_BSPFilename ); + + char timeStr[512]; + if ( pInfo->m_RunningTimeMS == RUNNINGTIME_MS_SENTINEL ) + { + Q_strncpy( timeStr, "?", sizeof( timeStr ) ); + } + else + { + FormatTimeString( pInfo->m_RunningTimeMS / 1000, timeStr, sizeof( timeStr ) ); + } + m_JobsList.SetItemText( iItem, 3, timeStr ); + + char jobIDStr[512]; + Q_snprintf( jobIDStr, sizeof( jobIDStr ), "%d", pInfo->m_JobID ); + m_JobsList.SetItemText( iItem, 4, jobIDStr ); + } + + m_JobsList.SortItems( JobsSortFn, (LPARAM)&m_JobsList ); +} + + +void CJobSearchDlg::OnDblclkUserList() +{ + int sel = m_UserList.GetCurSel(); + if ( sel != LB_ERR ) + { + CString computerName; + m_UserList.GetText( sel, computerName ); + + // Look for jobs that this user initiated. + char query[4096]; + Q_snprintf( query, sizeof( query ), "select RunningTimeMS, JobID, BSPFilename, StartTime, MachineName from job_master_start where MachineName=\"%s\"", (const char*)computerName ); + GetMySQL()->Execute( query ); + + RepopulateJobsList(); + } +} + +void CJobSearchDlg::OnDblclkWorkerList() +{ + int sel = m_WorkerList.GetCurSel(); + if ( sel != LB_ERR ) + { + CString computerName; + m_WorkerList.GetText( sel, computerName ); + + // This query does: + // 1. Take the workers with the specified MachineName. + // 2. Only use IsMaster = 0. + // 3. Now get all the job_master_start records with the same JobID. + char query[4096]; + Q_snprintf( query, sizeof( query ), "select job_master_start.RunningTimeMS, job_master_start.JobID, job_master_start.BSPFilename, job_master_start.StartTime, job_master_start.MachineName " + "from job_master_start, job_worker_start " + "where job_worker_start.MachineName = \"%s\" and " + "IsMaster = 0 and " + "job_master_start.JobID = job_worker_start.JobID", + (const char*)computerName ); + GetMySQL()->Execute( query ); + + RepopulateJobsList(); + } +} + +bool ReadStringFromFile( FILE *fp, char *pStr, int strSize ) +{ + int i=0; + for ( i; i < strSize-2; i++ ) + { + if ( fread( &pStr[i], 1, 1, fp ) != 1 || + pStr[i] == '\n' ) + { + break; + } + } + + pStr[i] = 0; + return i != 0; +} + +const char* FindArg( const char *pArgName, const char *pDefault="" ) +{ + for ( int i=1; i < __argc; i++ ) + { + if ( Q_stricmp( pArgName, __argv[i] ) == 0 ) + { + if ( (i+1) < __argc ) + return __argv[i+1]; + else + return pDefault; + } + } + return NULL; +} + +BOOL CJobSearchDlg::OnInitDialog() +{ + CDialog::OnInitDialog(); + + m_JobsList.SetExtendedStyle( LVS_EX_FULLROWSELECT ); + + char str[512]; + + // Init the mysql database. + const char *pDBName = FindArg( "-dbname", NULL ); + const char *pHostName = FindArg( "-hostname", NULL ); + const char *pUserName = FindArg( "-username", NULL ); + + if ( pDBName && pHostName && pUserName ) + { + m_DBName = pDBName; + m_HostName = pHostName; + m_UserName = pUserName; + } + else + { + // Load the dbinfo_browser.txt file to get the database information. + const char *pFilename = FindArg( "-dbinfo", NULL ); + if ( !pFilename ) + pFilename = "dbinfo_job_search.txt"; + + FILE *fp = fopen( pFilename, "rt" ); + if ( !fp ) + { + Q_snprintf( str, sizeof( str ), "Can't open '%s' for database info.", pFilename ); + MessageBox( str, "Error", MB_OK ); + EndDialog( 0 ); + return FALSE; + } + + char hostName[512], dbName[512], userName[512]; + if ( !ReadStringFromFile( fp, hostName, sizeof( hostName ) ) || + !ReadStringFromFile( fp, dbName, sizeof( dbName ) ) || + !ReadStringFromFile( fp, userName, sizeof( userName ) ) + ) + { + fclose( fp ); + Q_snprintf( str, sizeof( str ), "'%s' has invalid format.", pFilename ); + MessageBox( str, "Error", MB_OK ); + EndDialog( 0 ); + return FALSE; + } + + m_DBName = dbName; + m_HostName = hostName; + m_UserName = userName; + + fclose( fp ); + } + + // Get the mysql interface. + if ( !Sys_LoadInterface( "mysql_wrapper", MYSQL_WRAPPER_VERSION_NAME, &m_hMySQLDLL, (void**)&m_pSQL ) ) + return false; + + if ( !m_pSQL->InitMySQL( m_DBName, m_HostName, m_UserName ) ) + { + Q_snprintf( str, sizeof( str ), "Can't init MYSQL db (db = '%s', host = '%s', user = '%s')", (const char*)m_DBName, (const char*)m_HostName, (const char*)m_UserName ); + MessageBox( str, "Error", MB_OK ); + EndDialog( 0 ); + return FALSE; + } + + // Setup the headers for the job info list. + struct + { + char *pText; + int width; + } titles[] = + { + {"Date", 100}, + {"User", 100}, + {"BSP Filename", 100}, + {"Running Time", 100}, + {"Job ID", 100} + }; + for ( int i=0; i < ARRAYSIZE( titles ); i++ ) + { + m_JobsList.InsertColumn( i, titles[i].pText, LVCFMT_LEFT, titles[i].width, i ); + } + + + CUtlVector<char*> computerNames; + CNetViewThread netView; + netView.Init(); + DWORD startTime = GetTickCount(); + while ( 1 ) + { + netView.GetComputerNames( computerNames ); + if ( computerNames.Count() > 0 ) + break; + + Sleep( 30 ); + if ( GetTickCount() - startTime > 5000 ) + { + Q_snprintf( str, sizeof( str ), "Unable to get computer names Can't init MYSQL db (db = '%s', host = '%s', user = '%s')", (const char*)m_DBName, (const char*)m_HostName, (const char*)m_UserName ); + MessageBox( str, "Error", MB_OK ); + EndDialog( 0 ); + return FALSE; + } + } + + PopulateWorkerList( computerNames ); + PopulateUserList( computerNames ); + + + // Auto-select a worker? + const char *pSelectWorker = FindArg( "-SelectWorker", NULL ); + if ( pSelectWorker ) + { + int index = m_WorkerList.FindString( -1, pSelectWorker ); + if ( index != LB_ERR ) + { + m_WorkerList.SetCurSel( index ); + OnDblclkWorkerList(); + } + } + + + // Setup our anchors. + m_AnchorMgr.AddAnchor( this, GetDlgItem( IDC_SEARCH_BY_USER_PANEL ), ANCHOR_LEFT, ANCHOR_TOP, ANCHOR_WIDTH_PERCENT, ANCHOR_HEIGHT_PERCENT ); + m_AnchorMgr.AddAnchor( this, GetDlgItem( IDC_USER_LIST ), ANCHOR_LEFT, ANCHOR_TOP, ANCHOR_WIDTH_PERCENT, ANCHOR_HEIGHT_PERCENT ); + + m_AnchorMgr.AddAnchor( this, GetDlgItem( IDC_WORKER_PANEL ), ANCHOR_WIDTH_PERCENT, ANCHOR_TOP, ANCHOR_RIGHT, ANCHOR_HEIGHT_PERCENT ); + m_AnchorMgr.AddAnchor( this, GetDlgItem( IDC_WORKER_LIST ), ANCHOR_WIDTH_PERCENT, ANCHOR_TOP, ANCHOR_RIGHT, ANCHOR_HEIGHT_PERCENT ); + + m_AnchorMgr.AddAnchor( this, GetDlgItem( IDC_JOBS_PANEL ), ANCHOR_LEFT, ANCHOR_HEIGHT_PERCENT, ANCHOR_RIGHT, ANCHOR_BOTTOM ); + m_AnchorMgr.AddAnchor( this, GetDlgItem( IDC_JOBS_LIST ), ANCHOR_LEFT, ANCHOR_HEIGHT_PERCENT, ANCHOR_RIGHT, ANCHOR_BOTTOM ); + + m_AnchorMgr.AddAnchor( this, GetDlgItem( IDC_QUIT ), ANCHOR_WIDTH_PERCENT, ANCHOR_BOTTOM, ANCHOR_WIDTH_PERCENT, ANCHOR_BOTTOM ); + + return TRUE; // return TRUE unless you set the focus to a control + // EXCEPTION: OCX Property Pages should return FALSE +} + +void CJobSearchDlg::PopulateWorkerList( CUtlVector<char*> &computerNames ) +{ + m_WorkerList.ResetContent(); + for ( int i=0; i < computerNames.Count(); i++ ) + { + m_WorkerList.AddString( computerNames[i] ); + } +} + +void CJobSearchDlg::PopulateUserList( CUtlVector<char*> &computerNames ) +{ + m_UserList.ResetContent(); + for ( int i=0; i < computerNames.Count(); i++ ) + { + m_UserList.AddString( computerNames[i] ); + } +} + + + +void CJobSearchDlg::OnQuit() +{ + EndDialog( 0 ); +} + +void CJobSearchDlg::OnSize(UINT nType, int cx, int cy) +{ + CDialog::OnSize(nType, cx, cy); + + m_AnchorMgr.UpdateAnchors( this ); +} diff --git a/utils/vmpi/vmpi_job_search/JobSearchDlg.h b/utils/vmpi/vmpi_job_search/JobSearchDlg.h new file mode 100644 index 0000000..6430b8b --- /dev/null +++ b/utils/vmpi/vmpi_job_search/JobSearchDlg.h @@ -0,0 +1,86 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +#if !defined(AFX_JOBSEARCHDLG_H__833A83FF_35CC_42B5_AEB3_AE31C7FDF492__INCLUDED_) +#define AFX_JOBSEARCHDLG_H__833A83FF_35CC_42B5_AEB3_AE31C7FDF492__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 +// JobSearchDlg.h : header file +// + +#include "resource.h" +#include "imysqlwrapper.h" +#include "window_anchor_mgr.h" + + +///////////////////////////////////////////////////////////////////////////// +// CJobSearchDlg dialog + +class CJobSearchDlg : public CDialog +{ +// Construction +public: + CJobSearchDlg(CWnd* pParent = NULL); // standard constructor + virtual ~CJobSearchDlg(); + +// Dialog Data + //{{AFX_DATA(CJobSearchDlg) + enum { IDD = IDD_VMPI_JOB_SEARCH }; + CListBox m_WorkerList; + CListBox m_UserList; + CListCtrl m_JobsList; + //}}AFX_DATA + + +// Overrides + // ClassWizard generated virtual function overrides + //{{AFX_VIRTUAL(CJobSearchDlg) + protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support + //}}AFX_VIRTUAL + +// Implementation +protected: + + void ClearJobsList(); + void RepopulateJobsList(); + + void PopulateWorkerList( CUtlVector<char*> &computerNames ); + void PopulateUserList( CUtlVector<char*> &computerNames ); + + int GetSelectedJobIndex(); + + + // Info on how we connected to the database so we can pass it to apps we launch. + CString m_DBName, m_HostName, m_UserName; + + + IMySQL* GetMySQL() { return m_pSQL; } + IMySQL *m_pSQL; + CSysModule *m_hMySQLDLL; + + CWindowAnchorMgr m_AnchorMgr; + + + // Generated message map functions + //{{AFX_MSG(CJobSearchDlg) + afx_msg void OnDblclkJobsList(NMHDR* pNMHDR, LRESULT* pResult); + afx_msg void OnDblclkUserList(); + afx_msg void OnDblclkWorkerList(); + virtual BOOL OnInitDialog(); + afx_msg void OnQuit(); + afx_msg void OnSize(UINT nType, int cx, int cy); + //}}AFX_MSG + DECLARE_MESSAGE_MAP() +}; + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_JOBSEARCHDLG_H__833A83FF_35CC_42B5_AEB3_AE31C7FDF492__INCLUDED_) diff --git a/utils/vmpi/vmpi_job_search/StdAfx.cpp b/utils/vmpi/vmpi_job_search/StdAfx.cpp new file mode 100644 index 0000000..de47b55 --- /dev/null +++ b/utils/vmpi/vmpi_job_search/StdAfx.cpp @@ -0,0 +1,15 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// stdafx.cpp : source file that includes just the standard includes +// vmpi_browser_job_search.pch will be the pre-compiled header +// stdafx.obj will contain the pre-compiled type information + +#include "stdafx.h" + + + diff --git a/utils/vmpi/vmpi_job_search/StdAfx.h b/utils/vmpi/vmpi_job_search/StdAfx.h new file mode 100644 index 0000000..88ecf03 --- /dev/null +++ b/utils/vmpi/vmpi_job_search/StdAfx.h @@ -0,0 +1,36 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, but +// are changed infrequently +// + +#if !defined(AFX_STDAFX_H__2CCE1890_EB30_4887_B493_6CAB022977E4__INCLUDED_) +#define AFX_STDAFX_H__2CCE1890_EB30_4887_B493_6CAB022977E4__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers + +#include "tier0/basetypes.h" + +#include <afxwin.h> // MFC core and standard components +#include <afxext.h> // MFC extensions +#include <afxdisp.h> // MFC Automation classes +#include <afxdtctl.h> // MFC support for Internet Explorer 4 Common Controls +#ifndef _AFX_NO_AFXCMN_SUPPORT +#include <afxcmn.h> // MFC support for Windows Common Controls +#endif // _AFX_NO_AFXCMN_SUPPORT + + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_STDAFX_H__2CCE1890_EB30_4887_B493_6CAB022977E4__INCLUDED_) diff --git a/utils/vmpi/vmpi_job_search/res/vmpi_browser_job_search.ico b/utils/vmpi/vmpi_job_search/res/vmpi_browser_job_search.ico Binary files differnew file mode 100644 index 0000000..7eef0bc --- /dev/null +++ b/utils/vmpi/vmpi_job_search/res/vmpi_browser_job_search.ico diff --git a/utils/vmpi/vmpi_job_search/res/vmpi_browser_job_search.rc2 b/utils/vmpi/vmpi_job_search/res/vmpi_browser_job_search.rc2 new file mode 100644 index 0000000..03d7a3c --- /dev/null +++ b/utils/vmpi/vmpi_job_search/res/vmpi_browser_job_search.rc2 @@ -0,0 +1,13 @@ +// +// VMPI_BROWSER_JOB_SEARCH.RC2 - resources Microsoft Visual C++ does not edit directly +// + +#ifdef APSTUDIO_INVOKED + #error this file is not editable by Microsoft Visual C++ +#endif //APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// Add manually edited resources here... + +///////////////////////////////////////////////////////////////////////////// diff --git a/utils/vmpi/vmpi_job_search/resource.h b/utils/vmpi/vmpi_job_search/resource.h new file mode 100644 index 0000000..0fceaed --- /dev/null +++ b/utils/vmpi/vmpi_job_search/resource.h @@ -0,0 +1,32 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +//{{NO_DEPENDENCIES}} +// Microsoft Developer Studio generated include file. +// Used by vmpi_browser_job_search.rc +// +#define IDD_VMPI_BROWSER_JOB_SEARCH_DIALOG 102 +#define IDR_MAINFRAME 128 +#define IDD_VMPI_JOB_SEARCH 136 +#define IDC_QUIT 1000 +#define IDC_SEARCH_BY_USER_PANEL 1001 +#define IDC_WORKER_PANEL 1002 +#define IDC_JOBS_PANEL 1003 +#define IDC_USER_LIST 1015 +#define IDC_WORKER_LIST 1016 +#define IDC_JOBS_LIST 1017 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 129 +#define _APS_NEXT_COMMAND_VALUE 32771 +#define _APS_NEXT_CONTROL_VALUE 1004 +#define _APS_NEXT_SYMED_VALUE 101 +#endif +#endif diff --git a/utils/vmpi/vmpi_job_search/vmpi_browser_job_search.cpp b/utils/vmpi/vmpi_job_search/vmpi_browser_job_search.cpp new file mode 100644 index 0000000..c6fd4a1 --- /dev/null +++ b/utils/vmpi/vmpi_job_search/vmpi_browser_job_search.cpp @@ -0,0 +1,75 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// vmpi_browser_job_search.cpp : Defines the class behaviors for the application. +// + +#include "stdafx.h" +#include "vmpi_browser_job_search.h" +#include "JobSearchDlg.h" + +#ifdef _DEBUG +#define new DEBUG_NEW +#undef THIS_FILE +static char THIS_FILE[] = __FILE__; +#endif + +///////////////////////////////////////////////////////////////////////////// +// CVMPIBrowserJobSearchApp + +BEGIN_MESSAGE_MAP(CVMPIBrowserJobSearchApp, CWinApp) + //{{AFX_MSG_MAP(CVMPIBrowserJobSearchApp) + // NOTE - the ClassWizard will add and remove mapping macros here. + // DO NOT EDIT what you see in these blocks of generated code! + //}}AFX_MSG + ON_COMMAND(ID_HELP, CWinApp::OnHelp) +END_MESSAGE_MAP() + +///////////////////////////////////////////////////////////////////////////// +// CVMPIBrowserJobSearchApp construction + +CVMPIBrowserJobSearchApp::CVMPIBrowserJobSearchApp() +{ + // TODO: add construction code here, + // Place all significant initialization in InitInstance +} + +///////////////////////////////////////////////////////////////////////////// +// The one and only CVMPIBrowserJobSearchApp object + +CVMPIBrowserJobSearchApp theApp; + +///////////////////////////////////////////////////////////////////////////// +// CVMPIBrowserJobSearchApp initialization + +BOOL CVMPIBrowserJobSearchApp::InitInstance() +{ + AfxEnableControlContainer(); + + // Standard initialization + // If you are not using these features and wish to reduce the size + // of your final executable, you should remove from the following + // the specific initialization routines you do not need. + + CJobSearchDlg dlg; + m_pMainWnd = &dlg; + int nResponse = dlg.DoModal(); + if (nResponse == IDOK) + { + // TODO: Place code here to handle when the dialog is + // dismissed with OK + } + else if (nResponse == IDCANCEL) + { + // TODO: Place code here to handle when the dialog is + // dismissed with Cancel + } + + // Since the dialog has been closed, return FALSE so that we exit the + // application, rather than start the application's message pump. + return FALSE; +} diff --git a/utils/vmpi/vmpi_job_search/vmpi_browser_job_search.h b/utils/vmpi/vmpi_job_search/vmpi_browser_job_search.h new file mode 100644 index 0000000..721b41c --- /dev/null +++ b/utils/vmpi/vmpi_job_search/vmpi_browser_job_search.h @@ -0,0 +1,56 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// vmpi_browser_job_search.h : main header file for the VMPI_BROWSER_JOB_SEARCH application +// + +#if !defined(AFX_VMPI_BROWSER_JOB_SEARCH_H__96197957_586A_4F10_ACEA_EBBB9E6FD619__INCLUDED_) +#define AFX_VMPI_BROWSER_JOB_SEARCH_H__96197957_586A_4F10_ACEA_EBBB9E6FD619__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#ifndef __AFXWIN_H__ + #error include 'stdafx.h' before including this file for PCH +#endif + +#include "resource.h" // main symbols + +///////////////////////////////////////////////////////////////////////////// +// CVMPIBrowserJobSearchApp: +// See vmpi_browser_job_search.cpp for the implementation of this class +// + +class CVMPIBrowserJobSearchApp : public CWinApp +{ +public: + CVMPIBrowserJobSearchApp(); + +// Overrides + // ClassWizard generated virtual function overrides + //{{AFX_VIRTUAL(CVMPIBrowserJobSearchApp) + public: + virtual BOOL InitInstance(); + //}}AFX_VIRTUAL + +// Implementation + + //{{AFX_MSG(CVMPIBrowserJobSearchApp) + // NOTE - the ClassWizard will add and remove member functions here. + // DO NOT EDIT what you see in these blocks of generated code ! + //}}AFX_MSG + DECLARE_MESSAGE_MAP() +}; + + +///////////////////////////////////////////////////////////////////////////// + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_VMPI_BROWSER_JOB_SEARCH_H__96197957_586A_4F10_ACEA_EBBB9E6FD619__INCLUDED_) diff --git a/utils/vmpi/vmpi_job_search/vmpi_browser_job_search.rc b/utils/vmpi/vmpi_job_search/vmpi_browser_job_search.rc new file mode 100644 index 0000000..4ed763a --- /dev/null +++ b/utils/vmpi/vmpi_job_search/vmpi_browser_job_search.rc @@ -0,0 +1,184 @@ +//Microsoft Developer Studio generated resource script. +// +#include "resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#include "afxres.h" + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +// English (U.S.) resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +#ifdef _WIN32 +LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US +#pragma code_page(1252) +#endif //_WIN32 + +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE DISCARDABLE +BEGIN + "resource.h\0" +END + +2 TEXTINCLUDE DISCARDABLE +BEGIN + "#include ""afxres.h""\r\n" + "\0" +END + +3 TEXTINCLUDE DISCARDABLE +BEGIN + "#define _AFX_NO_SPLITTER_RESOURCES\r\n" + "#define _AFX_NO_OLE_RESOURCES\r\n" + "#define _AFX_NO_TRACKER_RESOURCES\r\n" + "#define _AFX_NO_PROPERTY_RESOURCES\r\n" + "\r\n" + "#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)\r\n" + "#ifdef _WIN32\r\n" + "LANGUAGE 9, 1\r\n" + "#pragma code_page(1252)\r\n" + "#endif //_WIN32\r\n" + "#include ""res\\vmpi_browser_job_search.rc2"" // non-Microsoft Visual C++ edited resources\r\n" + "#include ""afxres.rc"" // Standard components\r\n" + "#endif\r\n" + "\0" +END + +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// Icon +// + +// Icon with lowest ID value placed first to ensure application icon +// remains consistent on all systems. +IDR_MAINFRAME ICON DISCARDABLE "res\\vmpi_browser_job_search.ico" + +#ifndef _MAC +///////////////////////////////////////////////////////////////////////////// +// +// Version +// + +VS_VERSION_INFO VERSIONINFO + FILEVERSION 1,0,0,1 + PRODUCTVERSION 1,0,0,1 + FILEFLAGSMASK 0x3fL +#ifdef _DEBUG + FILEFLAGS 0x1L +#else + FILEFLAGS 0x0L +#endif + FILEOS 0x4L + FILETYPE 0x1L + FILESUBTYPE 0x0L +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904B0" + BEGIN + VALUE "CompanyName", "\0" + VALUE "FileDescription", "vmpi_browser_job_search MFC Application\0" + VALUE "FileVersion", "1, 0, 0, 1\0" + VALUE "InternalName", "vmpi_browser_job_search\0" + VALUE "LegalCopyright", "Copyright (C) 2003\0" + VALUE "LegalTrademarks", "\0" + VALUE "OriginalFilename", "vmpi_browser_job_search.EXE\0" + VALUE "ProductName", "vmpi_browser_job_search Application\0" + VALUE "ProductVersion", "1, 0, 0, 1\0" + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 1200 + END +END + +#endif // !_MAC + + +///////////////////////////////////////////////////////////////////////////// +// +// DESIGNINFO +// + +#ifdef APSTUDIO_INVOKED +GUIDELINES DESIGNINFO DISCARDABLE +BEGIN + IDD_VMPI_JOB_SEARCH, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 400 + TOPMARGIN, 7 + BOTTOMMARGIN, 338 + END +END +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// Dialog +// + +IDD_VMPI_JOB_SEARCH DIALOGEX 0, 0, 407, 345 +STYLE DS_MODALFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_POPUP | + WS_VISIBLE | WS_CAPTION | WS_SYSMENU +EXSTYLE WS_EX_APPWINDOW +CAPTION "Job Search" +FONT 8, "MS Sans Serif" +BEGIN + GROUPBOX "Jobs",IDC_JOBS_PANEL,7,153,393,169 + LISTBOX IDC_USER_LIST,13,17,180,128,LBS_SORT | + LBS_NOINTEGRALHEIGHT | WS_VSCROLL | WS_TABSTOP + GROUPBOX "Search By User",IDC_SEARCH_BY_USER_PANEL,7,7,192,143 + LISTBOX IDC_WORKER_LIST,211,17,183,128,LBS_SORT | + LBS_NOINTEGRALHEIGHT | WS_VSCROLL | WS_TABSTOP + GROUPBOX "Search By Worker",IDC_WORKER_PANEL,205,7,195,143 + CONTROL "List3",IDC_JOBS_LIST,"SysListView32",LVS_REPORT | + LVS_SHOWSELALWAYS | WS_BORDER | WS_TABSTOP,14,164,380, + 153 + PUSHBUTTON "&Quit",IDC_QUIT,192,327,23,14 +END + +#endif // English (U.S.) resources +///////////////////////////////////////////////////////////////////////////// + + + +#ifndef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 3 resource. +// +#define _AFX_NO_SPLITTER_RESOURCES +#define _AFX_NO_OLE_RESOURCES +#define _AFX_NO_TRACKER_RESOURCES +#define _AFX_NO_PROPERTY_RESOURCES + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +#ifdef _WIN32 +LANGUAGE 9, 1 +#pragma code_page(1252) +#endif //_WIN32 +#include "res\vmpi_browser_job_search.rc2" // non-Microsoft Visual C++ edited resources +#include "afxres.rc" // Standard components +#endif + +///////////////////////////////////////////////////////////////////////////// +#endif // not APSTUDIO_INVOKED + diff --git a/utils/vmpi/vmpi_job_search/vmpi_job_search.vpc b/utils/vmpi/vmpi_job_search/vmpi_job_search.vpc new file mode 100644 index 0000000..01dba8b --- /dev/null +++ b/utils/vmpi/vmpi_job_search/vmpi_job_search.vpc @@ -0,0 +1,97 @@ +//----------------------------------------------------------------------------- +// vmpi_job_search.VPC +// +// Project Script +//----------------------------------------------------------------------------- + +$Macro SRCDIR "..\..\.." +$Macro OUTBINDIR "$SRCDIR\..\game\bin" +$Macro OUTBINNAME "vmpi_job_search" + +$Include "$SRCDIR\vpc_scripts\source_exe_base.vpc" + +$Configuration +{ + $Compiler + { + $AdditionalIncludeDirectories "$BASE,..\,..\mysql\include" + $PreprocessorDefinitions "$BASE;PROTECTED_THINGS_DISABLE;WINVER=0x501;NO_WARN_MBCS_MFC_DEPRECATION" + $Create/UsePrecompiledHeader "Use Precompiled Header (/Yu)" + $PrecompiledHeaderFile "Debug/vmpi_browser_job_search.pch" + $EnableC++Exceptions "Yes (/EHsc)" + } +} + +$Configuration "Debug" +{ + $Linker + { + // Deprecated MBCS MFC libraries for VS 2013 (nafxcw.lib and nafxcwd.lib) can be downloaded from http://go.microsoft.com/?linkid=9832071 + $AdditionalDependencies "$BASE nafxcwd.lib" + $IgnoreSpecificLibrary "nafxcw.lib libcmt.lib" + } +} + +$Configuration "Release" +{ + $Linker + { + // Deprecated MBCS MFC libraries for VS 2013 (nafxcw.lib and nafxcwd.lib) can be downloaded from http://go.microsoft.com/?linkid=9832071 + $AdditionalDependencies "$BASE nafxcw.lib libcmt.lib" + $IgnoreSpecificLibrary "nafxcwd.lib libcmtd.lib" + } +} + +$Project "vmpi_job_search" +{ + $Folder "Source Files" + { + -$File "$SRCDIR\public\tier0\memoverride.cpp" + + $File "..\net_view_thread.cpp" + $File "vmpi_browser_job_search.cpp" + $File "vmpi_browser_job_search.rc" + $File "..\window_anchor_mgr.cpp" + + $File "JobSearchDlg.cpp" \ + "..\vmpi_browser_helpers.cpp" + { + $Configuration + { + $Compiler + { + $Create/UsePrecompiledHeader "Not Using Precompiled Headers" + } + } + } + + $File "StdAfx.cpp" + { + $Configuration + { + $Compiler + { + $Create/UsePrecompiledHeader "Create Precompiled Header (/Yc)" + } + } + } + } + + $Folder "Header Files" + { + $File "JobSearchDlg.h" + $File "..\mysql_wrapper.h" + $File "..\net_view_thread.h" + $File "Resource.h" + $File "StdAfx.h" + $File "..\vmpi_browser_helpers.h" + $File "vmpi_browser_job_search.h" + $File "..\window_anchor_mgr.h" + } + + $Folder "Resource Files" + { + $File "res\vmpi_browser_job_search.ico" + $File "res\vmpi_browser_job_search.rc2" + } +} diff --git a/utils/vmpi/vmpi_job_watch/GraphControl.cpp b/utils/vmpi/vmpi_job_watch/GraphControl.cpp new file mode 100644 index 0000000..44d7e57 --- /dev/null +++ b/utils/vmpi/vmpi_job_watch/GraphControl.cpp @@ -0,0 +1,246 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// GraphControl.cpp : implementation file +// + +#include "stdafx.h" +#include "vmpi_browser_job_watch.h" +#include "GraphControl.h" +#include "mathlib/mathlib.h" + +#ifdef _DEBUG +#define new DEBUG_NEW +#undef THIS_FILE +static char THIS_FILE[] = __FILE__; +#endif + +///////////////////////////////////////////////////////////////////////////// +// CGraphControl + +CGraphControl::CGraphControl() +{ +} + +CGraphControl::~CGraphControl() +{ +} + + +BEGIN_MESSAGE_MAP(CGraphControl, CWnd) + //{{AFX_MSG_MAP(CGraphControl) + ON_WM_PAINT() + //}}AFX_MSG_MAP +END_MESSAGE_MAP() + + +void CGraphControl::Clear() +{ + CRect rcClient; + GetClientRect( rcClient ); + + CDC *pDC = GetDC(); + + CBrush brush( RGB( 0, 0, 0 ) ); + CBrush *pOldBrush = pDC->SelectObject( &brush ); + pDC->Rectangle( 0, 0, rcClient.Width(), rcClient.Height() ); + pDC->SelectObject( pOldBrush ); + + ReleaseDC( pDC ); +} + +void CGraphControl::Render( CDC *pDC ) +{ + // Clear the background. + CRect rcClient; + GetClientRect( rcClient ); + + + CBrush brush( RGB( 0, 0, 0 ) ); + CBrush *pOldBrush = pDC->SelectObject( &brush ); + pDC->Rectangle( 0, 0, rcClient.Width(), rcClient.Height() ); + pDC->SelectObject( pOldBrush ); + + + + // Work backwards from the right side to the left. + int nIntervals = rcClient.Width(); + DWORD intervalMS = 500; // one interval per pixel + DWORD startTime = 0xFFFFFFFF, endTime = 0; + + // First, find which order of magnitude to use on the vertical scale by finding the maximum value. + for ( int iEntry=0; iEntry < m_Entries.Count(); iEntry++ ) + { + DWORD msTime = m_Entries[iEntry].m_msTime; + startTime = min( startTime, msTime ); + endTime = max( endTime, msTime ); + } + + int curTime = (int)endTime - nIntervals*intervalMS; + + + + CGraphEntry prevEntry, curEntry; + prevEntry.m_msTime = curEntry.m_msTime = -1; + + CUtlVector<POINT> sentPoints; + CUtlVector<POINT> receivedPoints; + + int iCurEntry = -1; + int nMaxBytesSent = -1, nMaxBytesReceived = -1; + + for ( int x=0; x < nIntervals; x++ ) + { + if ( curTime >= 0 ) + { + // Now find the graph_entry for the time we're at. + while ( prevEntry.m_msTime == -1 || curTime > curEntry.m_msTime ) + { + ++iCurEntry; + if ( iCurEntry >= m_Entries.Count() ) + goto ENDLOOP; + + prevEntry = curEntry; + curEntry = m_Entries[iCurEntry]; + } + + if ( curTime >= prevEntry.m_msTime && curTime <= curEntry.m_msTime ) + { + // Interpolate the bytes sent. + int nBytesSent = (int)RemapVal( + curTime, + prevEntry.m_msTime, curEntry.m_msTime, + prevEntry.m_nBytesSent, curEntry.m_nBytesSent ); + + POINT sentPoint = { x, nBytesSent }; + sentPoints.AddToTail( sentPoint ); + nMaxBytesSent = max( nMaxBytesSent, nBytesSent ); + + + int nBytesReceived = (int)RemapVal( + curTime, + prevEntry.m_msTime, curEntry.m_msTime, + prevEntry.m_nBytesReceived, curEntry.m_nBytesReceived ); + + POINT receivedPoint = { x, nBytesReceived }; + receivedPoints.AddToTail( receivedPoint ); + nMaxBytesReceived = max( nMaxBytesReceived, nBytesReceived ); + } + } + + curTime += intervalMS; + } + + ENDLOOP:; + + + // Now normalize all the values. + int largest = max( nMaxBytesSent, nMaxBytesReceived ); + int topValue = (largest*11) / 10; +/* + DWORD nZeros; + for( nZeros = 1; nZeros < 20; nZeros++ ) + { + if ( largest < pow( 10, nZeros ) ) + break; + } + + // Now find the value at the top of the graph. We choose the smallest enclosing tenth of the + // order of magnitude we're at (so if we were at 1,000,000, and our max value was 350,000, we'd choose 400,000). + int iTenth; + int topValue; + for ( iTenth=1; iTenth <= 10; iTenth++ ) + { + topValue = (DWORD)( pow( 10, nZeros-1 ) * iTenth ); + if ( topValue >= largest ) + break; + } +*/ + + for ( int iSample=0; iSample < sentPoints.Count(); iSample++ ) + { + double flHeight; + + flHeight = ((double)sentPoints[iSample].y / topValue) * (rcClient.Height() - 1); + sentPoints[iSample].y = (int)( rcClient.Height() - flHeight ); + + flHeight = ((double)receivedPoints[iSample].y / topValue) * (rcClient.Height() - 1); + receivedPoints[iSample].y = (int)( rcClient.Height() - flHeight ); + } + + + // Draw some horizontal lines dividing the space. + int nLines = 10; + for ( int iLine=0; iLine <= nLines; iLine++ ) + { + CPen penLine; + COLORREF color; + if ( iLine == 0 || iLine == nLines/2 ) + color = RGB( 0, 220, 0 ); + else + color = RGB( 0, 100, 0 ); + + penLine.CreatePen( PS_SOLID, 1, color ); + CPen *pOldPen = pDC->SelectObject( &penLine ); + + int y = (iLine * rcClient.Height()) / nLines; + pDC->MoveTo( 0, y ); + pDC->LineTo( rcClient.Width(), y ); + + pDC->SelectObject( pOldPen ); + } + + + // Now draw the lines for the data. + CPen penSent( PS_SOLID, 1, RGB( 0, 255, 0 ) ); + CPen *pOldPen = pDC->SelectObject( &penSent ); + pDC->Polyline( sentPoints.Base(), sentPoints.Count() ); + pDC->SelectObject( pOldPen ); + + CPen penReceived( PS_SOLID, 1, RGB( 255, 255, 0 ) ); + pOldPen = pDC->SelectObject( &penReceived ); + pDC->Polyline( receivedPoints.Base(), receivedPoints.Count() ); + pDC->SelectObject( pOldPen ); + + + + // Draw text labels. + pDC->SetTextColor( RGB( 200, 200, 200 ) ); + pDC->SetBkColor( 0 ); + + CString str; + str.Format( "%dk", (topValue+511) / 1024 ); + pDC->ExtTextOut( 0, 1, 0, NULL, str, NULL ); + + str.Format( "%dk", (topValue+511) / 1024 / 2 ); + pDC->ExtTextOut( 0, rcClient.Height()/2 + 1, 0, NULL, str, NULL ); +} + + +void CGraphControl::Fill( CUtlVector<CGraphEntry> &entries ) +{ + CDC *pDC = GetDC(); + if ( !pDC ) + return; + + m_Entries = entries; + + Render( pDC ); + + ReleaseDC( pDC ); +} + + +///////////////////////////////////////////////////////////////////////////// +// CGraphControl message handlers + +void CGraphControl::OnPaint() +{ + CPaintDC dc(this); // device context for painting + + Render( &dc ); +} diff --git a/utils/vmpi/vmpi_job_watch/GraphControl.h b/utils/vmpi/vmpi_job_watch/GraphControl.h new file mode 100644 index 0000000..b8fcb88 --- /dev/null +++ b/utils/vmpi/vmpi_job_watch/GraphControl.h @@ -0,0 +1,86 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +#if !defined(AFX_GRAPHCONTROL_H__9B50B827_F24D_4C5A_BA6E_A591A64E404D__INCLUDED_) +#define AFX_GRAPHCONTROL_H__9B50B827_F24D_4C5A_BA6E_A591A64E404D__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 +// GraphControl.h : header file +// + +#include "utlvector.h" + + +class CGraphEntry +{ +public: + CGraphEntry() : + m_msTime( 0 ), + m_nBytesSent( 0 ), + m_nBytesReceived( 0 ) + { + } + + int m_msTime; + int m_nBytesSent; + int m_nBytesReceived; +}; + + +///////////////////////////////////////////////////////////////////////////// +// CGraphControl window + +class CGraphControl : public CWnd +{ +// Construction +public: + CGraphControl(); + +// Attributes +public: + +// Operations +public: + + void Clear(); + + // This function assumes you've already run the query and the graph_entry's are selected in. + void Fill( CUtlVector<CGraphEntry> &entries ); + + +// Overrides + // ClassWizard generated virtual function overrides + //{{AFX_VIRTUAL(CGraphControl) + //}}AFX_VIRTUAL + +// Implementation +public: + virtual ~CGraphControl(); + + +protected: + + void Render( CDC *pDC ); + + CUtlVector<CGraphEntry> m_Entries; + + // Generated message map functions +protected: + //{{AFX_MSG(CGraphControl) + afx_msg void OnPaint(); + //}}AFX_MSG + DECLARE_MESSAGE_MAP() +}; + +///////////////////////////////////////////////////////////////////////////// + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_GRAPHCONTROL_H__9B50B827_F24D_4C5A_BA6E_A591A64E404D__INCLUDED_) diff --git a/utils/vmpi/vmpi_job_watch/JobWatchDlg.cpp b/utils/vmpi/vmpi_job_watch/JobWatchDlg.cpp new file mode 100644 index 0000000..4c7909b --- /dev/null +++ b/utils/vmpi/vmpi_job_watch/JobWatchDlg.cpp @@ -0,0 +1,648 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// JobWatchDlg.cpp : implementation file +// + +#include "stdafx.h" +#include "JobWatchDlg.h" +#include "tier1/strtools.h" +#include "consolewnd.h" +#include "vmpi_browser_helpers.h" + + +#ifdef _DEBUG +#define new DEBUG_NEW +#undef THIS_FILE +static char THIS_FILE[] = __FILE__; +#endif + + +#define IMPLEMENT_SORT_NUMBER_FN( FnName, VarName ) \ + static int CALLBACK FnName( LPARAM iItem1, LPARAM iItem2, LPARAM lpParam ) \ + { \ + CWorkerInfo *pInfo1 = (CWorkerInfo*)iItem1; \ + CWorkerInfo *pInfo2 = (CWorkerInfo*)iItem2; \ + return pInfo1->VarName > pInfo2->VarName; \ + } + +static int CALLBACK SortByName( LPARAM iItem1, LPARAM iItem2, LPARAM lpParam ) +{ + CWorkerInfo *pInfo1 = (CWorkerInfo*)iItem1; + CWorkerInfo *pInfo2 = (CWorkerInfo*)iItem2; + + return strcmp( pInfo1->m_ComputerName, pInfo2->m_ComputerName ); +} + +static int CALLBACK SortByCurrentStage( LPARAM iItem1, LPARAM iItem2, LPARAM lpParam ) +{ + CWorkerInfo *pInfo1 = (CWorkerInfo*)iItem1; + CWorkerInfo *pInfo2 = (CWorkerInfo*)iItem2; + + return strcmp( pInfo1->m_CurrentStage, pInfo2->m_CurrentStage ); +} + +IMPLEMENT_SORT_NUMBER_FN( SortByConnected, m_bConnected ) +IMPLEMENT_SORT_NUMBER_FN( SortByWorkUnitsDone, m_nWorkUnitsDone ); +IMPLEMENT_SORT_NUMBER_FN( SortByRunningTime, m_RunningTimeMS ); +IMPLEMENT_SORT_NUMBER_FN( SortByThread0WU, m_ThreadWUs[0] ); +IMPLEMENT_SORT_NUMBER_FN( SortByThread1WU, m_ThreadWUs[1] ); +IMPLEMENT_SORT_NUMBER_FN( SortByThread2WU, m_ThreadWUs[2] ); +IMPLEMENT_SORT_NUMBER_FN( SortByThread3WU, m_ThreadWUs[3] ); + +typedef int (CALLBACK *ServicesSortFn)( LPARAM iItem1, LPARAM iItem2, LPARAM lpParam ); + +struct +{ + char *pText; + int width; + ServicesSortFn sortFn; +} g_ColumnInfos[] = +{ + {"Computer Name", 150, SortByName}, + {"Connected", 70, SortByConnected}, + {"Work Units Done", 100, SortByWorkUnitsDone}, + {"Running Time", 80, SortByRunningTime}, + {"Current Stage", 180, SortByCurrentStage}, + {"Thread 0", 70, SortByThread0WU}, + {"Thread 1", 70, SortByThread1WU}, + {"Thread 2", 70, SortByThread2WU}, + {"Thread 3", 70, SortByThread3WU} +}; + +#define COLUMN_COMPUTER_NAME 0 +#define COLUMN_CONNECTED 1 +#define COLUMN_WORK_UNITS_DONE 2 +#define COLUMN_RUNNING_TIME 3 +#define COLUMN_CURRENT_STAGE 4 +#define COLUMN_THREAD0_WU 5 +#define COLUMN_THREAD1_WU 6 +#define COLUMN_THREAD2_WU 7 +#define COLUMN_THREAD3_WU 8 + +int g_iSortColumn = 0; + + +///////////////////////////////////////////////////////////////////////////// +// CJobWatchDlg dialog + + +CJobWatchDlg::CJobWatchDlg(CWnd* pParent /*=NULL*/) + : CIdleDialog(CJobWatchDlg::IDD, pParent) +{ + m_CurMessageIndex = 0; + m_CurGraphTime = 0; + m_pSQL = NULL; + m_hMySQLDLL = NULL; + m_CurWorkerTextToken = 0; + m_LastQueryTime = 0; + + //{{AFX_DATA_INIT(CJobWatchDlg) + // NOTE: the ClassWizard will add member initialization here + //}}AFX_DATA_INIT +} + + +CJobWatchDlg::~CJobWatchDlg() +{ + if ( m_pSQL ) + { + m_pSQL->Release(); + } + + if ( m_hMySQLDLL ) + { + Sys_UnloadModule( m_hMySQLDLL ); + } +} + + +void CJobWatchDlg::DoDataExchange(CDataExchange* pDX) +{ + CDialog::DoDataExchange(pDX); + //{{AFX_DATA_MAP(CJobWatchDlg) + DDX_Control(pDX, IDC_WORKERS, m_Workers); + DDX_Control(pDX, IDC_TEXTOUTPUT, m_TextOutput); + //}}AFX_DATA_MAP +} + + +BEGIN_MESSAGE_MAP(CJobWatchDlg, CIdleDialog) + //{{AFX_MSG_MAP(CJobWatchDlg) + ON_LBN_SELCHANGE(IDC_WORKERS, OnSelChangeWorkers) + ON_WM_SIZE() + ON_NOTIFY(LVN_ODSTATECHANGED, IDC_WORKERS, OnOdstatechangedWorkers) + ON_NOTIFY(LVN_ITEMCHANGED, IDC_WORKERS, OnItemchangedWorkers) + //}}AFX_MSG_MAP +END_MESSAGE_MAP() + +///////////////////////////////////////////////////////////////////////////// +// CJobWatchDlg message handlers + +const char* FindArg( const char *pArgName, const char *pDefault="" ) +{ + for ( int i=1; i < __argc; i++ ) + { + if ( Q_stricmp( pArgName, __argv[i] ) == 0 ) + { + if ( (i+1) < __argc ) + return __argv[i+1]; + else + return pDefault; + } + } + return NULL; +} + + +bool ReadStringFromFile( FILE *fp, char *pStr, int strSize ) +{ + int i=0; + for ( i; i < strSize-2; i++ ) + { + if ( fread( &pStr[i], 1, 1, fp ) != 1 || + pStr[i] == '\n' ) + { + break; + } + } + + pStr[i] = 0; + return i != 0; +} + + +BOOL CJobWatchDlg::OnInitDialog() +{ + CDialog::OnInitDialog(); + + + m_Workers.SetExtendedStyle( LVS_EX_FULLROWSELECT ); + + // Setup the headers. + for ( int i=0; i < ARRAYSIZE( g_ColumnInfos ); i++ ) + { + m_Workers.InsertColumn( i, g_ColumnInfos[i].pText, LVCFMT_LEFT, g_ColumnInfos[i].width, i ); + } + + + m_GraphControl.SubclassDlgItem( IDC_GRAPH_AREA, this ); + + + CString str; + + // Get all our startup info from the command line. + const char *pJobID = FindArg( "-JobID", NULL ); + const char *pDBName = FindArg( "-dbname", NULL ); + const char *pHostName = FindArg( "-hostname", NULL ); + const char *pUserName = FindArg( "-username", NULL ); + + if ( !pJobID ) + { + str.Format( "Missing a command line parameter (-JobID or -dbname or -hostname or -username)" ); + MessageBox( str, "Error", MB_OK ); + EndDialog( 1 ); + return FALSE; + } + + char hostName[512], dbName[512], userName[512]; + if ( !pDBName || !pHostName || !pUserName ) + { + char errString[512]; + + // If they don't specify the DB info, get it from where + const char *pFilename = "dbinfo_job_search.txt"; + FILE *fp = fopen( pFilename, "rt" ); + if ( !fp ) + { + Q_snprintf( errString, sizeof( errString ), "Can't open '%s' for database info.", pFilename ); + MessageBox( errString, "Error", MB_OK ); + EndDialog( 0 ); + return FALSE; + } + + if ( !ReadStringFromFile( fp, hostName, sizeof( hostName ) ) || + !ReadStringFromFile( fp, dbName, sizeof( dbName ) ) || + !ReadStringFromFile( fp, userName, sizeof( userName ) ) + ) + { + fclose( fp ); + Q_snprintf( errString, sizeof( errString ), "'%s' has invalid format.", pFilename ); + MessageBox( errString, "Error", MB_OK ); + EndDialog( 0 ); + return FALSE; + } + + pDBName = dbName; + pHostName = hostName; + pUserName = userName; + + fclose( fp ); + } + + m_JobID = atoi( pJobID ); + + // Get the mysql interface. + IMySQL *pSQL; + if ( !Sys_LoadInterface( "mysql_wrapper", MYSQL_WRAPPER_VERSION_NAME, &m_hMySQLDLL, (void**)&pSQL ) ) + return false; + + if ( !pSQL->InitMySQL( pDBName, pHostName, pUserName ) ) + { + pSQL->Release(); + str.Format( "Can't init MYSQL db (db = '%s', host = '%s', user = '%s')", pDBName, pHostName, pUserName ); + MessageBox( str, "Error", MB_OK ); + EndDialog( 0 ); + return FALSE; + } + + m_pSQL = CreateMySQLAsync( pSQL ); + if ( !m_pSQL ) + { + pSQL->Release(); + str.Format( "Can't create IMySQLAsync" ); + MessageBox( str, "Error", MB_OK ); + EndDialog( 0 ); + return FALSE; + } + + + memset( m_bQueriesInProgress, 0, sizeof( m_bQueriesInProgress ) ); + + + // (Init the idle processor so we can update text and graphs). + StartIdleProcessing( 100 ); + + // Fill in the command line control. + char cmdLine[2048]; + Q_snprintf( cmdLine, sizeof( cmdLine ), "vmpi_job_watch -JobID %s -hostname %s -dbname %s -username %s", + pJobID, pHostName, pDBName, pUserName ); + SetDlgItemText( IDC_COMMAND_LINE, cmdLine ); + + // Setup anchors. + m_AnchorMgr.AddAnchor( this, GetDlgItem( IDC_WORKERS_PANEL ), ANCHOR_LEFT, ANCHOR_TOP, ANCHOR_WIDTH_PERCENT, ANCHOR_HEIGHT_PERCENT ); + m_AnchorMgr.AddAnchor( this, GetDlgItem( IDC_WORKERS ), ANCHOR_LEFT, ANCHOR_TOP, ANCHOR_WIDTH_PERCENT, ANCHOR_HEIGHT_PERCENT ); + + m_AnchorMgr.AddAnchor( this, GetDlgItem( IDC_TEXT_OUTPUT_PANEL ), ANCHOR_LEFT, ANCHOR_HEIGHT_PERCENT, ANCHOR_WIDTH_PERCENT, ANCHOR_BOTTOM ); + m_AnchorMgr.AddAnchor( this, GetDlgItem( IDC_TEXTOUTPUT ), ANCHOR_LEFT, ANCHOR_HEIGHT_PERCENT, ANCHOR_WIDTH_PERCENT, ANCHOR_BOTTOM ); + + m_AnchorMgr.AddAnchor( this, GetDlgItem( IDC_GRAPHS_PANEL ), ANCHOR_WIDTH_PERCENT, ANCHOR_TOP, ANCHOR_RIGHT, ANCHOR_HEIGHT_PERCENT ); + m_AnchorMgr.AddAnchor( this, &m_GraphControl, ANCHOR_WIDTH_PERCENT, ANCHOR_TOP, ANCHOR_RIGHT, ANCHOR_HEIGHT_PERCENT ); + + return TRUE; // return TRUE unless you set the focus to a control + // EXCEPTION: OCX Property Pages should return FALSE +} + + +CWorkerInfo* CJobWatchDlg::FindWorkerByID( unsigned long jobWorkerID ) +{ + int nIndex = -1; + while ( ( nIndex = m_Workers.GetNextItem( nIndex, LVNI_ALL ) ) != -1 ) + { + CWorkerInfo *pInfo = (CWorkerInfo*)m_Workers.GetItemData( nIndex ); + if ( pInfo->m_JobWorkerID == jobWorkerID ) + return pInfo; + } + + return NULL; +} + + +CWorkerInfo* CJobWatchDlg::FindWorkerByMachineName( const char *pMachineName ) +{ + int nIndex = -1; + while ( ( nIndex = m_Workers.GetNextItem( nIndex, LVNI_ALL ) ) != -1 ) + { + CWorkerInfo *pInfo = (CWorkerInfo*)m_Workers.GetItemData( nIndex ); + if ( Q_stricmp( pInfo->m_ComputerName, pMachineName ) == 0 ) + return pInfo; + } + + return NULL; +} + + +void CJobWatchDlg::SetWorkerListItemInt( int nIndex, int iColumn, int value ) +{ + char str[512]; + Q_snprintf( str, sizeof( str ), "%d", value ); + m_Workers.SetItemText( nIndex, iColumn, str ); +} + + +void CJobWatchDlg::UpdateWorkersList() +{ + int nIndex = -1; + while ( ( nIndex = m_Workers.GetNextItem( nIndex, LVNI_ALL ) ) != -1 ) + { + CWorkerInfo *pInfo = (CWorkerInfo*)m_Workers.GetItemData( nIndex ); + + char *pConnectedStr = pInfo->m_bConnected ? "yes" : "no"; + m_Workers.SetItemText( nIndex, COLUMN_CONNECTED, pConnectedStr ); + + SetWorkerListItemInt( nIndex, COLUMN_WORK_UNITS_DONE, pInfo->m_nWorkUnitsDone ); + + char timeStr[1024]; + FormatTimeString( pInfo->m_RunningTimeMS / 1000, timeStr, sizeof( timeStr ) ); + m_Workers.SetItemText( nIndex, COLUMN_RUNNING_TIME, timeStr ); + + // Current stage. + SetWorkerListItemInt( nIndex, COLUMN_WORK_UNITS_DONE, pInfo->m_nWorkUnitsDone ); + + m_Workers.SetItemText( nIndex, COLUMN_CURRENT_STAGE, pInfo->m_CurrentStage ); + + SetWorkerListItemInt( nIndex, COLUMN_THREAD0_WU, pInfo->m_ThreadWUs[0] ); + SetWorkerListItemInt( nIndex, COLUMN_THREAD1_WU, pInfo->m_ThreadWUs[1] ); + SetWorkerListItemInt( nIndex, COLUMN_THREAD2_WU, pInfo->m_ThreadWUs[2] ); + SetWorkerListItemInt( nIndex, COLUMN_THREAD3_WU, pInfo->m_ThreadWUs[3] ); + } + + ResortItems(); +} + + +bool CJobWatchDlg::GetCurJobWorkerID( unsigned long &id ) +{ + POSITION pos = m_Workers.GetFirstSelectedItemPosition(); + if ( !pos ) + return false; + + int index = m_Workers.GetNextSelectedItem( pos ); + CWorkerInfo *pInfo = (CWorkerInfo*)m_Workers.GetItemData( index ); + id = pInfo->m_JobWorkerID; + return true; +} + + +void CJobWatchDlg::OnSelChangeWorkers() +{ + // Clear the text output and invalidate any old queries for text. + int nLen = m_TextOutput.SendMessage( EM_GETLIMITTEXT, 0, 0 ); + m_TextOutput.SendMessage( EM_SETSEL, 0, nLen ); + m_TextOutput.SendMessage( EM_REPLACESEL, FALSE, (LPARAM)"" ); + + m_CurMessageIndex = 0; + m_CurWorkerTextToken++; + m_LastQueryTime = 0; // force a query. + + m_GraphControl.Clear(); + m_CurGraphTime = -1; +} + + +void CJobWatchDlg::ResortItems() +{ + m_Workers.SortItems( g_ColumnInfos[g_iSortColumn].sortFn, (LPARAM)this ); +} + + + +void CJobWatchDlg::OnIdle() +{ + // Issue any queries that we need to. + DWORD curTime = GetTickCount(); + if ( curTime - m_LastQueryTime >= 1000 ) + { + m_LastQueryTime = curTime; + char query[2048]; + + unsigned long jobWorkerID; + bool bJobWorkerIDValid = GetCurJobWorkerID( jobWorkerID ); + + if ( !m_bQueriesInProgress[QUERY_TEXT] && bJobWorkerIDValid ) + { + Q_snprintf( query, sizeof( query ), "select * from text_messages where JobWorkerID=%lu and MessageIndex >= %lu", jobWorkerID, m_CurMessageIndex ); + m_pSQL->Execute( query, (void*)(QUERY_TEXT | (m_CurWorkerTextToken << 16)) ); + m_bQueriesInProgress[QUERY_TEXT] = true; + } + + if ( !m_bQueriesInProgress[QUERY_GRAPH] && bJobWorkerIDValid ) + { + Q_snprintf( query, sizeof( query ), "select * from graph_entry where JobWorkerID=%lu", jobWorkerID ); + m_pSQL->Execute( query, (void*)QUERY_GRAPH ); + m_bQueriesInProgress[QUERY_GRAPH] = true; + } + + if ( !m_bQueriesInProgress[QUERY_WORKER_STATS] ) + { + Q_snprintf( query, sizeof( query ), "select JobWorkerID, WorkerState, NumWorkUnits, " + "RunningTimeMS, CurrentStage, Thread0WU, Thread1WU, Thread2WU, Thread3WU, IsMaster, MachineName " + " from job_worker_start where JobID=%lu", m_JobID ); + + m_pSQL->Execute( query, (void*)QUERY_WORKER_STATS ); + m_bQueriesInProgress[QUERY_WORKER_STATS] = true; + } + } + + + // Pickup query results. + CQueryResults results; + while ( m_pSQL->GetNextResults( results ) && results.m_pResults ) + { + int iQueryID = ((int)results.m_pUserData) & 0xFFFF; + int iExtraData = ((int)results.m_pUserData) >> 16; + + if ( results.m_pResults ) + { + if ( iQueryID == QUERY_TEXT ) + { + if ( iExtraData == m_CurWorkerTextToken ) + { + ProcessQueryResults_Text( results.m_pResults ); + } + } + else if ( iQueryID == QUERY_GRAPH ) + { + ProcessQueryResults_Graph( results.m_pResults ); + } + else if ( iQueryID == QUERY_WORKER_STATS ) + { + ProcessQueryResults_WorkerStats( results.m_pResults ); + } + + results.m_pResults->Release(); + } + + m_bQueriesInProgress[iQueryID] = false; + } +} + + +void CJobWatchDlg::ProcessQueryResults_WorkerStats( IMySQLRowSet *pSet ) +{ + bool bChange = false; + while ( pSet->NextRow() ) + { + int iColumn = 0; + int workerID = pSet->GetColumnValue_Int( iColumn++ ); + int workerState = pSet->GetColumnValue_Int( iColumn++ ); + int nWorkUnits = pSet->GetColumnValue_Int( iColumn++ ); + unsigned long runningTimeMS = pSet->GetColumnValue_Int( iColumn++ ); + const char *pCurrentStage = pSet->GetColumnValue_String( iColumn++ ); + int iThread0WU = pSet->GetColumnValue_Int( iColumn++ ); + int iThread1WU = pSet->GetColumnValue_Int( iColumn++ ); + int iThread2WU = pSet->GetColumnValue_Int( iColumn++ ); + int iThread3WU = pSet->GetColumnValue_Int( iColumn++ ); + int bIsMaster = pSet->GetColumnValue_Int( iColumn++ ); + const char *pMachineName = pSet->GetColumnValue_String( iColumn ); + + CWorkerInfo *pInfo = FindWorkerByID( workerID ); + if ( pInfo ) + { + if ( workerState != pInfo->m_bConnected || + nWorkUnits != pInfo->m_nWorkUnitsDone || + runningTimeMS != pInfo->m_RunningTimeMS || + stricmp( pCurrentStage, pInfo->m_CurrentStage ) != 0 || + iThread0WU != pInfo->m_ThreadWUs[0] || + iThread1WU != pInfo->m_ThreadWUs[1] || + iThread2WU != pInfo->m_ThreadWUs[2] || + iThread3WU != pInfo->m_ThreadWUs[3] + ) + { + bChange = true; + pInfo->m_bConnected = workerState; + pInfo->m_nWorkUnitsDone = nWorkUnits; + pInfo->m_RunningTimeMS = runningTimeMS; + pInfo->m_CurrentStage = pCurrentStage; + pInfo->m_ThreadWUs[0] = iThread0WU; + pInfo->m_ThreadWUs[1] = iThread1WU; + pInfo->m_ThreadWUs[2] = iThread2WU; + pInfo->m_ThreadWUs[3] = iThread3WU; + } + } + else + { + // Add a new entry. + CWorkerInfo *pInfo = new CWorkerInfo; + pInfo->m_ComputerName = pMachineName; + pInfo->m_bConnected = false; + pInfo->m_nWorkUnitsDone = 0; + pInfo->m_RunningTimeMS = 0; + pInfo->m_JobWorkerID = workerID; + + int index; + if ( bIsMaster ) + { + char tempStr[512]; + Q_snprintf( tempStr, sizeof( tempStr ), "%s [master]", (const char*)pInfo->m_ComputerName ); + index = m_Workers.InsertItem( COLUMN_COMPUTER_NAME, tempStr, NULL ); + } + else + { + index = m_Workers.InsertItem( COLUMN_COMPUTER_NAME, pInfo->m_ComputerName, NULL ); + } + + m_Workers.SetItemData( index, (DWORD)pInfo ); + bChange = true; + } + } + + if ( bChange ) + { + UpdateWorkersList(); + } +} + + +void CJobWatchDlg::ProcessQueryResults_Text( IMySQLRowSet *pSet ) +{ + CUtlVector<char> text; + + while ( pSet->NextRow() ) + { + const char *pTextStr = pSet->GetColumnValue( "text" ).String(); + int len = strlen( pTextStr ); + text.AddMultipleToTail( len, pTextStr ); + + m_CurMessageIndex = pSet->GetColumnValue( "MessageIndex" ).Int32() + 1; + } + + text.AddToTail( 0 ); + FormatAndSendToEditControl( m_TextOutput.GetSafeHwnd(), text.Base() ); +} + + +void CJobWatchDlg::ProcessQueryResults_Graph( IMySQLRowSet *pSet ) +{ + int iMSTime = pSet->GetColumnIndex( "MSSinceJobStart" ); + int iBytesSent = pSet->GetColumnIndex( "BytesSent" ); + int iBytesReceived = pSet->GetColumnIndex( "BytesReceived" ); + + // See if there's anything new. + CUtlVector<CGraphEntry> entries; + + int highest = m_CurGraphTime; + while ( pSet->NextRow() ) + { + CGraphEntry entry; + entry.m_msTime = pSet->GetColumnValue( iMSTime ).Int32(); + entry.m_nBytesSent = pSet->GetColumnValue( iBytesSent ).Int32(); + entry.m_nBytesReceived = pSet->GetColumnValue( iBytesReceived ).Int32(); + entries.AddToTail( entry ); + + highest = max( highest, entry.m_msTime ); + } + + if ( highest > m_CurGraphTime ) + { + m_CurGraphTime = highest; + + m_GraphControl.Clear(); + m_GraphControl.Fill( entries ); + } +} + + +void CJobWatchDlg::OnSize(UINT nType, int cx, int cy) +{ + CIdleDialog::OnSize(nType, cx, cy); + + m_AnchorMgr.UpdateAnchors( this ); +} + + +BOOL CJobWatchDlg::OnNotify(WPARAM wParam, LPARAM lParam, LRESULT* pResult) +{ + NMHDR *pHdr = (NMHDR*)lParam; + if ( pHdr->idFrom == IDC_WORKERS ) + { + if ( pHdr->code == LVN_COLUMNCLICK ) + { + LPNMLISTVIEW pListView = (LPNMLISTVIEW)lParam; + + // Now sort by this column. + g_iSortColumn = max( 0, min( pListView->iSubItem, (int)ARRAYSIZE( g_ColumnInfos ) - 1 ) ); + ResortItems(); + } + } + + return CIdleDialog::OnNotify(wParam, lParam, pResult); +} + +void CJobWatchDlg::OnOdstatechangedWorkers(NMHDR* pNMHDR, LRESULT* pResult) +{ + NMLVODSTATECHANGE* pStateChanged = (NMLVODSTATECHANGE*)pNMHDR; + + if ( !( pStateChanged->uOldState & LVIS_SELECTED ) && ( pStateChanged->uNewState & LVIS_SELECTED ) ) + { + OnSelChangeWorkers(); + } + + *pResult = 0; +} + +void CJobWatchDlg::OnItemchangedWorkers(NMHDR* pNMHDR, LRESULT* pResult) +{ + NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR; + + if ( !( pNMListView->uOldState & LVIS_SELECTED ) && ( pNMListView->uNewState & LVIS_SELECTED ) ) + { + OnSelChangeWorkers(); + } + + *pResult = 0; +} diff --git a/utils/vmpi/vmpi_job_watch/JobWatchDlg.h b/utils/vmpi/vmpi_job_watch/JobWatchDlg.h new file mode 100644 index 0000000..6bec50b --- /dev/null +++ b/utils/vmpi/vmpi_job_watch/JobWatchDlg.h @@ -0,0 +1,134 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +#if !defined(AFX_JOBWATCHDLG_H__761BDEEF_D549_4F10_817C_1C1FAF9FCA47__INCLUDED_) +#define AFX_JOBWATCHDLG_H__761BDEEF_D549_4F10_817C_1C1FAF9FCA47__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 +// JobWatchDlg.h : header file +// + + +#include "idle_dialog.h" +#include "resource.h" +#include "utlvector.h" +#include "imysqlwrapper.h" +#include "GraphControl.h" +#include "window_anchor_mgr.h" +#include "mysql_async.h" + + +class CWorkerInfo +{ +public: + CWorkerInfo() + { + m_bConnected = false; + m_nWorkUnitsDone = 0; + m_JobWorkerID = 0xFFFFFFFF; + m_RunningTimeMS = 0; + m_ThreadWUs[0] = m_ThreadWUs[1] = m_ThreadWUs[2] = m_ThreadWUs[3] = -1; + } + + CString m_ComputerName; + int m_bConnected; + int m_nWorkUnitsDone; + unsigned long m_JobWorkerID; + unsigned long m_RunningTimeMS; + CString m_CurrentStage; + int m_ThreadWUs[4]; +}; + + + +///////////////////////////////////////////////////////////////////////////// +// CJobWatchDlg dialog + +class CJobWatchDlg : public CIdleDialog +{ +// Construction +public: + CJobWatchDlg( CWnd* pParent = NULL); // standard constructor + virtual ~CJobWatchDlg(); + +// Dialog Data + //{{AFX_DATA(CJobWatchDlg) + enum { IDD = IDD_JOB_WATCH }; + CListCtrl m_Workers; + CEdit m_TextOutput; + //}}AFX_DATA + + +// Overrides + // ClassWizard generated virtual function overrides + //{{AFX_VIRTUAL(CJobWatchDlg) + protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support + virtual BOOL OnNotify(WPARAM wParam, LPARAM lParam, LRESULT* pResult); + //}}AFX_VIRTUAL + +// Implementation +protected: + + virtual void OnIdle(); + void RefreshWorkerStats(); + CWorkerInfo* FindWorkerByID( unsigned long jobWorkerID ); + CWorkerInfo* FindWorkerByMachineName( const char *pMachineName ); + void SetWorkerListItemInt( int nIndex, int iColumn, int value ); + void UpdateWorkersList(); + void ResortItems(); + + // Query IDs. + enum + { + QUERY_TEXT=0, + QUERY_GRAPH, + QUERY_WORKER_STATS, + NUM_QUERIES + }; + + void ProcessQueryResults_Graph( IMySQLRowSet *pSet ); + void ProcessQueryResults_Text( IMySQLRowSet *pSet ); + void ProcessQueryResults_WorkerStats( IMySQLRowSet *pSet ); + + bool m_bQueriesInProgress[NUM_QUERIES]; + + // This is our connection to the mysql database. + IMySQLAsync *m_pSQL; + CSysModule *m_hMySQLDLL; + + CWindowAnchorMgr m_AnchorMgr; + + + bool GetCurJobWorkerID( unsigned long &id ); + + CGraphControl m_GraphControl; + unsigned long m_JobID; + int m_CurGraphTime; + + int m_CurMessageIndex; + int m_CurWorkerTextToken; // used to let it ignore old text in the thread's queue + + DWORD m_LastQueryTime; // Last time we made a query. + + // Generated message map functions + //{{AFX_MSG(CJobWatchDlg) + virtual BOOL OnInitDialog(); + afx_msg void OnSelChangeWorkers(); + afx_msg void OnSize(UINT nType, int cx, int cy); + afx_msg void OnOdstatechangedWorkers(NMHDR* pNMHDR, LRESULT* pResult); + afx_msg void OnItemchangedWorkers(NMHDR* pNMHDR, LRESULT* pResult); + //}}AFX_MSG + DECLARE_MESSAGE_MAP() +}; + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_JOBWATCHDLG_H__761BDEEF_D549_4F10_817C_1C1FAF9FCA47__INCLUDED_) diff --git a/utils/vmpi/vmpi_job_watch/StdAfx.cpp b/utils/vmpi/vmpi_job_watch/StdAfx.cpp new file mode 100644 index 0000000..86ac49b --- /dev/null +++ b/utils/vmpi/vmpi_job_watch/StdAfx.cpp @@ -0,0 +1,15 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// stdafx.cpp : source file that includes just the standard includes +// vmpi_browser_job_watch.pch will be the pre-compiled header +// stdafx.obj will contain the pre-compiled type information + +#include "stdafx.h" + + + diff --git a/utils/vmpi/vmpi_job_watch/StdAfx.h b/utils/vmpi/vmpi_job_watch/StdAfx.h new file mode 100644 index 0000000..3c1d23e --- /dev/null +++ b/utils/vmpi/vmpi_job_watch/StdAfx.h @@ -0,0 +1,36 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, but +// are changed infrequently +// + +#if !defined(AFX_STDAFX_H__E8FBDA6A_CE57_4416_8329_90155CD6CEC3__INCLUDED_) +#define AFX_STDAFX_H__E8FBDA6A_CE57_4416_8329_90155CD6CEC3__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers + +#include "tier0/basetypes.h" + +#include <afxwin.h> // MFC core and standard components +#include <afxext.h> // MFC extensions +#include <afxdisp.h> // MFC Automation classes +#include <afxdtctl.h> // MFC support for Internet Explorer 4 Common Controls +#ifndef _AFX_NO_AFXCMN_SUPPORT +#include <afxcmn.h> // MFC support for Windows Common Controls +#endif // _AFX_NO_AFXCMN_SUPPORT + + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_STDAFX_H__E8FBDA6A_CE57_4416_8329_90155CD6CEC3__INCLUDED_) diff --git a/utils/vmpi/vmpi_job_watch/res/vmpi_browser_job_watch.ico b/utils/vmpi/vmpi_job_watch/res/vmpi_browser_job_watch.ico Binary files differnew file mode 100644 index 0000000..7eef0bc --- /dev/null +++ b/utils/vmpi/vmpi_job_watch/res/vmpi_browser_job_watch.ico diff --git a/utils/vmpi/vmpi_job_watch/res/vmpi_browser_job_watch.rc2 b/utils/vmpi/vmpi_job_watch/res/vmpi_browser_job_watch.rc2 new file mode 100644 index 0000000..6e93fd0 --- /dev/null +++ b/utils/vmpi/vmpi_job_watch/res/vmpi_browser_job_watch.rc2 @@ -0,0 +1,13 @@ +// +// VMPI_BROWSER_JOB_WATCH.RC2 - resources Microsoft Visual C++ does not edit directly +// + +#ifdef APSTUDIO_INVOKED + #error this file is not editable by Microsoft Visual C++ +#endif //APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// Add manually edited resources here... + +///////////////////////////////////////////////////////////////////////////// diff --git a/utils/vmpi/vmpi_job_watch/resource.h b/utils/vmpi/vmpi_job_watch/resource.h new file mode 100644 index 0000000..c81a23e --- /dev/null +++ b/utils/vmpi/vmpi_job_watch/resource.h @@ -0,0 +1,32 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +//{{NO_DEPENDENCIES}} +// Microsoft Developer Studio generated include file. +// Used by vmpi_browser_job_watch.rc +// +#define IDD_VMPI_BROWSER_JOB_WATCH_DIALOG 102 +#define IDR_MAINFRAME 128 +#define IDD_JOB_WATCH 135 +#define IDC_WORKERS 1001 +#define IDC_GRAPH_AREA 1002 +#define IDC_TEXTOUTPUT 1005 +#define IDC_WORKERS_PANEL 1006 +#define IDC_TEXT_OUTPUT_PANEL 1007 +#define IDC_GRAPHS_PANEL 1008 +#define IDC_COMMAND_LINE 1009 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 129 +#define _APS_NEXT_COMMAND_VALUE 32771 +#define _APS_NEXT_CONTROL_VALUE 1010 +#define _APS_NEXT_SYMED_VALUE 101 +#endif +#endif diff --git a/utils/vmpi/vmpi_job_watch/vmpi_browser_job_watch.cpp b/utils/vmpi/vmpi_job_watch/vmpi_browser_job_watch.cpp new file mode 100644 index 0000000..efdf515 --- /dev/null +++ b/utils/vmpi/vmpi_job_watch/vmpi_browser_job_watch.cpp @@ -0,0 +1,75 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// vmpi_browser_job_watch.cpp : Defines the class behaviors for the application. +// + +#include "stdafx.h" +#include "vmpi_browser_job_watch.h" +#include "JobWatchDlg.h" + +#ifdef _DEBUG +#define new DEBUG_NEW +#undef THIS_FILE +static char THIS_FILE[] = __FILE__; +#endif + +///////////////////////////////////////////////////////////////////////////// +// CVMPIBrowserJobWatchApp + +BEGIN_MESSAGE_MAP(CVMPIBrowserJobWatchApp, CWinApp) + //{{AFX_MSG_MAP(CVMPIBrowserJobWatchApp) + // NOTE - the ClassWizard will add and remove mapping macros here. + // DO NOT EDIT what you see in these blocks of generated code! + //}}AFX_MSG + ON_COMMAND(ID_HELP, CWinApp::OnHelp) +END_MESSAGE_MAP() + +///////////////////////////////////////////////////////////////////////////// +// CVMPIBrowserJobWatchApp construction + +CVMPIBrowserJobWatchApp::CVMPIBrowserJobWatchApp() +{ + // TODO: add construction code here, + // Place all significant initialization in InitInstance +} + +///////////////////////////////////////////////////////////////////////////// +// The one and only CVMPIBrowserJobWatchApp object + +CVMPIBrowserJobWatchApp theApp; + +///////////////////////////////////////////////////////////////////////////// +// CVMPIBrowserJobWatchApp initialization + +BOOL CVMPIBrowserJobWatchApp::InitInstance() +{ + AfxEnableControlContainer(); + + // Standard initialization + // If you are not using these features and wish to reduce the size + // of your final executable, you should remove from the following + // the specific initialization routines you do not need. + + CJobWatchDlg dlg; + m_pMainWnd = &dlg; + int nResponse = dlg.DoModal(); + if (nResponse == IDOK) + { + // TODO: Place code here to handle when the dialog is + // dismissed with OK + } + else if (nResponse == IDCANCEL) + { + // TODO: Place code here to handle when the dialog is + // dismissed with Cancel + } + + // Since the dialog has been closed, return FALSE so that we exit the + // application, rather than start the application's message pump. + return FALSE; +} diff --git a/utils/vmpi/vmpi_job_watch/vmpi_browser_job_watch.h b/utils/vmpi/vmpi_job_watch/vmpi_browser_job_watch.h new file mode 100644 index 0000000..bd55384 --- /dev/null +++ b/utils/vmpi/vmpi_job_watch/vmpi_browser_job_watch.h @@ -0,0 +1,56 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// vmpi_browser_job_watch.h : main header file for the VMPI_BROWSER_JOB_WATCH application +// + +#if !defined(AFX_VMPI_BROWSER_JOB_WATCH_H__1DF22047_F615_4799_913A_222E3701BE5E__INCLUDED_) +#define AFX_VMPI_BROWSER_JOB_WATCH_H__1DF22047_F615_4799_913A_222E3701BE5E__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#ifndef __AFXWIN_H__ + #error include 'stdafx.h' before including this file for PCH +#endif + +#include "resource.h" // main symbols + +///////////////////////////////////////////////////////////////////////////// +// CVMPIBrowserJobWatchApp: +// See vmpi_browser_job_watch.cpp for the implementation of this class +// + +class CVMPIBrowserJobWatchApp : public CWinApp +{ +public: + CVMPIBrowserJobWatchApp(); + +// Overrides + // ClassWizard generated virtual function overrides + //{{AFX_VIRTUAL(CVMPIBrowserJobWatchApp) + public: + virtual BOOL InitInstance(); + //}}AFX_VIRTUAL + +// Implementation + + //{{AFX_MSG(CVMPIBrowserJobWatchApp) + // NOTE - the ClassWizard will add and remove member functions here. + // DO NOT EDIT what you see in these blocks of generated code ! + //}}AFX_MSG + DECLARE_MESSAGE_MAP() +}; + + +///////////////////////////////////////////////////////////////////////////// + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_VMPI_BROWSER_JOB_WATCH_H__1DF22047_F615_4799_913A_222E3701BE5E__INCLUDED_) diff --git a/utils/vmpi/vmpi_job_watch/vmpi_browser_job_watch.rc b/utils/vmpi/vmpi_job_watch/vmpi_browser_job_watch.rc new file mode 100644 index 0000000..56c3fc7 --- /dev/null +++ b/utils/vmpi/vmpi_job_watch/vmpi_browser_job_watch.rc @@ -0,0 +1,183 @@ +//Microsoft Developer Studio generated resource script. +// +#include "resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#include "afxres.h" + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +// English (U.S.) resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +#ifdef _WIN32 +LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US +#pragma code_page(1252) +#endif //_WIN32 + +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE DISCARDABLE +BEGIN + "resource.h\0" +END + +2 TEXTINCLUDE DISCARDABLE +BEGIN + "#include ""afxres.h""\r\n" + "\0" +END + +3 TEXTINCLUDE DISCARDABLE +BEGIN + "#define _AFX_NO_SPLITTER_RESOURCES\r\n" + "#define _AFX_NO_OLE_RESOURCES\r\n" + "#define _AFX_NO_TRACKER_RESOURCES\r\n" + "#define _AFX_NO_PROPERTY_RESOURCES\r\n" + "\r\n" + "#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)\r\n" + "#ifdef _WIN32\r\n" + "LANGUAGE 9, 1\r\n" + "#pragma code_page(1252)\r\n" + "#endif //_WIN32\r\n" + "#include ""res\\vmpi_browser_job_watch.rc2"" // non-Microsoft Visual C++ edited resources\r\n" + "#include ""afxres.rc"" // Standard components\r\n" + "#endif\r\n" + "\0" +END + +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// Icon +// + +// Icon with lowest ID value placed first to ensure application icon +// remains consistent on all systems. +IDR_MAINFRAME ICON DISCARDABLE "res\\vmpi_browser_job_watch.ico" + +#ifndef _MAC +///////////////////////////////////////////////////////////////////////////// +// +// Version +// + +VS_VERSION_INFO VERSIONINFO + FILEVERSION 1,0,0,1 + PRODUCTVERSION 1,0,0,1 + FILEFLAGSMASK 0x3fL +#ifdef _DEBUG + FILEFLAGS 0x1L +#else + FILEFLAGS 0x0L +#endif + FILEOS 0x4L + FILETYPE 0x1L + FILESUBTYPE 0x0L +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904B0" + BEGIN + VALUE "CompanyName", "\0" + VALUE "FileDescription", "vmpi_browser_job_watch MFC Application\0" + VALUE "FileVersion", "1, 0, 0, 1\0" + VALUE "InternalName", "vmpi_browser_job_watch\0" + VALUE "LegalCopyright", "Copyright (C) 2003\0" + VALUE "LegalTrademarks", "\0" + VALUE "OriginalFilename", "vmpi_browser_job_watch.EXE\0" + VALUE "ProductName", "vmpi_browser_job_watch Application\0" + VALUE "ProductVersion", "1, 0, 0, 1\0" + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 1200 + END +END + +#endif // !_MAC + + +///////////////////////////////////////////////////////////////////////////// +// +// Dialog +// + +IDD_JOB_WATCH DIALOG DISCARDABLE 0, 0, 592, 366 +STYLE WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_POPUP | WS_VISIBLE | WS_CAPTION | + WS_SYSMENU | WS_THICKFRAME +CAPTION "Job Watch" +FONT 8, "MS Sans Serif" +BEGIN + EDITTEXT IDC_TEXTOUTPUT,13,177,291,179,ES_MULTILINE | ES_READONLY | + WS_VSCROLL | WS_HSCROLL + GROUPBOX "Workers",IDC_WORKERS_PANEL,7,32,578,132 + GROUPBOX "Text Output",IDC_TEXT_OUTPUT_PANEL,7,164,303,195 + GROUPBOX "Graphs",IDC_GRAPHS_PANEL,318,164,267,195 + CONTROL "",IDC_GRAPH_AREA,"Static",SS_BLACKFRAME,323,176,255,179 + CONTROL "List1",IDC_WORKERS,"SysListView32",LVS_REPORT | + LVS_SORTASCENDING | WS_BORDER | WS_TABSTOP,13,41,564,118 + LTEXT "Command Line:",IDC_STATIC,7,9,50,8 + EDITTEXT IDC_COMMAND_LINE,60,7,364,14,ES_AUTOHSCROLL | + ES_READONLY +END + + +///////////////////////////////////////////////////////////////////////////// +// +// DESIGNINFO +// + +#ifdef APSTUDIO_INVOKED +GUIDELINES DESIGNINFO DISCARDABLE +BEGIN + IDD_JOB_WATCH, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 585 + TOPMARGIN, 7 + BOTTOMMARGIN, 359 + END +END +#endif // APSTUDIO_INVOKED + +#endif // English (U.S.) resources +///////////////////////////////////////////////////////////////////////////// + + + +#ifndef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 3 resource. +// +#define _AFX_NO_SPLITTER_RESOURCES +#define _AFX_NO_OLE_RESOURCES +#define _AFX_NO_TRACKER_RESOURCES +#define _AFX_NO_PROPERTY_RESOURCES + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +#ifdef _WIN32 +LANGUAGE 9, 1 +#pragma code_page(1252) +#endif //_WIN32 +#include "res\vmpi_browser_job_watch.rc2" // non-Microsoft Visual C++ edited resources +#include "afxres.rc" // Standard components +#endif + +///////////////////////////////////////////////////////////////////////////// +#endif // not APSTUDIO_INVOKED + diff --git a/utils/vmpi/vmpi_job_watch/vmpi_job_watch.vpc b/utils/vmpi/vmpi_job_watch/vmpi_job_watch.vpc new file mode 100644 index 0000000..9d8f372 --- /dev/null +++ b/utils/vmpi/vmpi_job_watch/vmpi_job_watch.vpc @@ -0,0 +1,80 @@ +//----------------------------------------------------------------------------- +// vmpi_job_watch.VPC +// +// Project Script +//----------------------------------------------------------------------------- + +$Macro SRCDIR "..\..\.." +$Macro OUTBINDIR "$SRCDIR\..\game\bin" +$Macro OUTBINNAME "vmpi_job_watch" + +$Include "$SRCDIR\vpc_scripts\source_exe_base.vpc" + +$Configuration +{ + $Compiler + { + $AdditionalIncludeDirectories "$BASE,.\,..\,..\..\common,..\mysql\include" + $PreprocessorDefinitions "$BASE;PROTECTED_THINGS_DISABLE;WINVER=0x501;NO_WARN_MBCS_MFC_DEPRECATION" + $EnableC++Exceptions "Yes (/EHsc)" + } +} + +$Configuration "Debug" +{ + $Linker + { + // Deprecated MBCS MFC libraries for VS 2013 (nafxcw.lib and nafxcwd.lib) can be downloaded from http://go.microsoft.com/?linkid=9832071 + $AdditionalDependencies "$BASE nafxcwd.lib" + $IgnoreSpecificLibrary "nafxcw.lib libcmt.lib" + } +} + +$Configuration "Release" +{ + $Linker + { + // Deprecated MBCS MFC libraries for VS 2013 (nafxcw.lib and nafxcwd.lib) can be downloaded from http://go.microsoft.com/?linkid=9832071 + $AdditionalDependencies "$BASE nafxcw.lib libcmt.lib" + $IgnoreSpecificLibrary "nafxcwd.lib libcmtd.lib" + } +} + +$Project "vmpi_job_watch" +{ + $Folder "Source Files" + { + -$File "$SRCDIR\public\tier0\memoverride.cpp" + + $File "..\..\common\consolewnd.cpp" + $File "GraphControl.cpp" + $File "..\idle_dialog.cpp" + $File "JobWatchDlg.cpp" + $File "..\mysql_async.cpp" + $File "..\vmpi_browser_helpers.cpp" + $File "vmpi_browser_job_watch.cpp" + $File "vmpi_browser_job_watch.rc" + $File "..\win_idle.cpp" + $File "..\window_anchor_mgr.cpp" + } + + $Folder "Header Files" + { + $File "..\..\common\consolewnd.h" + $File "GraphControl.h" + $File "..\idle_dialog.h" + $File "JobWatchDlg.h" + $File "..\mysql_async.h" + $File "..\mysql_wrapper.h" + $File "Resource.h" + $File "StdAfx.h" + $File "vmpi_browser_job_watch.h" + $File "..\win_idle.h" + } + + $Folder "Resource Files" + { + $File "res\vmpi_browser_job_watch.ico" + $File "res\vmpi_browser_job_watch.rc2" + } +} diff --git a/utils/vmpi/vmpi_parameters.h b/utils/vmpi/vmpi_parameters.h new file mode 100644 index 0000000..e6f0abc --- /dev/null +++ b/utils/vmpi/vmpi_parameters.h @@ -0,0 +1,31 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//============================================================================= + +VMPI_PARAM( mpi_Worker, 0, "Workers use this to connect to a VMPI job. Specify the IP address of the master. Example: -mpi_worker 1.2.3.4 or -mpi_worker 1.2.3.4:242" ) +VMPI_PARAM( mpi_Port, 0, "Use this on the master to force it to bind to a specified port. Otherwise it binds to 23311 (and ascending port numbers if 23311 doesn't work)." ) +VMPI_PARAM( mpi_Graphics, 0, "Show a graphical representation of work units [grey=work unit not sent yet, red=sent, green=completed, blue=in-process]" ) +VMPI_PARAM( mpi_Retry, 0, "Use this on the worker to have it retry connecting to the master forever. Otherwise it will exit if it can't connect to the master immediately." ) +VMPI_PARAM( mpi_AutoRestart, 0, "Use this on the worker to have it restart with the same command line parameters after completing a job. Useful in conjunction with -mpi_Retry to have an always-on worker ready to do work." ) +VMPI_PARAM( mpi_TrackEvents, 0, "Enables a debug menu during jobs (press D to access). Note: -mpi_Graphics automatically enables -mpi_TrackEvents." ) +VMPI_PARAM( mpi_ShowDistributeWorkStats, 0, "After finishing a stage in the work unit processing, shows statistics." ) +VMPI_PARAM( mpi_TimingWait, 0, "Causes the master to wait for a keypress to start so workers can connect before it starts. Used for performance measurements." ) +VMPI_PARAM( mpi_WorkerCount, 0, "Set the maximum number of workers allowed in the job." ) +VMPI_PARAM( mpi_AutoLocalWorker, 0, "Used on the master's machine. Automatically spawn a worker on the local machine. Used for testing." ) +VMPI_PARAM( mpi_FileTransmitRate, 0, "VMPI file transmission rate in kB/sec." ) +VMPI_PARAM( mpi_Verbose, 0, "Set to 0, 1, or 2 to control verbosity of debug output." ) +VMPI_PARAM( mpi_NoMasterWorkerThreads, 0, "Don't process work units locally (in the master). Only used by the SDK work unit distributor." ) +VMPI_PARAM( mpi_SDKMode, VMPI_PARAM_SDK_HIDDEN, "Force VMPI to run in SDK mode." ) +VMPI_PARAM( mpi_UseSDKDistributor, VMPI_PARAM_SDK_HIDDEN, "Use the SDK work unit distributor. Optimized for low numbers of workers and higher latency. Note that this will automatically be used in SDK distributions." ) +VMPI_PARAM( mpi_UseDefaultDistributor, VMPI_PARAM_SDK_HIDDEN, "Use the default work unit distributor. Optimized for high numbers of workers, higher numbers of work units, and lower latency. Note that this will automatically be used in non-SDK distributions." ) +VMPI_PARAM( mpi_NoTimeout, VMPI_PARAM_SDK_HIDDEN, "Don't timeout VMPI sockets. Used for testing." ) +VMPI_PARAM( mpi_DontSetThreadPriorities, VMPI_PARAM_SDK_HIDDEN, "Don't set worker thread priorities to idle." ) +VMPI_PARAM( mpi_GroupPackets, VMPI_PARAM_SDK_HIDDEN, "Delay and group some of the worker packets instead of sending immediately." ) +VMPI_PARAM( mpi_Stats, VMPI_PARAM_SDK_HIDDEN, "Enables the use of a database to store compile statistics." ) +VMPI_PARAM( mpi_Stats_TextOutput, VMPI_PARAM_SDK_HIDDEN, "Enables the workers storing all of their text output into the stats database." ) +VMPI_PARAM( mpi_pw, VMPI_PARAM_SDK_HIDDEN, "Non-SDK only. Sets a password on the VMPI job. Workers must also use the same -mpi_pw [password] argument or else the master will ignore their requests to join the job." ) +VMPI_PARAM( mpi_CalcShuffleCRC, VMPI_PARAM_SDK_HIDDEN, "Calculate a CRC for shuffled work unit arrays in the SDK work unit distributor." ) +VMPI_PARAM( mpi_Job_Watch, VMPI_PARAM_SDK_HIDDEN, "Automatically launches vmpi_job_watch.exe on the job." ) +VMPI_PARAM( mpi_Local, VMPI_PARAM_SDK_HIDDEN, "Similar to -mpi_AutoLocalWorker, but the automatically-spawned worker's console window is hidden." )
\ No newline at end of file diff --git a/utils/vmpi/vmpi_service/StdAfx.cpp b/utils/vmpi/vmpi_service/StdAfx.cpp new file mode 100644 index 0000000..f3f31b0 --- /dev/null +++ b/utils/vmpi/vmpi_service/StdAfx.cpp @@ -0,0 +1,15 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// stdafx.cpp : source file that includes just the standard includes +// vmpi_service.pch will be the pre-compiled header +// stdafx.obj will contain the pre-compiled type information + +#include "stdafx.h" + +// TODO: reference any additional headers you need in STDAFX.H +// and not in this file diff --git a/utils/vmpi/vmpi_service/StdAfx.h b/utils/vmpi/vmpi_service/StdAfx.h new file mode 100644 index 0000000..b490c37 --- /dev/null +++ b/utils/vmpi/vmpi_service/StdAfx.h @@ -0,0 +1,35 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, but +// are changed infrequently +// + +#if !defined(AFX_STDAFX_H__A1923E9A_F174_4448_8004_33888CD7DC88__INCLUDED_) +#define AFX_STDAFX_H__A1923E9A_F174_4448_8004_33888CD7DC88__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers + +#include <windows.h> +#include <winsock2.h> +#include <shellapi.h> +#include <winuser.h> +#include "basetypes.h" +#include <stdio.h> +#include "iphelpers.h" + +// TODO: reference additional headers your program requires here + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_STDAFX_H__A1923E9A_F174_4448_8004_33888CD7DC88__INCLUDED_) diff --git a/utils/vmpi/vmpi_service/perf_counters.cpp b/utils/vmpi/vmpi_service/perf_counters.cpp new file mode 100644 index 0000000..3d98d2a --- /dev/null +++ b/utils/vmpi/vmpi_service/perf_counters.cpp @@ -0,0 +1,500 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//============================================================================= + +#include "stdafx.h" +#include "tier1/utldict.h" +#include <pdh.h> +#include <pdhmsg.h> +#include "perf_counters.h" + + +#if 1 + +class CPerfTracker : public IPerfTracker +{ +public: + + CPerfTracker() + { + m_hProcessorTimeCounter = NULL; + m_dwProcessID = 0; + if ( PdhOpenQuery( NULL, 0, &m_hQuery ) != ERROR_SUCCESS ) + m_hQuery = NULL; + + SYSTEM_INFO info; + GetSystemInfo( &info ); + m_nProcessors = (int)info.dwNumberOfProcessors; + } + + ~CPerfTracker() + { + if ( m_hQuery ) + PdhCloseQuery( m_hQuery ); + } + + virtual void Init( unsigned long dwProcessID ) + { + Term(); + + m_dwProcessID = dwProcessID; + + char instanceName[512]; + if ( GetInstanceNameFromProcessID( m_dwProcessID, instanceName, sizeof( instanceName ) ) ) + { + // Create a counter to watch this process' time. + char str[512]; + V_snprintf( str, sizeof( str ), "\\Process(%s)\\%% Processor Time", instanceName ); + if ( PdhAddCounter( m_hQuery, str, 0, &m_hProcessorTimeCounter ) != ERROR_SUCCESS ) + { + m_hProcessorTimeCounter = NULL; + } + + V_snprintf( str, sizeof( str ), "\\Process(%s)\\Private Bytes", instanceName ); + if ( PdhAddCounter( m_hQuery, str, 0, &m_hPrivateBytesCounter ) != ERROR_SUCCESS ) + { + m_hPrivateBytesCounter = NULL; + } + } + } + + void Term() + { + if ( m_hProcessorTimeCounter ) + PdhRemoveCounter( m_hProcessorTimeCounter ); + + if ( m_hPrivateBytesCounter ) + PdhRemoveCounter( m_hPrivateBytesCounter ); + + m_hProcessorTimeCounter = NULL; + m_hPrivateBytesCounter = NULL; + } + + virtual void Release() + { + delete this; + } + + virtual unsigned long GetProcessID() + { + return m_dwProcessID; + } + + virtual void GetPerfData( int &processorPercentage, int &memoryUsageMegabytes ) + { + processorPercentage = 101; + memoryUsageMegabytes = 0; + + // Collect query data.. + PDH_STATUS ret = PdhCollectQueryData( m_hQuery ); + if ( ret != ERROR_SUCCESS ) + return; + + // Check processor usage. + DWORD dwType; + PDH_FMT_COUNTERVALUE counterValue; + if ( PdhGetFormattedCounterValue( m_hProcessorTimeCounter, PDH_FMT_LONG | PDH_FMT_NOCAP100, &dwType, &counterValue ) == ERROR_SUCCESS ) + processorPercentage = counterValue.longValue / m_nProcessors; + else + processorPercentage = 101; + + // Check memory usage. + if ( PdhGetFormattedCounterValue( m_hPrivateBytesCounter, PDH_FMT_DOUBLE | PDH_FMT_NOCAP100, &dwType, &counterValue ) == ERROR_SUCCESS ) + memoryUsageMegabytes = (int)(counterValue.doubleValue / (1024.0 * 1024.0)); + else + memoryUsageMegabytes = 0; + } + + +private: + + bool GetInstanceNameFromProcessID( DWORD processID, char *instanceName, int instanceNameLen ) + { + instanceName[0] = 0; + + bool bRet = false; + + // This refreshes the object list. If we don't do this, it won't get new process IDs correctly. + DWORD dummy = 0; + PdhEnumObjects( NULL, NULL, NULL, &dummy, PERF_DETAIL_NOVICE, true ); + + // Find out how much data we need. + DWORD counterListLen=2, instanceListLen=2; + char *counterList = new char[counterListLen]; + char *instanceList = new char[instanceListLen]; + PDH_STATUS stat = PdhEnumObjectItems( NULL, NULL, "Process", counterList, &counterListLen, instanceList, &instanceListLen, PERF_DETAIL_NOVICE, 0 ); + if ( stat == PDH_MORE_DATA ) + { + delete [] counterList; + delete [] instanceList; + char *counterList = new char[counterListLen]; + char *instanceList = new char[instanceListLen]; + + stat = PdhEnumObjectItems( NULL, NULL, "Process", counterList, &counterListLen, instanceList, &instanceListLen, PERF_DETAIL_NOVICE, 0 ); + if ( stat == ERROR_SUCCESS ) + { + // We need the # of each one.. + CUtlDict<int,int> counts; + + // The instance name list is a bunch of strings terminated with nulls. The final one has two nulls after it. + // Walk through the list and get the process ID associated with each instance name. + const char *pCur = instanceList; + while ( *pCur ) + { + int index = counts.Find( pCur ); + if ( index == counts.InvalidIndex() ) + counts.Insert( pCur, 1 ); + else + counts[index]++; + + pCur += strlen( pCur ) + 1; + } + + // Each instance (like "vrad") might have multiple versions, like if you're running multiple vrad processes at the same time. + for ( int i=counts.First(); i != counts.InvalidIndex(); i=counts.Next( i ) ) + { + const char *pInstanceName = counts.GetElementName( i ); + int nInstances = counts[i]; + for ( int iInstance=0; iInstance < nInstances; iInstance++ ) + { + char testInstanceName[256], fullObjectName[256]; + V_snprintf( testInstanceName, sizeof( testInstanceName ), "%s#%d", pInstanceName, iInstance ); + V_snprintf( fullObjectName, sizeof( fullObjectName ), "\\Process(%s)\\ID Process", testInstanceName ); + + HCOUNTER hCounter = NULL; + stat = PdhAddCounter( m_hQuery, fullObjectName, 0, &hCounter ); + if ( stat == ERROR_SUCCESS ) + { + stat = PdhCollectQueryData( m_hQuery ); + if ( stat == ERROR_SUCCESS ) + { + DWORD dwType; + PDH_FMT_COUNTERVALUE counterValue; + stat = PdhGetFormattedCounterValue( hCounter, PDH_FMT_LONG, &dwType, &counterValue ); + if ( stat == 0 && counterValue.longValue == (long)processID ) + { + // Finall! We found it. + V_strncpy( instanceName, testInstanceName, instanceNameLen ); + bRet = true; + PdhRemoveCounter( hCounter ); + break; + } + } + + PdhRemoveCounter( hCounter ); + } + } + + if ( bRet ) + break; + } + } + + delete [] counterList; + delete [] instanceList; + } + + return bRet; + } + +private: + DWORD m_dwProcessID; + PDH_HQUERY m_hQuery; + HCOUNTER m_hProcessorTimeCounter; + HCOUNTER m_hPrivateBytesCounter; + int m_nProcessors; +}; + + +IPerfTracker* CreatePerfTracker() +{ + return new CPerfTracker; +} + + +#else + +#include <winperf.h> + +// --------------------------------------------------------------------------------------------------------------------- // +// NOTE: THIS IS THE OLD, UGLY WAY TO DO IT. +// --------------------------------------------------------------------------------------------------------------------- // + +class CPerfTracker +{ +public: + CPerfTracker(); + void Init( unsigned long dwProcessID ); + + unsigned long GetProcessID(); + + // Get the percentage of CPU time that the process is using. + int GetCPUPercentage(); + +private: + DWORD m_dwProcessID; + LONGLONG m_lnOldValue; + LARGE_INTEGER m_OldPerfTime100nSec; + int m_nProcessors; +}; + +#define TOTALBYTES 100*1024 +#define BYTEINCREMENT 10*1024 + +#define SYSTEM_OBJECT_INDEX 2 // 'System' object +#define PROCESS_OBJECT_INDEX 230 // 'Process' object +#define PROCESSOR_OBJECT_INDEX 238 // 'Processor' object +#define TOTAL_PROCESSOR_TIME_COUNTER_INDEX 240 // '% Total processor time' counter (valid in WinNT under 'System' object) +#define PROCESSOR_TIME_COUNTER_INDEX 6 // '% processor time' counter (for Win2K/XP) + + +// +// The performance data is accessed through the registry key +// HKEY_PEFORMANCE_DATA. +// However, although we use the registry to collect performance data, +// the data is not stored in the registry database. +// Instead, calling the registry functions with the HKEY_PEFORMANCE_DATA key +// causes the system to collect the data from the appropriate system +// object managers. +// +// QueryPerformanceData allocates memory block for getting the +// performance data. +// +// +void QueryPerformanceData(PERF_DATA_BLOCK **pPerfData, DWORD dwObjectIndex, DWORD dwCounterIndex) +{ + // + // Since i want to use the same allocated area for each query, + // i declare CBuffer as static. + // The allocated is changed only when RegQueryValueEx return ERROR_MORE_DATA + // + static CUtlVector<char> Buffer; + if ( Buffer.Count() == 0 ) + Buffer.SetSize( TOTALBYTES ); + + DWORD BufferSize = Buffer.Count(); + LONG lRes; + + char keyName[32]; + V_snprintf(keyName, sizeof(keyName), "%d",dwObjectIndex); + + memset( Buffer.Base(), 0, Buffer.Count() ); + while( (lRes = RegQueryValueEx( HKEY_PERFORMANCE_DATA, + keyName, + NULL, + NULL, + (LPBYTE)Buffer.Base(), + &BufferSize )) == ERROR_MORE_DATA ) + { + // Get a buffer that is big enough. + BufferSize += BYTEINCREMENT; + Buffer.SetSize( BufferSize ); + } + + *pPerfData = (PPERF_DATA_BLOCK)Buffer.Base(); +} + + +/***************************************************************** + * * + * Functions used to navigate through the performance data. * + * * + *****************************************************************/ + +inline PPERF_OBJECT_TYPE FirstObject( PPERF_DATA_BLOCK PerfData ) +{ + return( (PPERF_OBJECT_TYPE)((PBYTE)PerfData + PerfData->HeaderLength) ); +} + +inline PPERF_OBJECT_TYPE NextObject( PPERF_OBJECT_TYPE PerfObj ) +{ + return( (PPERF_OBJECT_TYPE)((PBYTE)PerfObj + PerfObj->TotalByteLength) ); +} + +inline PPERF_COUNTER_DEFINITION FirstCounter( PPERF_OBJECT_TYPE PerfObj ) +{ + return( (PPERF_COUNTER_DEFINITION) ((PBYTE)PerfObj + PerfObj->HeaderLength) ); +} + +inline PPERF_COUNTER_DEFINITION NextCounter( PPERF_COUNTER_DEFINITION PerfCntr ) +{ + return( (PPERF_COUNTER_DEFINITION)((PBYTE)PerfCntr + PerfCntr->ByteLength) ); +} + +inline PPERF_INSTANCE_DEFINITION FirstInstance( PPERF_OBJECT_TYPE PerfObj ) +{ + return( (PPERF_INSTANCE_DEFINITION)((PBYTE)PerfObj + PerfObj->DefinitionLength) ); +} + +inline PPERF_INSTANCE_DEFINITION NextInstance( PPERF_INSTANCE_DEFINITION PerfInst ) +{ + PPERF_COUNTER_BLOCK PerfCntrBlk; + + PerfCntrBlk = (PPERF_COUNTER_BLOCK)((PBYTE)PerfInst + PerfInst->ByteLength); + + return( (PPERF_INSTANCE_DEFINITION)((PBYTE)PerfCntrBlk + PerfCntrBlk->ByteLength) ); +} + + +template<class T> +T GetCounterValueForProcessID(PPERF_OBJECT_TYPE pPerfObj, DWORD dwCounterIndex, DWORD dwProcessID) +{ + unsigned long PROC_ID_COUNTER = 784; + + BOOL bProcessIDExist = FALSE; + PPERF_COUNTER_DEFINITION pPerfCntr = NULL; + PPERF_COUNTER_DEFINITION pTheRequestedPerfCntr = NULL; + PPERF_COUNTER_DEFINITION pProcIDPerfCntr = NULL; + PPERF_INSTANCE_DEFINITION pPerfInst = NULL; + PPERF_COUNTER_BLOCK pCounterBlock = NULL; + + // Get the first counter. + + pPerfCntr = FirstCounter( pPerfObj ); + + for( DWORD j=0; j < pPerfObj->NumCounters; j++ ) + { + if (pPerfCntr->CounterNameTitleIndex == PROC_ID_COUNTER) + { + pProcIDPerfCntr = pPerfCntr; + if (pTheRequestedPerfCntr) + break; + } + + if (pPerfCntr->CounterNameTitleIndex == dwCounterIndex) + { + pTheRequestedPerfCntr = pPerfCntr; + if (pProcIDPerfCntr) + break; + } + + // Get the next counter. + + pPerfCntr = NextCounter( pPerfCntr ); + } + + if( pPerfObj->NumInstances == PERF_NO_INSTANCES ) + { + pCounterBlock = (PPERF_COUNTER_BLOCK) ((LPBYTE) pPerfObj + pPerfObj->DefinitionLength); + } + else + { + pPerfInst = FirstInstance( pPerfObj ); + + for( int k=0; k < pPerfObj->NumInstances; k++ ) + { + pCounterBlock = (PPERF_COUNTER_BLOCK) ((LPBYTE) pPerfInst + pPerfInst->ByteLength); + if (pCounterBlock) + { + DWORD processID = *(DWORD*)((LPBYTE) pCounterBlock + pProcIDPerfCntr->CounterOffset); + if (processID == dwProcessID) + { + bProcessIDExist = TRUE; + break; + } + } + + // Get the next instance. + pPerfInst = NextInstance( pPerfInst ); + } + } + + if (bProcessIDExist && pCounterBlock) + { + T *lnValue = NULL; + lnValue = (T*)((LPBYTE) pCounterBlock + pTheRequestedPerfCntr->CounterOffset); + return *lnValue; + } + return -1; +} + + +template<class T> +T GetCounterValueForProcessID(PERF_DATA_BLOCK **pPerfData, DWORD dwObjectIndex, DWORD dwCounterIndex, DWORD dwProcessID) +{ + QueryPerformanceData(pPerfData, dwObjectIndex, dwCounterIndex); + + PPERF_OBJECT_TYPE pPerfObj = NULL; + T lnValue = {0}; + + // Get the first object type. + pPerfObj = FirstObject( *pPerfData ); + + // Look for the given object index + + for( DWORD i=0; i < (*pPerfData)->NumObjectTypes; i++ ) + { + + if (pPerfObj->ObjectNameTitleIndex == dwObjectIndex) + { + lnValue = GetCounterValueForProcessID<T>(pPerfObj, dwCounterIndex, dwProcessID); + break; + } + + pPerfObj = NextObject( pPerfObj ); + } + return lnValue; +} + + +// ------------------------------------------------------------------------------------------- // +// CPerfTracker implementation. +// ------------------------------------------------------------------------------------------- // + +CPerfTracker::CPerfTracker() +{ + Init( 0 ); + + SYSTEM_INFO info; + GetSystemInfo( &info ); + m_nProcessors = (int)info.dwNumberOfProcessors; +} + + +void CPerfTracker::Init( unsigned long dwProcessID ) +{ + m_dwProcessID = dwProcessID; + m_lnOldValue = 0; +} + + +unsigned long CPerfTracker::GetProcessID() +{ + return m_dwProcessID; +} + + +int CPerfTracker::GetCPUPercentage() +{ + DWORD dwObjectIndex = PROCESS_OBJECT_INDEX; + DWORD dwCpuUsageIndex = PROCESSOR_TIME_COUNTER_INDEX; + + PPERF_DATA_BLOCK pPerfData = NULL; + LONGLONG lnNewValue = GetCounterValueForProcessID<LONGLONG>( &pPerfData, dwObjectIndex, dwCpuUsageIndex, m_dwProcessID ); + LARGE_INTEGER NewPerfTime100nSec = pPerfData->PerfTime100nSec; + + if ( m_lnOldValue == 0 ) + { + m_lnOldValue = lnNewValue; + m_OldPerfTime100nSec = NewPerfTime100nSec; + return 0; + } + + LONGLONG lnValueDelta = lnNewValue - m_lnOldValue; + double DeltaPerfTime100nSec = (double)NewPerfTime100nSec.QuadPart - (double)m_OldPerfTime100nSec.QuadPart; + + m_lnOldValue = lnNewValue; + m_OldPerfTime100nSec = NewPerfTime100nSec; + + double a = (double)lnValueDelta / DeltaPerfTime100nSec; + + int CpuUsage = (int) (a*100); + if (CpuUsage < 0) + return 0; + + return CpuUsage / m_nProcessors; +} + +#endif
\ No newline at end of file diff --git a/utils/vmpi/vmpi_service/perf_counters.h b/utils/vmpi/vmpi_service/perf_counters.h new file mode 100644 index 0000000..aa80014 --- /dev/null +++ b/utils/vmpi/vmpi_service/perf_counters.h @@ -0,0 +1,28 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//============================================================================= + +#ifndef PERF_COUNTERS_H +#define PERF_COUNTERS_H +#ifdef _WIN32 +#pragma once +#endif + + +class IPerfTracker +{ +public: + virtual void Init( unsigned long dwProcessID ) = 0; + virtual void Release() = 0; + + virtual unsigned long GetProcessID() = 0; + virtual void GetPerfData( int &processorPercentage, int &memoryUsageMegabytes ) = 0; +}; + + +IPerfTracker* CreatePerfTracker(); + + +#endif // PERF_COUNTERS_H diff --git a/utils/vmpi/vmpi_service/resource.h b/utils/vmpi/vmpi_service/resource.h new file mode 100644 index 0000000..492680b --- /dev/null +++ b/utils/vmpi/vmpi_service/resource.h @@ -0,0 +1,18 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +//{{NO_DEPENDENCIES}} +// Microsoft Visual C++ generated include file. +// Used by Vmpi_service.rc +// +#define IDS_STRING102 102 +#define IDS_VERSION_STRING 102 // *** If this changes, change the matching value in vmpi_defs.h! + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 103 +#define _APS_NEXT_COMMAND_VALUE 40001 +#define _APS_NEXT_CONTROL_VALUE 1001 +#define _APS_NEXT_SYMED_VALUE 101 +#endif +#endif diff --git a/utils/vmpi/vmpi_service/service_conn_mgr.cpp b/utils/vmpi/vmpi_service/service_conn_mgr.cpp new file mode 100644 index 0000000..c8b48ca --- /dev/null +++ b/utils/vmpi/vmpi_service/service_conn_mgr.cpp @@ -0,0 +1,234 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#include "stdafx.h" +#include "service_conn_mgr.h" +#include "vmpi.h" +#include "tier0/dbg.h" +#include "tcpsocket_helpers.h" + + +#define SERVICECONNMGR_CONNECT_ATTEMPT_INTERVAL 1000 + + + +// ------------------------------------------------------------------------------------------- // +// CServiceConn. +// ------------------------------------------------------------------------------------------- // + +CServiceConn::CServiceConn() +{ + m_pSocket = NULL; +} + + +CServiceConn::~CServiceConn() +{ + if ( m_pSocket ) + m_pSocket->Release(); +} + + +// ------------------------------------------------------------------------------------------- // +// CServiceConnMgr. +// ------------------------------------------------------------------------------------------- // + + +CServiceConnMgr::CServiceConnMgr() +{ + m_bServer = false; + m_bShuttingDown = false; + m_pListenSocket = NULL; +} + + +CServiceConnMgr::~CServiceConnMgr() +{ + Term(); +} + + +bool CServiceConnMgr::InitServer() +{ + Term(); + + m_bServer = true; + + // Create a socket to listen on. + for ( int iPort=VMPI_SERVICE_FIRST_UI_PORT; iPort <= VMPI_SERVICE_LAST_UI_PORT; iPort++ ) + { + m_pListenSocket = CreateTCPListenSocketEmu( iPort, 5 ); + if ( m_pListenSocket ) + break; + } + if ( !m_pListenSocket ) + return false; + + return true; +} + + +bool CServiceConnMgr::InitClient() +{ + Term(); + + m_bServer = false; + + AttemptConnect(); + return true; +} + + +void CServiceConnMgr::Term() +{ + m_bShuttingDown = true; // This prevents some reentrancy. + + // Get rid of our registry key. + if ( m_pListenSocket ) + { + m_pListenSocket->Release(); + m_pListenSocket = NULL; + } + + m_Connections.PurgeAndDeleteElements(); + + m_bShuttingDown = false; +} + + +bool CServiceConnMgr::IsConnected() +{ + return m_Connections.Count() != 0; +} + + +void CServiceConnMgr::Update() +{ + DWORD curTime = GetTickCount(); + + // Connect if we're an unconnected client. + if ( m_bServer ) + { + if ( m_pListenSocket ) + { + // Listen for more connections. + while ( 1 ) + { + CIPAddr addr; + ITCPSocket *pSocket = m_pListenSocket->UpdateListen( &addr ); + if ( !pSocket ) + break; + + CServiceConn *pConn = new CServiceConn; + pConn->m_ID = m_Connections.AddToTail( pConn ); + pConn->m_LastRecvTime = curTime; + pConn->m_pSocket = pSocket; + + OnNewConnection( pConn->m_ID ); + } + } + } + else + { + if ( !IsConnected() && curTime - m_LastConnectAttemptTime >= SERVICECONNMGR_CONNECT_ATTEMPT_INTERVAL ) + { + AttemptConnect(); + } + } + + // Check for timeouts and send acks. + int iNext; + for ( int iCur=m_Connections.Head(); iCur != m_Connections.InvalidIndex(); iCur=iNext ) + { + iNext = m_Connections.Next( iCur ); + CServiceConn *pConn = m_Connections[iCur]; + + if ( pConn->m_pSocket->IsConnected() ) + { + DWORD startTime = GetTickCount(); + CUtlVector<unsigned char> data; + while ( pConn->m_pSocket->Recv( data ) ) + { + HandlePacket( (char*)data.Base(), data.Count() ); + + // Don't sit in this loop too long. + if ( (GetTickCount() - startTime) > 50 ) + break; + } + } + else + { + OnTerminateConnection( iCur ); + m_Connections.Remove( iCur ); + delete pConn; + } + } +} + + +void CServiceConnMgr::SendPacket( int id, const void *pData, int len ) +{ + if ( id == -1 ) + { + FOR_EACH_LL( m_Connections, i ) + { + m_Connections[i]->m_pSocket->Send( pData, len ); + } + } + else + { + m_Connections[id]->m_pSocket->Send( pData, len ); + } +} + + +void CServiceConnMgr::AttemptConnect() +{ + m_LastConnectAttemptTime = GetTickCount(); + + + ITCPSocket *pSocket = NULL; + for ( int iPort=VMPI_SERVICE_FIRST_UI_PORT; iPort <= VMPI_SERVICE_LAST_UI_PORT; iPort++ ) + { + pSocket = CreateTCPSocketEmu(); + if ( !pSocket || !pSocket->BindToAny( 0 ) ) + return; + + CIPAddr addr( 127, 0, 0, 1, iPort ); + if ( TCPSocket_Connect( pSocket, &addr, 0.1 ) ) + break; + + pSocket->Release(); + pSocket = NULL; + } + + if ( pSocket ) + { + CServiceConn *pConn = new CServiceConn; + pConn->m_ID = m_Connections.AddToTail( pConn ); + pConn->m_LastRecvTime = GetTickCount(); + pConn->m_pSocket = pSocket; + + OnNewConnection( pConn->m_ID ); + } +} + + +void CServiceConnMgr::OnNewConnection( int id ) +{ +} + + +void CServiceConnMgr::OnTerminateConnection( int id ) +{ +} + + +void CServiceConnMgr::HandlePacket( const char *pData, int len ) +{ +} + diff --git a/utils/vmpi/vmpi_service/service_conn_mgr.h b/utils/vmpi/vmpi_service/service_conn_mgr.h new file mode 100644 index 0000000..c5f9558 --- /dev/null +++ b/utils/vmpi/vmpi_service/service_conn_mgr.h @@ -0,0 +1,92 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#ifndef SERVICE_CONN_MGR_H +#define SERVICE_CONN_MGR_H +#ifdef _WIN32 +#pragma once +#endif + + +#include "utllinkedlist.h" +#include "utlvector.h" +#include "tcpsocket.h" +#include "ThreadedTCPSocketEmu.h" + + +class CServiceConn +{ +public: + CServiceConn(); + ~CServiceConn(); + + int m_ID; + ITCPSocket *m_pSocket; + DWORD m_LastRecvTime; +}; + + +// ------------------------------------------------------------------------------------------ // +// CServiceConnMgr. This class manages connections to all the UIs (there should only be one UI at +// any given time, but it's conceivable that multiple people can be logged into NT servers +// simultaneously). +// ------------------------------------------------------------------------------------------ // + +class CServiceConnMgr +{ +public: + + CServiceConnMgr(); + ~CServiceConnMgr(); + + bool InitServer(); // Registers as a systemwide server. + bool InitClient(); // Connects to the server. + void Term(); + + // Returns true if there are any connections. If you used InitClient() and there are + // no connections, it will continuously try to connect with a server. + bool IsConnected(); + + // This should be called as often as possible. It checks for dead connections and it + // handles incoming packets from UIs. + void Update(); + + // This sends out a message. If id is -1, then it sends to all connections. + void SendPacket( int id, const void *pData, int len ); + + +// Overridables. +public: + + virtual void OnNewConnection( int id ); + virtual void OnTerminateConnection( int id ); + virtual void HandlePacket( const char *pData, int len ); + + +private: + + void AttemptConnect(); + + +private: + + CUtlLinkedList<CServiceConn*, int> m_Connections; + + bool m_bShuttingDown; + + // This tells if we're running as a client or server. + bool m_bServer; + + // If we're a client, this is the last time we tried to connect. + DWORD m_LastConnectAttemptTime; + + // If we're the server, this is the socket we listen on. + ITCPListenSocket *m_pListenSocket; +}; + + +#endif // SERVICE_CONN_MGR_H diff --git a/utils/vmpi/vmpi_service/service_helpers.cpp b/utils/vmpi/vmpi_service/service_helpers.cpp new file mode 100644 index 0000000..a20c5df --- /dev/null +++ b/utils/vmpi/vmpi_service/service_helpers.cpp @@ -0,0 +1,181 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#include "stdafx.h" +#include "service_helpers.h" + + +static CRITICAL_SECTION g_CtrlHandlerMutex; + +static void (*g_pInternalServiceFn)( void *pParam ) = NULL; +static void *g_pInternalServiceParam = NULL; + +static volatile bool g_bShouldExit = false; + + +SERVICE_STATUS MyServiceStatus; +SERVICE_STATUS_HANDLE MyServiceStatusHandle = NULL; + + +void WINAPI MyServiceCtrlHandler( DWORD Opcode ) +{ + DWORD status; + + switch(Opcode) + { + case SERVICE_CONTROL_STOP: + // Do whatever it takes to stop here. + ServiceHelpers_ExitEarly(); + + MyServiceStatus.dwWin32ExitCode = 0; + MyServiceStatus.dwCurrentState = SERVICE_STOPPED; + + if ( !SetServiceStatus( MyServiceStatusHandle, &MyServiceStatus) ) + { + status = GetLastError(); + Msg( "[MY_SERVICE] SetServiceStatus error %ld\n", status ); + } + + Msg( "[MY_SERVICE] Leaving MyService \n" ); + return; + + case SERVICE_CONTROL_INTERROGATE: + // Fall through to send current status. + break; + + default: + Msg("[MY_SERVICE] Unrecognized opcode %ld\n", Opcode ); + } + + // Send current status. + if ( !SetServiceStatus( MyServiceStatusHandle, &MyServiceStatus ) ) + { + status = GetLastError(); + Msg( "[MY_SERVICE] SetServiceStatus error %ld\n", status ); + } +} + + +void WINAPI MyServiceStart( DWORD argc, LPTSTR *argv ) +{ + DWORD status; + + MyServiceStatus.dwServiceType = SERVICE_WIN32; + MyServiceStatus.dwCurrentState = SERVICE_START_PENDING; + MyServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP; + MyServiceStatus.dwWin32ExitCode = 0; + MyServiceStatus.dwServiceSpecificExitCode = 0; + MyServiceStatus.dwCheckPoint = 0; + MyServiceStatus.dwWaitHint = 0; + + MyServiceStatusHandle = RegisterServiceCtrlHandler( "MyService", MyServiceCtrlHandler ); + if ( MyServiceStatusHandle == (SERVICE_STATUS_HANDLE)0 ) + { + Msg("[MY_SERVICE] RegisterServiceCtrlHandler failed %d\n", GetLastError() ); + return; + } + + // Initialization complete - report running status. + MyServiceStatus.dwCurrentState = SERVICE_RUNNING; + + if ( !SetServiceStatus( MyServiceStatusHandle, &MyServiceStatus ) ) + { + status = GetLastError(); + Msg( "[MY_SERVICE] SetServiceStatus error %ld\n", status ); + } + + + // Run the app's main in-thread loop. + g_pInternalServiceFn( g_pInternalServiceParam ); + + + // Tell the SCM that we're stopped. + MyServiceStatus.dwCurrentState = SERVICE_STOPPED; + MyServiceStatus.dwWin32ExitCode = NO_ERROR; + MyServiceStatus.dwServiceSpecificExitCode = 0; + SetServiceStatus( MyServiceStatusHandle, &MyServiceStatus ); + + + // This is where the service does its work. + Msg( "[MY_SERVICE] Returning the Main Thread \n" ); +} + + +void ServiceHelpers_Init() +{ + InitializeCriticalSection( &g_CtrlHandlerMutex ); +} + + +bool ServiceHelpers_StartService( const char *pServiceName, void (*pFn)( void *pParam ), void *pParam ) +{ + // Ok, just run the service. + const SERVICE_TABLE_ENTRY DispatchTable[2] = + { + { (char*)pServiceName, MyServiceStart }, + { NULL, NULL } + }; + + g_pInternalServiceFn = pFn; + g_pInternalServiceParam = pParam; + + if ( StartServiceCtrlDispatcher( DispatchTable ) ) + { + return true; + } + else + { + Msg( "StartServiceCtrlDispatcher error = '%s'\n", GetLastErrorString() ); + return false; + } +} + + +void ServiceHelpers_ExitEarly() +{ + EnterCriticalSection( &g_CtrlHandlerMutex ); + g_bShouldExit = true; + LeaveCriticalSection( &g_CtrlHandlerMutex ); +} + + +bool ServiceHelpers_ShouldExit() +{ + EnterCriticalSection( &g_CtrlHandlerMutex ); + bool bRet = g_bShouldExit; + LeaveCriticalSection( &g_CtrlHandlerMutex ); + + return bRet; +} + + +char* GetLastErrorString() +{ + static char err[2048]; + + LPVOID lpMsgBuf; + FormatMessage( + FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + GetLastError(), + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language + (LPTSTR) &lpMsgBuf, + 0, + NULL + ); + + strncpy( err, (char*)lpMsgBuf, sizeof( err ) ); + LocalFree( lpMsgBuf ); + + err[ sizeof( err ) - 1 ] = 0; + + return err; +} + + diff --git a/utils/vmpi/vmpi_service/service_helpers.h b/utils/vmpi/vmpi_service/service_helpers.h new file mode 100644 index 0000000..dc70f28 --- /dev/null +++ b/utils/vmpi/vmpi_service/service_helpers.h @@ -0,0 +1,43 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#ifndef SERVICE_HELPERS_H +#define SERVICE_HELPERS_H +#ifdef _WIN32 +#pragma once +#endif + + +// Call this if you want to use the ExitEarly() and ShouldExit() helpers. +void ServiceHelpers_Init(); + +// Start this app in the service control manager. +// +// The service will run in a thread. If the service starts successfully, then +// it will call pFn and pass in pParam. Inside there, you should loop until +// ShouldServiceExit() returns true. +bool ServiceHelpers_StartService( const char *pServiceName, void (*pFn)( void *pParam ), void *pParam ); + + +// Call this to exit the service early. This will make ShouldServiceExit() return true, +// and your main thread function should pick it up and exit. +// +// NOTE: this can be used even if the service isn't running as long as you call ServiceHelpers_Init(). +void ServiceHelpers_ExitEarly(); + +// Your thread loop should call this each time around. If this function returns true, +// then your thread function should return, causing the service to exit. +// +// NOTE: this can be used even if the service isn't running as long as you call ServiceHelpers_Init(). +bool ServiceHelpers_ShouldExit(); + + +// This function wants a better home. +char* GetLastErrorString(); + + +#endif // SERVICE_HELPERS_H diff --git a/utils/vmpi/vmpi_service/vmpi_service.cpp b/utils/vmpi/vmpi_service/vmpi_service.cpp new file mode 100644 index 0000000..03f7eea --- /dev/null +++ b/utils/vmpi/vmpi_service/vmpi_service.cpp @@ -0,0 +1,1710 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// vmpi_service.cpp : Defines the entry point for the console application. +// + +#include "stdafx.h" +#include "vmpi.h" +#include "iphelpers.h" +#include "bitbuf.h" +#include "tier1/strtools.h" +#include "interface.h" +#include "ilaunchabledll.h" +#include "resource.h" +#include "consolewnd.h" +#include <io.h> +#include "utllinkedlist.h" +#include "service_helpers.h" +#include "vmpi_filesystem.h" +#include "service_conn_mgr.h" +#include "resource.h" +#include "perf_counters.h" +#include "tier0/icommandline.h" + + +// If we couldn't get into a job (maybe they weren't accepting more workers at the time), +// then we wait this long and retry the connection. +#define JOB_MEMORY_DURATION 60 + + +char g_VersionString[64]; // From the IDS_VERSION_STRING string. +HKEY g_hVMPIServiceKey = NULL; // HKML/Software/Valve/VMPI + +double g_flLastKillProcessTime = 0; + +char *g_pPassword = NULL; // Set if this service is using a pw. +ISocket *g_pSocket = NULL; +int g_SocketPort = -1; // Which port we were able to bind the port on. + +char g_RunningProcess_ExeName[MAX_PATH] = {0}; +char g_RunningProcess_MapName[MAX_PATH] = {0}; +HANDLE g_hRunningProcess = NULL; +HANDLE g_hRunningThread = NULL; +DWORD g_dwRunningProcessId = 0; +IPerfTracker *g_pPerfTracker = NULL; // Tracks CPU usage. + +// When this is true, it will launch new processes invisibly. +bool g_bHideNewProcessWindows = true; + +HINSTANCE g_hInstance = NULL; +int g_iBoundPort = -1; + +bool g_bScreensaverMode = false; // If this is true, then it'll act like the service is disabled while + // a screensaver isn't running. + +// If this is on, it runs the exes out of c:/hl2/bin instead of the network. If the exes are built in debug, +// this makes it possible to catch nasty crashes. +bool g_bSuperDebugMode = false; + + +bool g_bScreensaverRunning = false; // Updated each frame to tell if the screensaver is running. + + +// GetTickCount() at the time the app was started. +DWORD g_AppStartTime = 0; + +// GetTickCount() at the time the service ran a worker app. +DWORD g_CreateProcessTime = 0; + + +CIPAddr g_CurRespondAddr; +int g_CurJobID[4]; +int g_CurJobPriority = -1; // VMPI priority of the currently-running job. + +// The directory we're running in. +char g_BaseAppPath[MAX_PATH]; +char g_FileCachePath[MAX_PATH]; // [base app path]\vmpi_service_cache. + + +// Different modes this app can run in. +#define RUNMODE_INSTALL 0 +#define RUNMODE_CONSOLE 1 +#define RUNMODE_SERVICE 2 + +int g_RunMode = RUNMODE_CONSOLE; + +bool g_bMinimized = false; // true if they run with -minimized. +int g_iCurState = VMPI_SERVICE_STATE_IDLE; +char g_CurMasterName[512] = {0}; + + + +////// +// This block of variables is setup while we wait for the downloader to finish. +// When the downloading is complete, we launch the app using these variables. +////// + +#ifdef _DEBUG + #define MAX_DOWNLOADER_TIME_ALLOWED 300000 // If the downloader takes longer than this, kill it. +#else + #define MAX_DOWNLOADER_TIME_ALLOWED 30 // If the downloader takes longer than this, kill it. +#endif + +// If this is non-NULL, then there is NOT a VMPI worker app running currently.. the downloader +HANDLE g_Waiting_hProcess = NULL; +float g_Waiting_StartTime = 0; +CUtlVector<char*> g_Waiting_Argv; +int g_Waiting_Priority = 0; +bool g_Waiting_bShowAppWindow = false; +bool g_Waiting_bPatching = 0; // If this is nonzero, then we're downloading so we can apply a patch. + + +// Used to track the services browsers that have been talking to us lately. +#define SERVICES_BROWSER_TIMEOUT 10 // We remove a services browser from the list if we don't hear from it for this long. +class CServicesBrowserInfo +{ +public: + float m_flLastPingTime; // Last time they talked to us. + CIPAddr m_Addr; // Their IP address. +}; +CUtlVector<CServicesBrowserInfo> g_ServicesBrowsers; + + +void HandlePacket_KILL_PROCESS( const CIPAddr *ipFrom ); +void KillRunningProcess( const char *pReason, bool bGoToIdle ); +void LoadStateFromRegistry(); +void SaveStateToRegistry(); + + +void SetPassword( const char *pPassword ) +{ + delete [] g_pPassword; + if ( pPassword ) + { + int len = V_strlen( pPassword ) + 1; + g_pPassword = new char[len]; + V_strncpy( g_pPassword, pPassword, len ); + } + else + { + g_pPassword = NULL; + } +} + + +// ------------------------------------------------------------------------------------------ // +// This handles connection to clients. +// ------------------------------------------------------------------------------------------ // + +class CVMPIServiceConnMgr : public CServiceConnMgr +{ +public: + + virtual void OnNewConnection( int id ); + virtual void HandlePacket( const char *pData, int len ); + void SendCurStateTo( int id ); + + +public: + + void AddConsoleOutput( const char *pMsg ); + + void SetAppState( int iState ); +}; + + +void CVMPIServiceConnMgr::AddConsoleOutput( const char *pMsg ) +{ + // Tell clients of the new text string. + CUtlVector<char> data; + data.AddToTail( VMPI_SERVICE_UI_PROTOCOL_VERSION ); + data.AddToTail( VMPI_SERVICE_TO_UI_CONSOLE_TEXT ); + data.AddMultipleToTail( strlen( pMsg ) + 1, pMsg ); + SendPacket( -1, data.Base(), data.Count() ); +} + + +void CVMPIServiceConnMgr::SetAppState( int iState ) +{ + // Update our state and send it to the clients. + g_iCurState = iState; + SendCurStateTo( -1 ); +} + + +void CVMPIServiceConnMgr::OnNewConnection( int id ) +{ + // Send our current state to the new connection. + Msg( "(debug) Made a new connection!\n" ); + SendCurStateTo( id ); +} + + +void CVMPIServiceConnMgr::SendCurStateTo( int id ) +{ + CUtlVector<char> data; + data.AddToTail( VMPI_SERVICE_UI_PROTOCOL_VERSION ); + data.AddToTail( VMPI_SERVICE_TO_UI_STATE ); + data.AddMultipleToTail( sizeof( g_iCurState ), (char*)&g_iCurState ); + data.AddToTail( (char)g_bScreensaverMode ); + + if ( g_pPassword ) + data.AddMultipleToTail( strlen( g_pPassword ) + 1, g_pPassword ); + else + data.AddToTail( 0 ); + + SendPacket( -1, data.Base(), data.Count() ); +} + + +void CVMPIServiceConnMgr::HandlePacket( const char *pData, int len ) +{ + switch( pData[0] ) + { + case VMPI_KILL_PROCESS: + { + HandlePacket_KILL_PROCESS( NULL ); + } + break; + + case VMPI_SERVICE_DISABLE: + { + KillRunningProcess( "Got a VMPI_SERVICE_DISABLE packet", true ); + SetAppState( VMPI_SERVICE_STATE_DISABLED ); + SaveStateToRegistry(); + } + break; + + case VMPI_SERVICE_ENABLE: + { + if ( g_iCurState == VMPI_SERVICE_STATE_DISABLED ) + { + SetAppState( VMPI_SERVICE_STATE_IDLE ); + } + SaveStateToRegistry(); + } + break; + + case VMPI_SERVICE_UPDATE_PASSWORD: + { + const char *pStr = pData + 1; + SetPassword( pStr ); + + // Send out the new state. + SendCurStateTo( -1 ); + } + break; + + case VMPI_SERVICE_SCREENSAVER_MODE: + { + g_bScreensaverMode = (pData[1] != 0); + SendCurStateTo( -1 ); + SaveStateToRegistry(); + } + break; + + case VMPI_SERVICE_EXIT: + { + Msg( "Got a VMPI_SERVICE_EXIT packet.\n "); + ServiceHelpers_ExitEarly(); + } + break; + } +} + +// This is allocated by the service thread and only used in there. +CVMPIServiceConnMgr *g_pConnMgr = NULL; + + +// ------------------------------------------------------------------------------------------ // +// Persistent state stuff. +// ------------------------------------------------------------------------------------------ // + +void LoadStateFromRegistry() +{ + if ( g_hVMPIServiceKey ) + { + DWORD val = 0; + DWORD type = REG_DWORD; + DWORD size = sizeof( val ); + + if ( RegQueryValueEx( + g_hVMPIServiceKey, + "ScreensaverMode", + 0, + &type, + (unsigned char*)&val, + &size ) == ERROR_SUCCESS && + type == REG_DWORD && + size == sizeof( val ) ) + { + g_bScreensaverMode = (val != 0); + } + + if ( RegQueryValueEx( + g_hVMPIServiceKey, + "Disabled", + 0, + &type, + (unsigned char*)&val, + &size ) == ERROR_SUCCESS && + type == REG_DWORD && + size == sizeof( val ) && + val != 0 ) + { + if ( g_pConnMgr ) + g_pConnMgr->SetAppState( VMPI_SERVICE_STATE_DISABLED ); + } + } +} + +void SaveStateToRegistry() +{ + if ( g_hVMPIServiceKey ) + { + DWORD val; + + val = g_bScreensaverMode; + RegSetValueEx( + g_hVMPIServiceKey, + "ScreensaverMode", + 0, + REG_DWORD, + (unsigned char*)&val, + sizeof( val ) ); + + val = (g_iCurState == VMPI_SERVICE_STATE_DISABLED); + RegSetValueEx( + g_hVMPIServiceKey, + "Disabled", + 0, + REG_DWORD, + (unsigned char*)&val, + sizeof( val ) ); + } +} + + +// ------------------------------------------------------------------------------------------ // +// Helper functions. +// ------------------------------------------------------------------------------------------ // + +char* FindArg( int argc, char **argv, const char *pArgName, char *pDefaultValue="" ) +{ + for ( int i=0; i < argc; i++ ) + { + if ( stricmp( argv[i], pArgName ) == 0 ) + { + if ( (i+1) >= argc ) + return pDefaultValue; + else + return argv[i+1]; + } + } + return NULL; +} + + +SpewRetval_t MySpewOutputFunc( SpewType_t spewType, const char *pMsg ) +{ + // Put the message in status.txt. +#ifdef VMPI_SERVICE_LOGS + static FILE *fp = fopen( "c:\\vmpi_service.log", "wt" ); + if ( fp ) + { + fprintf( fp, "%s", pMsg ); + fflush( fp ); + } +#endif + + + // Print it to the console. + if ( g_pConnMgr ) + g_pConnMgr->AddConsoleOutput( pMsg ); + + // Output to the debug console. + OutputDebugString( pMsg ); + + if ( spewType == SPEW_ASSERT ) + return SPEW_DEBUGGER; + else if( spewType == SPEW_ERROR ) + return SPEW_ABORT; + else + return SPEW_CONTINUE; +} + + +char* CopyString( const char *pStr ) +{ + int len = V_strlen( pStr ) + 1; + char *pRet = new char[len]; + V_strncpy( pRet, pStr, len ); + return pRet; +} + +void AppendArg( CUtlVector<char*> &newArgv, const char *pIn ) +{ + newArgv.AddToTail( CopyString( pIn ) ); +} + + +void SendStartStatus( bool bStatus ) +{ + for ( int i=0; i < 3; i++ ) + { + char data[4096]; + bf_write dataBuf( data, sizeof( data ) ); + dataBuf.WriteByte( VMPI_PROTOCOL_VERSION ); + dataBuf.WriteByte( VMPI_NOTIFY_START_STATUS ); + dataBuf.WriteBytes( g_CurJobID, sizeof( g_CurJobID ) ); + dataBuf.WriteByte( bStatus ); + g_pSocket->SendTo( &g_CurRespondAddr, data, dataBuf.GetNumBytesWritten() ); + + Sleep( 50 ); + } +} + + +void SendEndStatus() +{ + for ( int i=0; i < 3; i++ ) + { + char data[4096]; + bf_write dataBuf( data, sizeof( data ) ); + dataBuf.WriteByte( VMPI_PROTOCOL_VERSION ); + dataBuf.WriteByte( VMPI_NOTIFY_END_STATUS ); + dataBuf.WriteBytes( g_CurJobID, sizeof( g_CurJobID ) ); + g_pSocket->SendTo( &g_CurRespondAddr, data, dataBuf.GetNumBytesWritten() ); + + Sleep( 50 ); + } +} + + +void KillRunningProcess( const char *pReason, bool bGoToIdle ) +{ + // Kill the downloader if it's running. + if ( g_Waiting_hProcess ) + { + TerminateProcess( g_Waiting_hProcess, 1 ); + CloseHandle( g_Waiting_hProcess ); + g_Waiting_hProcess = NULL; + } + + if ( !g_hRunningProcess ) + return; + + if ( pReason ) + Msg( pReason ); + + SendEndStatus(); + TerminateProcess( g_hRunningProcess, 1 ); + g_RunningProcess_ExeName[0] = 0; + g_RunningProcess_MapName[0] = 0; + + // Yep. Now we can start a new one. + CloseHandle( g_hRunningThread ); + g_hRunningThread = NULL; + + CloseHandle( g_hRunningProcess ); + g_hRunningProcess = NULL; + + g_CurJobPriority = -1; + + if ( bGoToIdle ) + if ( g_pConnMgr ) + g_pConnMgr->SetAppState( VMPI_SERVICE_STATE_IDLE ); +} + + +// ------------------------------------------------------------------------------------------ // +// Job memory stuff. +// ------------------------------------------------------------------------------------------ // + +// CJobMemory is used to track which jobs we ran (or tried to run). +// We remember which jobs we did because Winsock likes to queue up the job packets on +// our socket, so if we don't remember which jobs we ran, we'd run the job a bunch of times. +class CJobMemory +{ +public: + int m_ID[4]; // Random ID that comes from the server. + float m_Time; +}; + +CUtlLinkedList<CJobMemory, int> g_JobMemories; + + +bool FindJobMemory( int id[4] ) +{ + int iNext; + for ( int i=g_JobMemories.Head(); i != g_JobMemories.InvalidIndex(); i=iNext ) + { + iNext = g_JobMemories.Next( i ); + + CJobMemory *pJob = &g_JobMemories[i]; + if ( memcmp( pJob->m_ID, id, sizeof( pJob->m_ID ) ) == 0 ) + return true; + } + return false; +} + + +void TimeoutJobIDs() +{ + double flCurTime = Plat_FloatTime(); + + int iNext; + for ( int i=g_JobMemories.Head(); i != g_JobMemories.InvalidIndex(); i=iNext ) + { + iNext = g_JobMemories.Next( i ); + + if ( (flCurTime - g_JobMemories[i].m_Time) > JOB_MEMORY_DURATION ) + g_JobMemories.Remove( i ); + } +} + + +void AddJobMemory( int id[4] ) +{ + TimeoutJobIDs(); + + CJobMemory job; + memcpy( job.m_ID, id, sizeof( job.m_ID ) ); + job.m_Time = Plat_FloatTime(); + g_JobMemories.AddToTail( job ); +} + + +bool CheckJobID( bf_read &buf, int jobID[4] ) +{ + TimeoutJobIDs(); + + jobID[0] = buf.ReadLong(); + jobID[1] = buf.ReadLong(); + jobID[2] = buf.ReadLong(); + jobID[3] = buf.ReadLong(); + if ( FindJobMemory( jobID ) || buf.IsOverflowed() ) + { + return false; + } + + return true; +} + + + + +// ------------------------------------------------------------------------------------------ // +// The main VMPI code. +// ------------------------------------------------------------------------------------------ // + +void VMPI_Waiter_Term() +{ + KillRunningProcess( NULL, false ); + if ( g_pConnMgr ) + { + g_pConnMgr->Term(); + delete g_pConnMgr; + g_pConnMgr = NULL; + } + + if ( g_pSocket ) + { + g_pSocket->Release(); + g_pSocket = NULL; + } + + g_pPerfTracker->Release(); + g_pPerfTracker = NULL; +} + + +bool VMPI_Waiter_Init() +{ + // Run as idle priority. + HKEY hKey = NULL; + RegCreateKey( HKEY_LOCAL_MACHINE, VMPI_SERVICE_KEY, &hKey ); + DWORD dwVal = 0; + DWORD dummyType = REG_DWORD; + DWORD dwValLen = sizeof( dwVal ); + if ( RegQueryValueEx( hKey, "LowPriority", NULL, &dummyType, (LPBYTE)&dwVal, &dwValLen ) == ERROR_SUCCESS ) + { + if ( dwVal ) + { + SetPriorityClass( GetCurrentProcess(), IDLE_PRIORITY_CLASS ); + } + } + else + { + RegSetValueEx( hKey, "LowPriority", 0, REG_DWORD, (unsigned char*)&dwVal, sizeof( dwVal ) ); + } + + g_pConnMgr = new CVMPIServiceConnMgr; + + if ( !g_pConnMgr->InitServer() ) + Msg( "ERROR INITIALIZING CONNMGR\n" ); + + g_pSocket = CreateIPSocket(); + if ( !g_pSocket ) + { + Msg( "Error creating a socket.\n" ); + return false; + } + + // Bind to the first port we find in the range [VMPI_SERVICE_PORT, VMPI_LAST_SERVICE_PORT]. + int iTest; + for ( iTest=VMPI_SERVICE_PORT; iTest <= VMPI_LAST_SERVICE_PORT; iTest++ ) + { + g_SocketPort = iTest; + if ( g_pSocket->BindToAny( iTest ) ) + break; + } + if ( iTest == VMPI_LAST_SERVICE_PORT ) + { + Msg( "Error binding a socket to port %d.\n", VMPI_SERVICE_PORT ); + VMPI_Waiter_Term(); + return false; + } + + g_iBoundPort = iTest; + g_pPerfTracker = CreatePerfTracker(); + return true; +} + + +void RunInDLL( const char *pFilename, CUtlVector<char*> &newArgv ) +{ + if ( g_pConnMgr ) + g_pConnMgr->SetAppState( VMPI_SERVICE_STATE_BUSY ); + + bool bSuccess = false; + CSysModule *pModule = Sys_LoadModule( pFilename ); + if ( pModule ) + { + CreateInterfaceFn fn = Sys_GetFactory( pModule ); + if ( fn ) + { + ILaunchableDLL *pDLL = (ILaunchableDLL*)fn( LAUNCHABLE_DLL_INTERFACE_VERSION, NULL ); + if( pDLL ) + { + // Do this here because the executables we would have launched usually would do it. + CommandLine()->CreateCmdLine( newArgv.Count(), newArgv.Base() ); + pDLL->main( newArgv.Count(), newArgv.Base() ); + bSuccess = true; + SpewOutputFunc( MySpewOutputFunc ); + } + } + + Sys_UnloadModule( pModule ); + } + + if ( !bSuccess ) + { + Msg( "Error running VRAD (or VVIS) out of DLL '%s'\n", pFilename ); + } + + if ( g_pConnMgr ) + g_pConnMgr->SetAppState( VMPI_SERVICE_STATE_IDLE ); +} + + +void GetArgsFromBuffer( + bf_read &buf, + CUtlVector<char*> &newArgv, + bool *bShowAppWindow ) +{ + int nArgs = buf.ReadWord(); + + bool bSpewArgs = false; + + for ( int iArg=0; iArg < nArgs; iArg++ ) + { + char argStr[512]; + buf.ReadString( argStr, sizeof( argStr ) ); + + AppendArg( newArgv, argStr ); + if ( stricmp( argStr, "-mpi_verbose" ) == 0 ) + bSpewArgs = true; + + if ( stricmp( argStr, "-mpi_ShowAppWindow" ) == 0 ) + *bShowAppWindow = true; + } + + if ( bSpewArgs ) + { + Msg( "nArgs: %d\n", newArgv.Count() ); + for ( int i=0; i < newArgv.Count(); i++ ) + Msg( "Arg %d: %s\n", i, newArgv[i] ); + } +} + + +bool GetDLLFilename( CUtlVector<char*> &newArgv, char pDLLFilename[MAX_PATH] ) +{ + char *argStr = newArgv[0]; + int argLen = strlen( argStr ); + if ( argLen <= 4 ) + return false; + + if ( Q_stricmp( &argStr[argLen-4], ".exe" ) != 0 ) + return false; + + char baseFilename[MAX_PATH]; + Q_strncpy( baseFilename, argStr, MAX_PATH ); + baseFilename[ min( MAX_PATH-1, argLen-4 ) ] = 0; + + // First try _dll.dll (src_main), then try .dll (rel). + V_snprintf( pDLLFilename, MAX_PATH, "%s_dll.dll", baseFilename ); + if ( _access( pDLLFilename, 0 ) != 0 ) + { + V_snprintf( pDLLFilename, MAX_PATH, "%s.dll", baseFilename ); + } + + return true; +} + +void BuildCommandLineFromArgs( CUtlVector<char*> &newArgv, char *pOut, int outLen ) +{ + pOut[0] = 0; + + for ( int i=0; i < newArgv.Count(); i++ ) + { + char argStr[512]; + if ( strlen( newArgv[i] ) > 0 && newArgv[i][strlen(newArgv[i])-1] == '\\' ) + Q_snprintf( argStr, sizeof( argStr ), "\"%s\\\" ", newArgv[i] ); + else + Q_snprintf( argStr, sizeof( argStr ), "\"%s\" ", newArgv[i] ); + + Q_strncat( pOut, argStr, outLen, COPY_ALL_CHARACTERS ); + } +} + +bool RunProcessFromArgs( CUtlVector<char*> &newArgv, bool bShowAppWindow, bool bCreateSuspended, const char *pWorkingDir, PROCESS_INFORMATION *pOut ) +{ + char commandLine[2048]; + BuildCommandLineFromArgs( newArgv, commandLine, sizeof( commandLine ) ); + + Msg( "Running '%s'\n", commandLine ); + + STARTUPINFO si; + memset( &si, 0, sizeof( si ) ); + si.cb = sizeof( si ); + + memset( pOut, 0, sizeof( *pOut ) ); + + DWORD dwFlags = 0;//IDLE_PRIORITY_CLASS; + if ( bShowAppWindow ) + dwFlags |= CREATE_NEW_CONSOLE; + else + dwFlags |= CREATE_NO_WINDOW; + + if ( bCreateSuspended ) + dwFlags |= CREATE_SUSPENDED; + + UINT oldMode = SetErrorMode( SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS ); + + BOOL bRet = CreateProcess( + NULL, + commandLine, + NULL, // security + NULL, + TRUE, + dwFlags | IDLE_PRIORITY_CLASS, // flags + NULL, // environment + pWorkingDir, + &si, + pOut ); + + SetErrorMode( oldMode ); + return (bRet != FALSE); +} + + +void RunProcessAtCommandLine( + CUtlVector<char*> &newArgv, + bool bShowAppWindow, + bool bCreateSuspended, + int iPriority ) +{ + // current directory (use c:\\ because we don't want it to accidentally share + // DLLs like vstdlib with us). PROCESS_INFORMATION pi; + PROCESS_INFORMATION pi; + if ( RunProcessFromArgs( newArgv, bShowAppWindow, bCreateSuspended, g_FileCachePath, &pi ) ) + { + if ( g_pConnMgr ) + g_pConnMgr->SetAppState( VMPI_SERVICE_STATE_BUSY ); + + if ( newArgv.Count() > 0 && newArgv[0] ) + { + V_FileBase( newArgv[0], g_RunningProcess_ExeName, sizeof( g_RunningProcess_ExeName ) ); + + if ( V_stricmp( g_RunningProcess_ExeName, "vrad" ) == 0 || V_stricmp( g_RunningProcess_ExeName, "vvis" ) == 0 ) + V_FileBase( newArgv[newArgv.Count()-1], g_RunningProcess_MapName, sizeof( g_RunningProcess_MapName ) ); + } + + g_hRunningProcess = pi.hProcess; + g_hRunningThread = pi.hThread; + g_dwRunningProcessId = pi.dwProcessId; + g_pPerfTracker->Init( g_dwRunningProcessId ); + g_CurJobPriority = iPriority; + g_CreateProcessTime = GetTickCount(); + + SendStartStatus( true ); + } + else + { + Msg( " - ERROR in CreateProcess (%s)!\n", GetLastErrorString() ); + SendStartStatus( false ); + g_CurJobPriority = -1; + g_RunningProcess_ExeName[0] = 0; + g_RunningProcess_MapName[0] = 0; + } +} + + +bool WaitForProcessToExit() +{ + if ( g_hRunningProcess ) + { + // Did the process complete yet? + if ( WaitForSingleObject( g_hRunningProcess, 0 ) == WAIT_TIMEOUT ) + { + // Nope.. keep waiting. + return true; + } + else + { + Msg( "Finished!\n "); + + SendEndStatus(); + + // Change back to the 'waiting' icon. + if ( g_pConnMgr ) + g_pConnMgr->SetAppState( VMPI_SERVICE_STATE_IDLE ); + g_CurJobPriority = -1; + + // Yep. Now we can start a new one. + CloseHandle( g_hRunningThread ); + CloseHandle( g_hRunningProcess ); + g_hRunningProcess = g_hRunningThread = NULL; + g_RunningProcess_ExeName[0] = g_RunningProcess_MapName[0] = 0; + } + } + + return false; +} + + +void HandleWindowMessages() +{ + MSG msg; + while ( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) ) + { + TranslateMessage( &msg ); + DispatchMessage( &msg ); + } +} + +void GetRunningProcessStats( int &processorPercentage, int &memoryUsageMegabytes ) +{ + static int lastProcessorPercentage = 0; + static int lastMemory = 0; + if ( g_hRunningProcess ) + { + // Only update this every couple seconds. It's not too expensive (about 800 microseconds), but we don't + // need to do it a whole lot. + static DWORD lastReturnTime = GetTickCount(); + DWORD curTime = GetTickCount(); + if ( (curTime - lastReturnTime) >= 1000 ) + { + lastReturnTime = curTime; + g_pPerfTracker->GetPerfData( lastProcessorPercentage, lastMemory ); + } + } + else + { + lastProcessorPercentage = lastMemory = 0; + } + + processorPercentage = lastProcessorPercentage; + memoryUsageMegabytes = lastMemory; +} + + +void BuildPingHeader( CUtlVector<char> &data, char packetID, int iState ) +{ + // Figure out the computer's name. + char computerName[128]; + DWORD computerNameLen = sizeof( computerName ); + GetComputerName( computerName, &computerNameLen ); + + // Ping back at them. + data.AddToTail( VMPI_PROTOCOL_VERSION ); + data.AddToTail( packetID ); + data.AddToTail( (char)iState ); + + DWORD liveTime = GetTickCount() - g_AppStartTime; + data.AddMultipleToTail( sizeof( liveTime ), (char*)&liveTime ); + + data.AddMultipleToTail( sizeof( g_SocketPort ), (char*)&g_SocketPort ); + data.AddMultipleToTail( strlen( computerName ) + 1, computerName ); + + if ( g_hRunningProcess ) + data.AddMultipleToTail( strlen( g_CurMasterName ) + 1, g_CurMasterName ); + else + data.AddMultipleToTail( 1, "" ); + + // Write in how long the worker app has been running. + DWORD appRunTime = 0; + if ( g_hRunningProcess ) + appRunTime = GetTickCount() - g_CreateProcessTime; + + data.AddMultipleToTail( sizeof( appRunTime ), (char*)&appRunTime ); + + // Finally, write the password. + if ( g_pPassword ) + data.AddMultipleToTail( strlen( g_pPassword ) + 1, g_pPassword ); + else + data.AddToTail( 0 ); + + data.AddMultipleToTail( V_strlen( g_VersionString ) + 1, g_VersionString ); + + int processorPercentage, memoryUsageMegabytes; + GetRunningProcessStats( processorPercentage, memoryUsageMegabytes ); + + // Write processor percentage. + data.AddToTail( (char)processorPercentage ); + + // Write the EXE name. + data.AddMultipleToTail( V_strlen( g_RunningProcess_ExeName ) + 1, g_RunningProcess_ExeName ); + + // Write memory usage. + short memUsageShort = (short)memoryUsageMegabytes; + data.AddMultipleToTail( sizeof( memUsageShort ), (const char*)&memUsageShort ); + + // Write the map name. + data.AddMultipleToTail( V_strlen( g_RunningProcess_MapName ) + 1, g_RunningProcess_MapName ); +} + + +// This tracks a list +void AddServicesBrowserIP( const CIPAddr &ipFrom ) +{ + for ( int i=0; i < g_ServicesBrowsers.Count(); i++ ) + { + if ( g_ServicesBrowsers[i].m_Addr == ipFrom ) + { + g_ServicesBrowsers[i].m_flLastPingTime = Plat_FloatTime(); + return; + } + } + CServicesBrowserInfo info; + info.m_Addr = ipFrom; + info.m_flLastPingTime = Plat_FloatTime(); + g_ServicesBrowsers.AddToTail( info ); +} + + +void UpdateServicesBrowserIPs() +{ + double curTime = Plat_FloatTime(); + for ( int i=0; i < g_ServicesBrowsers.Count(); i++ ) + { + if ( (curTime - g_ServicesBrowsers[i].m_flLastPingTime) >= SERVICES_BROWSER_TIMEOUT ) + { + g_ServicesBrowsers.Remove( i ); + --i; + break; + } + } +} + + +void SendStateToServicesBrowsers() +{ + int curState; + if ( g_hRunningProcess ) + { + if ( g_Waiting_bPatching ) + curState = VMPI_STATE_PATCHING; + else + curState = VMPI_STATE_BUSY; + } + else if ( g_Waiting_hProcess ) + { + if ( g_Waiting_bPatching ) + curState = VMPI_STATE_PATCHING; + else + curState = VMPI_STATE_DOWNLOADING; + } + else if ( g_iCurState == VMPI_SERVICE_STATE_DISABLED ) + { + curState = VMPI_STATE_DISABLED; + } + else if ( g_bScreensaverMode && !g_bScreensaverRunning ) + { + curState = VMPI_STATE_SCREENSAVER_DISABLED; + } + else + { + curState = VMPI_STATE_IDLE; + } + + CUtlVector<char> data; + BuildPingHeader( data, VMPI_PING_RESPONSE, curState ); + + for ( int i=0; i < g_ServicesBrowsers.Count(); i++ ) + { + g_pSocket->SendTo( &g_ServicesBrowsers[i].m_Addr, data.Base(), data.Count() ); + } +} + + +void StopUI() +{ + char cPacket[2] = {VMPI_SERVICE_UI_PROTOCOL_VERSION, VMPI_SERVICE_TO_UI_EXIT}; + if ( g_pConnMgr ) + g_pConnMgr->SendPacket( -1, &cPacket, sizeof( cPacket ) ); + + // Wait for a bit for the connection to go away. + DWORD startTime = GetTickCount(); + while ( GetTickCount()-startTime < 2000 ) + { + if ( g_pConnMgr ) + { + g_pConnMgr->Update(); + if ( !g_pConnMgr->IsConnected() ) + break; + else + Sleep( 10 ); + } + } +} + + +void CheckScreensaverRunning() +{ + // We want to let patching finish even if we're in screensaver mode. + if ( g_Waiting_hProcess && g_Waiting_bPatching ) + return; + + BOOL bRunning = false; + SystemParametersInfo( SPI_GETSCREENSAVERRUNNING, 0, &bRunning, 0 ); + + g_bScreensaverRunning = (bRunning != 0); + if ( !g_bScreensaverRunning && g_bScreensaverMode ) + { + KillRunningProcess( "Screensaver not running", true ); + } +} + + +void AdjustSuperDebugArgs( CUtlVector<char*> &args ) +{ + // Get the directory this exe was run out of. + char filename[512]; + if ( GetModuleFileName( GetModuleHandle( NULL ), filename, sizeof( filename ) ) == 0 ) + return; + + char *pLastSlash = filename; + char *pCurPos = filename; + while ( *pCurPos ) + { + if ( *pCurPos == '/' || *pCurPos == '\\' ) + pLastSlash = pCurPos; + ++pCurPos; + } + *pLastSlash = 0; + + // In superdebug mode, run it out of c:/hl2/bin. + const char *pBase = args[0]; + const char *pBaseCur = pBase; + while ( *pBaseCur ) + { + if ( *pBaseCur == '/' || *pBaseCur == '\\' || *pBaseCur == ':' ) + { + pBase = pBaseCur+1; + pBaseCur = pBase; + } + ++pBaseCur; + } + + int maxLen = 64 + strlen( pBase ) + 1; + char *pNewFilename = new char[maxLen]; + _snprintf( pNewFilename, maxLen, "%s\\%s", filename, pBase ); + delete args[0]; + args[0] = pNewFilename; + + + // Now insert -allowdebug. + const char *pAllowDebug = "-allowdebug"; + char *pToInsert = new char[ strlen( pAllowDebug ) + 1 ]; + strcpy( pToInsert, pAllowDebug ); + args.InsertAfter( 0, pToInsert ); + +} + + +// -------------------------------------------------------------------------------- // +// Purpose: Launches vmpi_transfer.exe to download the required +// files from the master so we can launch. +// +// If successful, it sets hProcess to the process handle of the downloader. +// When that process terminates, we look for [cache dir]\ReadyToGo.txt and if it's +// there, then we start the job. +// -------------------------------------------------------------------------------- // +bool StartDownloadingAppFiles( + CUtlVector<char*> &newArgv, + char *cacheDir, + int cacheDirLen, + bool bShowAppWindow, + HANDLE *hProcess, + bool bPatching ) +{ + *hProcess = NULL; + + V_strncpy( cacheDir, g_FileCachePath, cacheDirLen ); + + // For now, cache dir is always the same. It's [current directory]\cache. + if ( _access( cacheDir, 0 ) != 0 ) + { + if ( !CreateDirectory( cacheDir, NULL ) && GetLastError() != ERROR_ALREADY_EXISTS ) + { + Warning( "Unable to create cache directory: %s.\n", cacheDir ); + return false; + } + } + + // Clear all the files in the directory. + char searchStr[MAX_PATH]; + V_ComposeFileName( cacheDir, "*.*", searchStr, sizeof( searchStr ) ); + _finddata_t findData; + intptr_t ret = _findfirst( searchStr, &findData ); + if ( ret != -1 ) + { + do + { + if ( findData.name[0] == '.' ) + continue; + + char fullFilename[MAX_PATH]; + V_ComposeFileName( cacheDir, findData.name, fullFilename, sizeof( fullFilename ) ); + if ( _unlink( fullFilename ) != 0 ) + { + Warning( "_unlink( %s ) failed.\n", fullFilename ); + return false; + } + } while ( _findnext( ret, &findData ) == 0 ); + + _findclose( ret ); + } + + // Change the EXE name to an absolute path to exactly where it is in the cache directory. + int maxExeNameLen = 1024; + char *pExeName = new char[maxExeNameLen]; + if ( bPatching ) + { + V_ComposeFileName( cacheDir, "vmpi_service_install.exe", pExeName, maxExeNameLen ); + + // Add args for the installer. + newArgv.InsertAfter( 0, CopyString( "-DontTouchUI" ) ); + + // When patching, we can't start the UI and the installer can't because we're running in the local system account + // and the UI is running on the account of whoever logged in. So what we do is send a message to the UI telling it + // to run <cacheDir>\WaitAndRestart and restart itself in N seconds. + newArgv.InsertAfter( 0, CopyString( "-Install_Quiet" ) ); + } + else + { + V_ComposeFileName( cacheDir, newArgv[0], pExeName, maxExeNameLen ); + } + + delete newArgv[0]; + newArgv[0] = pExeName; + + char fullExeFilename[MAX_PATH]; + V_ComposeFileName( g_BaseAppPath, "vmpi_transfer.exe", fullExeFilename, sizeof( fullExeFilename ) ); + + CUtlVector<char*> downloaderArgs; + downloaderArgs.AddToTail( fullExeFilename ); +#if defined( _DEBUG ) + downloaderArgs.AddToTail( "-allowdebug" ); +#endif + downloaderArgs.AddToTail( "-CachePath" ); // Tell it where to download the files to. + downloaderArgs.AddToTail( cacheDir ); + + // Pass all the -mpi_worker, -mpi_file, -mpi_filebase args into the downloader app. + for ( int i=1; i < (int)newArgv.Count()-1; i++ ) + { + if ( V_stricmp( newArgv[i], "-mpi_filebase" ) == 0 || V_stricmp( newArgv[i], "-mpi_file" ) == 0 ) + { + downloaderArgs.AddToTail( newArgv[i] ); + downloaderArgs.AddToTail( newArgv[i+1] ); + newArgv.Remove( i ); + newArgv.Remove( i ); + --i; + } + else if ( V_stricmp( newArgv[i], "-mpi_worker" ) == 0 ) + { + // We need this arg so it knows what IP to connect to, but we want to leave it in the final launch args too. + downloaderArgs.AddToTail( newArgv[i] ); + downloaderArgs.AddToTail( newArgv[i+1] ); + ++i; + } + } + + // Transfer each file. + PROCESS_INFORMATION pi; + if ( !RunProcessFromArgs( downloaderArgs, bShowAppWindow, false, g_BaseAppPath, &pi ) ) + return false; + + *hProcess = pi.hProcess; + return true; +} + + +void SendPatchCommandToUIs( DWORD dwInstallerProcessId ) +{ + Msg( "SendPatchCommandToUIs\n "); + + CUtlVector<char> data; + data.AddToTail( VMPI_SERVICE_UI_PROTOCOL_VERSION ); + data.AddToTail( VMPI_SERVICE_TO_UI_PATCHING ); + + // This arg tells the UI whether to exit after running the command or not. + data.AddToTail( 1 ); + + // First argument is the working directory, which is the cache path in this case. + data.AddMultipleToTail( V_strlen( g_FileCachePath ) + 1, g_FileCachePath ); + + // Second argument is the command line. + char waitAndRestartExe[MAX_PATH], serviceUIExe[MAX_PATH], commandLine[1024 * 8]; + V_ComposeFileName( g_FileCachePath, "WaitAndRestart.exe", waitAndRestartExe, sizeof( waitAndRestartExe ) ); + V_ComposeFileName( g_BaseAppPath, "vmpi_service_ui.exe", serviceUIExe, sizeof( serviceUIExe ) ); // We're running the UI from the same directory this exe is in. + char strSeconds[64]; + V_snprintf( strSeconds, sizeof( strSeconds ), "*%lu", dwInstallerProcessId ); + + // IMPORTANT to use BuildCommandLineFromArgs here because it'll handle slashes and quotes correctly. + // If we don't do that, the command often won't work. + CUtlVector<char*> args; + args.AddToTail( waitAndRestartExe ); + args.AddToTail( strSeconds ); + args.AddToTail( g_BaseAppPath ); + args.AddToTail( serviceUIExe ); + BuildCommandLineFromArgs( args, commandLine, sizeof( commandLine ) ); + data.AddMultipleToTail( V_strlen( commandLine ) + 1, commandLine ); + + if ( g_pConnMgr ) + { + g_pConnMgr->SendPacket( -1, data.Base(), data.Count() ); + Sleep( 1000 ); // Make sure this packet goes out. + } +} + + +// Returns true if the service was just patched and should exit. +bool CheckDownloaderFinished() +{ + if ( !g_Waiting_hProcess ) + return false; + + // Check if the downloader has timed out and kill it if necessary. + if ( Plat_FloatTime() - g_Waiting_StartTime > MAX_DOWNLOADER_TIME_ALLOWED ) + { + TerminateProcess( g_Waiting_hProcess, 1 ); + CloseHandle( g_Waiting_hProcess ); + g_Waiting_hProcess = NULL; + return false; + } + + // Check if it's done. + if ( WaitForSingleObject( g_Waiting_hProcess, 0 ) != WAIT_OBJECT_0 ) + return false; + + CloseHandle( g_Waiting_hProcess ); + g_Waiting_hProcess = NULL; + + // Ok, it's done. Did it finish successfully? + char testFilename[MAX_PATH]; + V_ComposeFileName( g_FileCachePath, "ReadyToGo.txt", testFilename, sizeof( testFilename ) ); + if ( _access( testFilename, 0 ) != 0 ) + return false; + + // Ok, the downloader finished successfully. Run the worker app. + if ( g_bSuperDebugMode ) + AdjustSuperDebugArgs( g_Waiting_Argv ); + + // Figure out the name of the master machine. + V_strncpy( g_CurMasterName, "<unknown>", sizeof( g_CurMasterName ) ); + for ( int iArg=1; iArg < g_Waiting_Argv.Count()-1; iArg++ ) + { + if ( stricmp( g_Waiting_Argv[iArg], "-mpi_MasterName" ) == 0 ) + { + Q_strncpy( g_CurMasterName, g_Waiting_Argv[iArg+1], sizeof( g_CurMasterName ) ); + } + } + + char DLLFilename[MAX_PATH]; + if ( FindArg( __argc, __argv, "-TryDLLMode" ) && + g_RunMode == RUNMODE_CONSOLE && + GetDLLFilename( g_Waiting_Argv, DLLFilename ) && + !g_Waiting_bPatching ) + { + // This is just a helper for debugging. If it's VRAD, we can run it + // in-process as a DLL instead of running it as a separate EXE. + RunInDLL( DLLFilename, g_Waiting_Argv ); + } + else + { + // Run the (hopefully!) MPI app they specified. + RunProcessAtCommandLine( g_Waiting_Argv, g_Waiting_bShowAppWindow, g_Waiting_bPatching, g_Waiting_Priority ); + + if ( g_Waiting_bPatching ) + { + // Tell any currently-running UI apps to patch themselves and quit ASAP so the installer can finish. + SendPatchCommandToUIs( g_dwRunningProcessId ); + + ResumeThread( g_hRunningThread ); // We started the installer suspended so we could make sure we'd send out the patch command. + + // We just ran the installer, but let's forget about it, otherwise we'll kill its process when we exit here. + CloseHandle( g_hRunningProcess ); + CloseHandle( g_hRunningThread ) ; + g_hRunningProcess = g_hRunningThread = NULL; + g_RunningProcess_ExeName[0] = 0; + g_RunningProcess_MapName[0] = 0; + + ServiceHelpers_ExitEarly(); + return true; + } + } + + g_Waiting_Argv.PurgeAndDeleteElements(); + return false; +} + + +void HandlePacket_LOOKING_FOR_WORKERS( bf_read &buf, const CIPAddr &ipFrom ) +{ + // If we're downloading files for a job request, don't process any more "looking for workers" packets. + if ( g_Waiting_hProcess ) + return; + + // This will be a nonzero-length string if patching. + char versionString[512]; + buf.ReadString( versionString, sizeof( versionString ) ); + + int iPort = buf.ReadShort(); + int iPriority = buf.ReadShort(); + + // Make sure we don't run the same job more than once. + if ( !CheckJobID( buf, g_CurJobID ) ) + return; + + CUtlVector<char*> newArgv; + GetArgsFromBuffer( buf, newArgv, &g_Waiting_bShowAppWindow ); + + bool bForcePatch = false; + if ( buf.GetNumBytesLeft() >= 1 ) + bForcePatch = (buf.ReadByte() != 0); + + int iDownloaderPort = iPort; + if ( buf.GetNumBytesLeft() >= 2 ) + iDownloaderPort = buf.ReadShort(); + + // Add these arguments after the executable filename to tell the program + // that it's an MPI worker and who to connect to. + char strDownloaderIP[128], strMainIP[128]; + V_snprintf( strDownloaderIP, sizeof( strDownloaderIP ), "%d.%d.%d.%d:%d", ipFrom.ip[0], ipFrom.ip[1], ipFrom.ip[2], ipFrom.ip[3], iDownloaderPort ); + V_snprintf( strMainIP, sizeof( strMainIP ), "%d.%d.%d.%d:%d", ipFrom.ip[0], ipFrom.ip[1], ipFrom.ip[2], ipFrom.ip[3], iPort ); + + // (-mpi is already on the command line of whoever ran the app). + // AppendArg( commandLine, sizeof( commandLine ), "-mpi" ); + newArgv.InsertAfter( 0, CopyString( "-mpi_worker" ) ); + newArgv.InsertAfter( 1, CopyString( strDownloaderIP ) ); + + + // If the version string is set, then this is a patch. + bool bPatching = false; + if ( versionString[0] != 0 ) + { + bPatching = true; + + // Check that we haven't applied this patch version yet. This case usually happens right after we've applied a patch + // and we're restarting. The vmpi_transfer master is still pinging us telling us to patch, but we don't want to + // reapply this patch. + if ( atof( versionString ) <= atof( g_VersionString ) && !bForcePatch ) + { + newArgv.PurgeAndDeleteElements(); + return; + } + + // Ok, it's a new version. Get rid of whatever was running before. + KillRunningProcess( "Starting a patch..", true ); + } + + // If there's already a job running, only interrupt it if this new one has a higher priority. + if ( WaitForProcessToExit() ) + { + if ( iPriority > g_CurJobPriority ) + { + KillRunningProcess( "Interrupted by a higher priority process", true ); + } + else + { + // This means we're already running a job with equal to or greater priority than + // the one that has been requested. We're going to ignore this request. + newArgv.PurgeAndDeleteElements(); + return; + } + } + + // Responses go here. + g_CurRespondAddr = ipFrom; + + // Also look for -mpi_ShowAppWindow in the args to the service. + if ( !g_Waiting_bShowAppWindow && FindArg( __argc, __argv, "-mpi_ShowAppWindow" ) ) + g_Waiting_bShowAppWindow = true; + + // Copy all the files from the master and put them in our cache dir to run with. + char cacheDir[MAX_PATH]; + if ( StartDownloadingAppFiles( newArgv, cacheDir, sizeof( cacheDir ), g_Waiting_bShowAppWindow, &g_Waiting_hProcess, bPatching ) ) + { + // After it's downloaded, we want it to switch to the main connection port. + if ( newArgv.Count() >= 3 && V_stricmp( newArgv[2], strDownloaderIP ) == 0 ) + { + delete newArgv[2]; + newArgv[2] = CopyString( strMainIP ); + } + + g_Waiting_StartTime = Plat_FloatTime(); + g_Waiting_Argv.PurgeAndDeleteElements(); + g_Waiting_Argv = newArgv; + g_Waiting_Priority = iPriority; + g_Waiting_bPatching = bPatching; + newArgv.Purge(); + } + else + { + newArgv.PurgeAndDeleteElements(); + } + + // Remember that we tried to run this job so we don't try to run it again. + AddJobMemory( g_CurJobID ); + + SendStateToServicesBrowsers(); +} + + +void HandlePacket_STOP_SERVICE( bf_read &buf, const CIPAddr &ipFrom ) +{ + Msg( "Got a STOP_SERVICE packet. Shutting down...\n" ); + + CWaitTimer timer( 1 ); + while ( 1 ) + { + AddServicesBrowserIP( ipFrom ); + SendStateToServicesBrowsers(); + + if ( timer.ShouldKeepWaiting() ) + Sleep( 200 ); + else + break; + } + + StopUI(); + ServiceHelpers_ExitEarly(); +} + + +void HandlePacket_KILL_PROCESS( const CIPAddr *ipFrom ) +{ + if ( Plat_FloatTime() - g_flLastKillProcessTime > 5 ) + { + KillRunningProcess( "Got a KILL_PROCESS packet. Stopping the worker executable.\n", true ); + + if ( ipFrom ) + { + AddServicesBrowserIP( *ipFrom ); + SendStateToServicesBrowsers(); + } + + g_flLastKillProcessTime = Plat_FloatTime(); + } +} + + +void HandlePacket_FORCE_PASSWORD_CHANGE( bf_read &buf, const CIPAddr &ipFrom ) +{ + char newPassword[512]; + buf.ReadString( newPassword, sizeof( newPassword ) ); + + Msg( "Got a FORCE_PASSWORD_CHANGE (%s) packet.\n", newPassword ); + + SetPassword( newPassword ); + if ( g_pConnMgr ) + g_pConnMgr->SendCurStateTo( -1 ); +} + + +void VMPI_Waiter_Update() +{ + CheckScreensaverRunning(); + HandleWindowMessages(); + UpdateServicesBrowserIPs(); + + while ( 1 ) + { + WaitForProcessToExit(); + if ( CheckDownloaderFinished() ) + return; + + // Recv off the socket first so it clears the queue while we're waiting for the process to exit. + char data[4096]; + CIPAddr ipFrom; + int len = g_pSocket->RecvFrom( data, sizeof( data ), &ipFrom ); + + // Any incoming packets? + if ( len <= 0 ) + break; + + bf_read buf( data, len ); + if ( buf.ReadByte() != VMPI_PROTOCOL_VERSION ) + continue; + + // Only handle packets with the right password. + char pwString[256]; + buf.ReadString( pwString, sizeof( pwString ) ); + + int packetID = buf.ReadByte(); + + if ( pwString[0] == VMPI_PASSWORD_OVERRIDE ) + { + // Always process these packets regardless of the password (these usually come from + // the installer when it is trying to stop a previously-running instance). + } + else if ( packetID == VMPI_LOOKING_FOR_WORKERS ) + { + if ( pwString[0] == 0 ) + { + if ( g_pPassword && g_pPassword[0] != 0 ) + continue; + } + else + { + if ( !g_pPassword || stricmp( g_pPassword, pwString ) != 0 ) + continue; + } + } + + // VMPI_KILL_PROCESS is checked before everything. + if ( packetID == VMPI_KILL_PROCESS ) + { + HandlePacket_KILL_PROCESS( &ipFrom ); + } + else if ( packetID == VMPI_PING_REQUEST ) + { + AddServicesBrowserIP( ipFrom ); + SendStateToServicesBrowsers(); + } + else if ( packetID == VMPI_STOP_SERVICE ) + { + HandlePacket_STOP_SERVICE( buf, ipFrom ); + return; + } + else if ( packetID == VMPI_SERVICE_PATCH ) + { + // The key to doing this here is that we ignore whether we're disabled or in screensaver mode.. we always handle + // the patch command (unless we've already handled this job ID OR if we've already applied this patch version). + HandlePacket_LOOKING_FOR_WORKERS( buf, ipFrom ); + } + else if ( packetID == VMPI_FORCE_PASSWORD_CHANGE ) + { + HandlePacket_FORCE_PASSWORD_CHANGE( buf, ipFrom ); + } + + // If they've told us not to wait for jobs, then ignore the packet. + if ( g_iCurState == VMPI_SERVICE_STATE_DISABLED || (g_bScreensaverMode && !g_bScreensaverRunning) ) + continue; + + if ( packetID == VMPI_LOOKING_FOR_WORKERS ) + { + HandlePacket_LOOKING_FOR_WORKERS( buf, ipFrom ); + } + } +} + + +// ------------------------------------------------------------------------------------------------ // +// Startup and service code. +// ------------------------------------------------------------------------------------------------ // + +void RunMainLoop() +{ + // This is the service's main loop. + while ( 1 ) + { + // If the service has been told to exit, then just exit. + if ( ServiceHelpers_ShouldExit() ) + break; + + VMPI_Waiter_Update(); + g_pConnMgr->Update(); + + Sleep( 50 ); + } +} + + +void InternalRunService() +{ + if ( !VMPI_Waiter_Init() ) + return; + + RunMainLoop(); + VMPI_Waiter_Term(); +} + + +// This function runs us as a console app. Useful for debugging or if you want to run more +// than one instance of VRAD on the same machine. +void RunAsNonServiceApp() +{ + InternalRunService(); +} + + +// This function runs inside the service thread. +void ServiceThreadFn( void *pParam ) +{ + InternalRunService(); +} + + +// This function works with the service manager and runs as a system service. +void RunService() +{ + if( !ServiceHelpers_StartService( VMPI_SERVICE_NAME_INTERNAL, ServiceThreadFn, NULL ) ) + { + Msg( "Service manager not started. Running as console app.\n" ); + g_RunMode = RUNMODE_CONSOLE; + InternalRunService(); + } +} + +int APIENTRY WinMain(HINSTANCE hInstance, + HINSTANCE hPrevInstance, + LPSTR lpCmdLine, + int nCmdShow) +{ + // Hook spew output. + SpewOutputFunc( MySpewOutputFunc ); + + // Get access to the registry.. + RegCreateKey( HKEY_LOCAL_MACHINE, VMPI_SERVICE_KEY, &g_hVMPIServiceKey ); + + // Setup our version string. + LoadString( hInstance, VMPI_SERVICE_IDS_VERSION_STRING, g_VersionString, sizeof( g_VersionString ) ); + + // Setup the base app path. + if ( !GetModuleFileName( GetModuleHandle( NULL ), g_BaseAppPath, sizeof( g_BaseAppPath ) ) ) + { + Warning( "GetModuleFileName failed.\n" ); + return false; + } + V_StripLastDir( g_BaseAppPath, sizeof( g_BaseAppPath ) ); + + // Setup the cache path. + V_ComposeFileName( g_BaseAppPath, "vmpi_service_cache", g_FileCachePath, sizeof( g_FileCachePath ) ); + + + const char *pArg = FindArg( __argc, __argv, "-mpi_pw", NULL ); + SetPassword( pArg ); + + if ( FindArg( __argc, __argv, "-console" ) ) + { + g_RunMode = RUNMODE_CONSOLE; + } + else + { + g_RunMode = RUNMODE_SERVICE; + } + + if ( FindArg( __argc, __argv, "-superdebug" ) ) + g_bSuperDebugMode = true; + + g_AppStartTime = GetTickCount(); + g_bMinimized = FindArg( __argc, __argv, "-minimized" ) != NULL; + + ServiceHelpers_Init(); + g_hInstance = hInstance; + + LoadStateFromRegistry(); + + // Install the service? + if ( g_RunMode == RUNMODE_CONSOLE ) + { + RunAsNonServiceApp(); + } + else + { + RunService(); + } + + return 0; +} + diff --git a/utils/vmpi/vmpi_service/vmpi_service.h b/utils/vmpi/vmpi_service/vmpi_service.h new file mode 100644 index 0000000..17c8178 --- /dev/null +++ b/utils/vmpi/vmpi_service/vmpi_service.h @@ -0,0 +1,19 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// + +#if !defined(AFX_VMPI_SERVICE_H__0EE084DB_9164_4DC2_9E95_CF25D32AAA7B__INCLUDED_) +#define AFX_VMPI_SERVICE_H__0EE084DB_9164_4DC2_9E95_CF25D32AAA7B__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#include "resource.h" + + +#endif // !defined(AFX_VMPI_SERVICE_H__0EE084DB_9164_4DC2_9E95_CF25D32AAA7B__INCLUDED_) diff --git a/utils/vmpi/vmpi_service/vmpi_service.rc b/utils/vmpi/vmpi_service/vmpi_service.rc new file mode 100644 index 0000000..bb7debf --- /dev/null +++ b/utils/vmpi/vmpi_service/vmpi_service.rc @@ -0,0 +1,74 @@ +// Microsoft Visual C++ generated resource script. +// +#include "resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#include "afxres.h" + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +// English (U.S.) resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +#ifdef _WIN32 +LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US +#pragma code_page(1252) +#endif //_WIN32 + +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE +BEGIN + "resource.h\0" +END + +2 TEXTINCLUDE +BEGIN + "#include ""afxres.h""\r\n" + "\0" +END + +3 TEXTINCLUDE +BEGIN + "\r\n" + "\0" +END + +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// String Table +// + +STRINGTABLE +BEGIN + IDS_VERSION_STRING "3.3" +END + +#endif // English (U.S.) resources +///////////////////////////////////////////////////////////////////////////// + + + +#ifndef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 3 resource. +// + + +///////////////////////////////////////////////////////////////////////////// +#endif // not APSTUDIO_INVOKED + diff --git a/utils/vmpi/vmpi_service/vmpi_service.vpc b/utils/vmpi/vmpi_service/vmpi_service.vpc new file mode 100644 index 0000000..7c5d4ba --- /dev/null +++ b/utils/vmpi/vmpi_service/vmpi_service.vpc @@ -0,0 +1,60 @@ +//----------------------------------------------------------------------------- +// VMPI_SERVICE.VPC +// +// Project Script +//----------------------------------------------------------------------------- + +$Macro SRCDIR "..\..\.." +$Macro OUTBINDIR "$SRCDIR\..\game\bin" + +$Include "$SRCDIR\vpc_scripts\source_exe_base.vpc" + +$Configuration +{ + $Compiler + { + $AdditionalIncludeDirectories "$BASE,..\..\common,..\" + $PreprocessorDefinitions "$BASE;PROTECTED_THINGS_DISABLE" + } + + $Linker + { + $AdditionalDependencies "$BASE pdh.lib ws2_32.lib odbc32.lib odbccp32.lib" + } +} + +$Project "Vmpi_service" +{ + $Folder "Source Files" + { + $File "..\iphelpers.cpp" + $File "service_conn_mgr.cpp" + $File "service_helpers.cpp" + $File "perf_counters.cpp" + $File "vmpi_service.rc" + $File "StdAfx.cpp" + $File "..\tcpsocket_helpers.cpp" + $File "..\ThreadedTCPSocket.cpp" + $File "..\ThreadedTCPSocketEmu.cpp" + $File "..\threadhelpers.cpp" + $File "vmpi_service.cpp" + } + + $Folder "Header Files" + { + $File "service_conn_mgr.h" + $File "service_helpers.h" + $File "perf_counters.h" + $File "StdAfx.h" + $File "resource.h" + $File "vmpi_service.h" + } + + $Folder "Resource Files" + { + $File "..\vmpi_service_ui\idi_busy_icon.ico" + $File "..\vmpi_service_ui\idi_disabled_icon.ico" + $File "..\vmpi_service_ui\idi_waiting_icon.ico" + $File "..\vmpi_service_ui\vmpi_service.ico" + } +} diff --git a/utils/vmpi/vmpi_service_install/ServiceInstallDlg.cpp b/utils/vmpi/vmpi_service_install/ServiceInstallDlg.cpp new file mode 100644 index 0000000..6a22176 --- /dev/null +++ b/utils/vmpi/vmpi_service_install/ServiceInstallDlg.cpp @@ -0,0 +1,1043 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// JobWatchDlg.cpp : implementation file +// + +#include "stdafx.h" +#include "ServiceInstallDlg.h" +#include "tier1/strtools.h" + + +#define DEFAULT_INSTALL_LOCATION "C:\\Program Files\\Valve\\vmpi_service" + +#define HLKM_WINDOWS_RUN_KEY "Software\\Microsoft\\Windows\\CurrentVersion\\Run" +#define VMPI_SERVICE_VALUE_NAME "VMPI Service" +#define VMPI_SERVICE_UI_VALUE_NAME "VMPI Service UI" + +// These are the files required for installation. +char *g_pInstallFiles[] = +{ + "vmpi_service.exe", + "vmpi_service_ui.exe", + "WaitAndRestart.exe", + "vmpi_service_install.exe", + "tier0.dll", + "vmpi_transfer.exe", + "filesystem_stdio.dll", + "vstdlib.dll" +}; + + +#ifdef _DEBUG +#define new DEBUG_NEW +#undef THIS_FILE +static char THIS_FILE[] = __FILE__; +#endif + + +HWND g_hMessageControl = NULL; +HKEY g_hVMPIKey = NULL; // hklm/software/valve/vmpi. +bool g_bNoOutput = false; +bool g_bDontTouchUI = false; +bool g_bReinstalling = false; + +FILE *g_fpLog = NULL; + + +char* FindArg( int argc, char **argv, const char *pArgName, char *pDefaultValue="" ) +{ + for ( int i=0; i < argc; i++ ) + { + if ( stricmp( argv[i], pArgName ) == 0 ) + { + if ( (i+1) >= argc ) + return pDefaultValue; + else + return argv[i+1]; + } + } + return NULL; +} + +void CloseLog() +{ + if ( g_fpLog ) + { + fflush( g_fpLog ); + fclose( g_fpLog ); + flushall(); + g_fpLog = NULL; + } +} + +void OpenLog() +{ + CloseLog(); + g_fpLog = fopen( "c:\\vmpi_service_install.log", "wt" ); +} + + +void AddToLog( const char *pMsg ) +{ + if ( g_fpLog ) + { + fprintf( g_fpLog, "%s", pMsg ); + } +} + + +SpewRetval_t MySpewOutputFunc( SpewType_t spewType, const tchar *pMsg ) +{ + AddToLog( pMsg ); + + if ( spewType == SPEW_MESSAGE || spewType == SPEW_WARNING ) + { + // Format the message and send it to the control. + CUtlVector<char> msg; + msg.SetSize( V_strlen( pMsg )*2 + 1 ); + + char *pOut = msg.Base(); + const char *pIn = pMsg; + while ( *pIn ) + { + if ( *pIn == '\n' ) + { + *pOut++ = '\r'; + *pOut++ = '\n'; + } + else + { + *pOut++ = *pIn; + } + ++pIn; + } + *pOut = 0; + + int nLen = (int)SendMessage( g_hMessageControl, EM_GETLIMITTEXT, 0, 0 ); + SendMessage( g_hMessageControl, EM_SETSEL, nLen, nLen ); + SendMessage( g_hMessageControl, EM_REPLACESEL, FALSE, (LPARAM)msg.Base() ); + } + + // Show a message box for warnings and errors. + if ( spewType == SPEW_ERROR || spewType == SPEW_WARNING ) + { + if ( !g_bNoOutput ) + AfxMessageBox( pMsg, MB_OK ); + } + + if ( spewType == SPEW_ERROR ) + { + CloseLog(); + TerminateProcess( GetCurrentProcess(), 2 ); + } + + return SPEW_CONTINUE; +} + + +void ScanDirectory( const char *pDirName, CUtlVector<CString> &subDirs, CUtlVector<CString> &files ) +{ + subDirs.Purge(); + files.Purge(); + + char strPattern[MAX_PATH]; + V_ComposeFileName( pDirName, "*.*", strPattern, sizeof( strPattern ) ); + + WIN32_FIND_DATA fileInfo; // File information + HANDLE hFile = ::FindFirstFile( strPattern, &fileInfo ); + if ( hFile == INVALID_HANDLE_VALUE ) + return; + + do + { + if ( fileInfo.cFileName[0] == '.' ) + continue; + + if ( fileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) + subDirs.AddToTail( fileInfo.cFileName ); + else + files.AddToTail( fileInfo.cFileName ); + } while( ::FindNextFile(hFile, &fileInfo) ); + + ::FindClose( hFile ); +} + + +int DeleteDirectory( const char *pRootDir, bool bDeleteSubdirectories, char errorFile[MAX_PATH] ) +{ + errorFile[0] = 0; + + CUtlVector<CString> subDirs, files; + ScanDirectory( pRootDir, subDirs, files ); + + // First nuke any subdirectories. + if ( bDeleteSubdirectories && !g_bReinstalling ) + { + for ( int i=0; i < subDirs.Count(); i++ ) + { + char fullName[MAX_PATH]; + V_ComposeFileName( pRootDir, subDirs[i], fullName, sizeof( fullName ) ); + + // Delete subdirectory + int iRC = DeleteDirectory( fullName, bDeleteSubdirectories, errorFile ); + if ( iRC ) + return iRC; + } + } + + for ( int i=0; i < files.Count(); i++ ) + { + char fullName[MAX_PATH]; + V_ComposeFileName( pRootDir, files[i], fullName, sizeof( fullName ) ); + + // Set file attributes + if ( !SetFileAttributes( fullName, FILE_ATTRIBUTE_NORMAL ) ) + return GetLastError(); + + // Delete file + if ( !DeleteFile( fullName ) ) + { + V_strncpy( errorFile, fullName, MAX_PATH ); + return GetLastError(); + } + } + + if( !g_bReinstalling ) + { + // Set directory attributes + if ( !SetFileAttributes( pRootDir, FILE_ATTRIBUTE_NORMAL ) ) + return GetLastError(); + + // Delete directory + if ( !RemoveDirectory( pRootDir ) ) + return GetLastError(); + } + + return 0; +} + + +bool CreateDirectory_R( const char *pDirName ) +{ + char chPrevDir[MAX_PATH]; + V_strncpy( chPrevDir, pDirName, sizeof( chPrevDir ) ); + if ( V_StripLastDir( chPrevDir, sizeof( chPrevDir ) ) ) + { + if ( V_stricmp( chPrevDir, ".\\" ) != 0 && V_stricmp( chPrevDir, "./" ) != 0 ) + if ( !CreateDirectory_R( chPrevDir ) ) + return false; + } + + if ( _access( pDirName, 0 ) == 0 ) + return true; + + return CreateDirectory( pDirName, NULL ) || GetLastError() == ERROR_ALREADY_EXISTS; +} + + +bool SetupStartMenuSubFolderName( const char *pSubFolderName, char *pOut, int outLen ) +{ + LPITEMIDLIST pidl; + + // Get a pointer to an item ID list that represents the path of a special folder + HRESULT hr = SHGetSpecialFolderLocation(NULL, CSIDL_COMMON_PROGRAMS, &pidl); + if ( hr != S_OK ) + return false; + + // Convert the item ID list's binary representation into a file system path + char szPath[_MAX_PATH]; + BOOL f = SHGetPathFromIDList(pidl, szPath); + + // Free the LPITEMIDLIST they gave us. + LPMALLOC pMalloc; + hr = SHGetMalloc(&pMalloc); + pMalloc->Free(pidl); + pMalloc->Release(); + + if ( f ) + { + V_ComposeFileName( szPath, pSubFolderName, pOut, outLen ); + return true; + } + else + { + return false; + } +} + +bool CreateStartMenuLink( const char *pSubFolderName, const char *pLinkName, const char *pLinkTarget, const char *pArguments ) +{ + char fullFolderName[MAX_PATH]; + if ( !SetupStartMenuSubFolderName( pSubFolderName, fullFolderName, sizeof( fullFolderName ) ) ) + return false; + + // Create the folder if necessary. + if ( !CreateDirectory_R( fullFolderName ) ) + { + Msg( "CreateStartMenuLink failed - can't create directory %s.\n", fullFolderName ); + return false; + } + + IShellLink* psl = NULL; + + // Get a pointer to the IShellLink interface. + bool bRet = false; + CoInitialize( NULL ); + HRESULT hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, reinterpret_cast<void**>(&psl)); + if (SUCCEEDED(hres)) + { + psl->SetPath( pLinkTarget ); // Set the path to the shortcut target + if ( pArguments ) + psl->SetArguments( pArguments ); + + // Query IShellLink for the IPersistFile interface for saving + //the shortcut in persistent storage. + IPersistFile* ppf = NULL; + hres = psl->QueryInterface( IID_IPersistFile, reinterpret_cast<void**>(&ppf) ); + if (SUCCEEDED(hres)) + { + // Setup the filename for the link. + char linkFilename[MAX_PATH]; + V_ComposeFileName( fullFolderName, pLinkName, linkFilename, sizeof( linkFilename ) ); + V_strncat( linkFilename, ".lnk", sizeof( linkFilename ) ); + + // Ensure that the string is ANSI. + WCHAR wsz[MAX_PATH]; + MultiByteToWideChar(CP_ACP, 0, linkFilename, -1, wsz, MAX_PATH); + + // Save the link by calling IPersistFile::Save. + hres = ppf->Save( wsz, TRUE ); + ppf->Release(); + bRet = true; + } + + psl->Release(); + } + CoUninitialize(); + return bRet; +} + + + +char* GetLastErrorString() +{ + static char err[2048]; + + LPVOID lpMsgBuf; + FormatMessage( + FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + GetLastError(), + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language + (LPTSTR) &lpMsgBuf, + 0, + NULL + ); + + strncpy( err, (char*)lpMsgBuf, sizeof( err ) ); + LocalFree( lpMsgBuf ); + + err[ sizeof( err ) - 1 ] = 0; + + return err; +} + + +bool LaunchApp( char *pCommandLine, const char *pBaseDir ) +{ + STARTUPINFO si; + memset( &si, 0, sizeof( si ) ); + si.cb = sizeof( si ); + + PROCESS_INFORMATION pi; + memset( &pi, 0, sizeof( pi ) ); + + return CreateProcess( NULL, pCommandLine, NULL, NULL, FALSE, 0, NULL, pBaseDir, &si, &pi ) != 0; +} + + +bool StartVMPIServiceUI( const char *pInstallLocation ) +{ + if ( g_bDontTouchUI ) + { + Msg( "StartVMPIServiceUI: Ignoring due to -DontTouchUI.\n" ); + return true; + } + + char cmdLine[MAX_PATH]; + V_ComposeFileName( pInstallLocation, "vmpi_service_ui.exe", cmdLine, sizeof( cmdLine ) ); + return LaunchApp( cmdLine, pInstallLocation ); +} + + +bool StartVMPIService( SC_HANDLE hSCManager ) +{ + bool bRet = true; + + // First, get rid of an old service with the same name. + SC_HANDLE hMyService = OpenService( hSCManager, VMPI_SERVICE_NAME_INTERNAL, SERVICE_START ); + if ( hMyService ) + { + if ( StartService( hMyService, NULL, NULL ) ) + { + Msg( "Started!\n" ); + } + else + { + Error( "Can't start the service.\n" ); + bRet = false; + } + } + else + { + Error( "Can't open service: %s\n", VMPI_SERVICE_NAME_INTERNAL ); + bRet = false; + } + + CloseServiceHandle( hMyService ); + return bRet; +} + + +bool StopRunningApp() +{ + if ( g_bDontTouchUI ) + { + Msg( "StopRunningApp: -DontTouchUI was specified, so exiting before stopping the app.\n" ); + return true; + } + + // Send the + ISocket *pSocket = CreateIPSocket(); + if ( pSocket ) + { + if ( pSocket->BindToAny( 0 ) ) + { + CUtlVector<char> protocolVersions; + protocolVersions.AddToTail( VMPI_PROTOCOL_VERSION ); + if ( VMPI_PROTOCOL_VERSION == 5 ) + protocolVersions.AddToTail( 4 ); // We want this installer to kill the previous services too. + + for ( int iProtocolVersion=0; iProtocolVersion < protocolVersions.Count(); iProtocolVersion++ ) + { + char cPacket[4] = + { + protocolVersions[iProtocolVersion], + VMPI_PASSWORD_OVERRIDE, // (force it to accept this message). + 0, + VMPI_STOP_SERVICE + }; + + CIPAddr addr( 127, 0, 0, 1, 0 ); + + for ( int iPort=VMPI_SERVICE_PORT; iPort <= VMPI_LAST_SERVICE_PORT; iPort++ ) + { + addr.port = iPort; + pSocket->SendTo( &addr, cPacket, sizeof( cPacket ) ); + } + } + + // Give it a sec to get the message and shutdown in case we're restarting. + Sleep( 2000 ); + + + // This is the overkill method. If it didn't shutdown gracefully, kill it. + HMODULE hInst = LoadLibrary( "psapi.dll" ); + if ( hInst ) + { + typedef BOOL (WINAPI *EnumProcessesFn)(DWORD *lpidProcess, DWORD cb, DWORD *cbNeeded); + typedef BOOL (WINAPI *EnumProcessModulesFn)(HANDLE hProcess, HMODULE *lphModule, DWORD cb, LPDWORD lpcbNeeded ); + typedef DWORD (WINAPI *GetModuleBaseNameFn)( HANDLE hProcess, HMODULE hModule, LPTSTR lpBaseName, DWORD nSize ); + + EnumProcessesFn EnumProcesses = (EnumProcessesFn)GetProcAddress( hInst, "EnumProcesses" ); + EnumProcessModulesFn EnumProcessModules = (EnumProcessModulesFn)GetProcAddress( hInst, "EnumProcessModules" ); + GetModuleBaseNameFn GetModuleBaseName = (GetModuleBaseNameFn)GetProcAddress( hInst, "GetModuleBaseNameA" ); + if ( EnumProcessModules && EnumProcesses ) + { + // Now just to make sure, kill the processes we're interested in. + DWORD procIDs[1024]; + DWORD nBytes; + if ( EnumProcesses( procIDs, sizeof( procIDs ), &nBytes ) ) + { + DWORD nProcs = nBytes / sizeof( procIDs[0] ); + for ( DWORD i=0; i < nProcs; i++ ) + { + HANDLE hProc = OpenProcess( PROCESS_ALL_ACCESS, FALSE, procIDs[i] ); + if ( hProc ) + { + HMODULE hModules[1024]; + if ( EnumProcessModules( hProc, hModules, sizeof( hModules ), &nBytes ) ) + { + DWORD nModules = nBytes / sizeof( hModules[0] ); + for ( DWORD iModule=0; iModule < nModules; iModule++ ) + { + char filename[512]; + if ( GetModuleBaseName( hProc, hModules[iModule], filename, sizeof( filename ) ) ) + { + if ( Q_stristr( filename, "vmpi_service.exe" ) || Q_stristr( filename, "vmpi_service_ui.exe" ) ) + { + TerminateProcess( hProc, 1 ); + CloseHandle( hProc ); + hProc = NULL; + break; + } + } + } + } + + CloseHandle( hProc ); + } + } + } + } + + FreeLibrary( hInst ); + } + } + + pSocket->Release(); + } + + return true; +} + + +bool StopOrDeleteService( SC_HANDLE hSCManager, bool bDelete ) +{ + bool bRet = true; + + // First, get rid of an old service with the same name. + SC_HANDLE hOldService = OpenService( hSCManager, VMPI_SERVICE_NAME_INTERNAL, SERVICE_STOP | DELETE ); + if ( hOldService ) + { + // Stop the service. + Msg( "Found the service already running.\n" ); + Msg( "Stopping service...\n" ); + SERVICE_STATUS status; + ControlService( hOldService, SERVICE_CONTROL_STOP, &status ); + + if ( bDelete ) + { + Msg( "Deleting service...\n" ); + bool bExitedNicely = false; + DWORD startTime = GetTickCount(); + while ( 1 ) + { + BOOL bRet = DeleteService( hOldService ); + if ( !bRet || bRet == ERROR_SERVICE_MARKED_FOR_DELETE ) + { + Msg( "Deleted old service.\n" ); + bExitedNicely = true; + break; + } + + // Wait for the service to stop for 8 seconds. + if ( GetTickCount() - startTime > 8000 ) + break; + } + + if ( !bExitedNicely ) + { + Error( "Couldn't delete the old '%s' service! Error: %s.\n", VMPI_SERVICE_NAME, GetLastErrorString() ); + bRet = false; + } + } + + CloseServiceHandle( hOldService ); + } + + return bRet; +} + + +bool GetExistingInstallationLocation( CString &strInstallLocation ) +{ + char buf[1024]; + DWORD bufSize = sizeof( buf ); + DWORD dwType; + if ( RegQueryValueEx( g_hVMPIKey, SERVICE_INSTALL_LOCATION_KEY, NULL, &dwType, (LPBYTE)buf, &bufSize ) == ERROR_SUCCESS ) + { + if ( dwType == REG_SZ ) + { + strInstallLocation = buf; + return true; + } + } + + return false; +} + +void RemoveRegistryKeys() +{ + // Delete the run values (that tells it to run the app when the user logs in). + HKEY hKey = NULL; + RegCreateKey( HKEY_LOCAL_MACHINE, HLKM_WINDOWS_RUN_KEY, &hKey ); + RegDeleteValue( hKey, VMPI_SERVICE_VALUE_NAME ); + RegDeleteValue( hKey, VMPI_SERVICE_UI_VALUE_NAME ); + + // Get rid of the "InstallLocation" value. + RegDeleteValue( g_hVMPIKey, SERVICE_INSTALL_LOCATION_KEY ); +} + + +bool IsAnInstallFile( const char *pName ) +{ + for ( int i=0; i < ARRAYSIZE( g_pInstallFiles ); i++ ) + { + if ( V_stricmp( g_pInstallFiles[i], pName ) == 0 ) + return true; + } + return false; +} + + +bool AnyNonInstallFilesInDirectory( const char *strInstallLocation ) +{ + char searchStr[MAX_PATH]; + V_ComposeFileName( strInstallLocation, "*.*", searchStr, sizeof( searchStr ) ); + + _finddata_t data; + long handle = _findfirst( searchStr, &data ); + if ( handle != -1 ) + { + do + { + if ( data.name[0] == '.' || (data.attrib & _A_SUBDIR) != 0 ) + continue; + + if ( !IsAnInstallFile( data.name ) ) + return true; + + } while( _findnext( handle, &data ) == 0 ); + + _findclose( handle ); + } + return false; +} + + +///////////////////////////////////////////////////////////////////////////// +// CServiceInstallDlg dialog + + +CServiceInstallDlg::CServiceInstallDlg(CWnd* pParent /*=NULL*/) + : CDialog(CServiceInstallDlg::IDD, pParent) +{ + //{{AFX_DATA_INIT(CServiceInstallDlg) + // NOTE: the ClassWizard will add member initialization here + //}}AFX_DATA_INIT +} + + +CServiceInstallDlg::~CServiceInstallDlg() +{ +} + + +void CServiceInstallDlg::DoDataExchange(CDataExchange* pDX) +{ + CDialog::DoDataExchange(pDX); + //{{AFX_DATA_MAP(CServiceInstallDlg) + //}}AFX_DATA_MAP +} + + +BEGIN_MESSAGE_MAP(CServiceInstallDlg, CDialog) + //{{AFX_MSG_MAP(CServiceInstallDlg) + ON_BN_CLICKED(IDC_CANCEL_BUTTON, OnCancel) + ON_BN_CLICKED(IDC_INSTALL_BUTTON, OnInstall) + ON_BN_CLICKED(IDC_UNINSTALL_BUTTON2, OnUninstall) + ON_BN_CLICKED(IDC_START_EXISTING_BUTTON, OnStartExisting) + ON_BN_CLICKED(IDC_STOP_EXISTING_BUTTON, OnStopExisting) + //}}AFX_MSG_MAP +END_MESSAGE_MAP() + +///////////////////////////////////////////////////////////////////////////// +// CServiceInstallDlg message handlers + +const char* FindArg( const char *pArgName, const char *pDefault="" ) +{ + for ( int i=1; i < __argc; i++ ) + { + if ( Q_stricmp( pArgName, __argv[i] ) == 0 ) + { + if ( (i+1) < __argc ) + return __argv[i+1]; + else + return pDefault; + } + } + return NULL; +} + + +BOOL CServiceInstallDlg::OnInitDialog() +{ + CDialog::OnInitDialog(); + + HICON hIcon = LoadIcon( AfxGetInstanceHandle(), MAKEINTRESOURCE( IDR_MAINFRAME ) ); + SetIcon( hIcon, true ); + + OpenLog(); + + // Setup the registry key for the install location. + if ( RegCreateKey( HKEY_LOCAL_MACHINE, VMPI_SERVICE_KEY, &g_hVMPIKey ) != ERROR_SUCCESS ) + { + Error( "Can't open registry key: %s.", VMPI_SERVICE_KEY ); + return FALSE; + } + + VerifyInstallFiles(); + + g_hMessageControl = ::GetDlgItem( GetSafeHwnd(), IDC_TEXTOUTPUT ); + SpewOutputFunc( MySpewOutputFunc ); + + // Init the service manager. + m_hSCManager = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS ); + if ( !m_hSCManager ) + { + Error( "OpenSCManager failed (%s)!\n", GetLastErrorString() ); + return FALSE; + } + + + // See if there is a previous installation. + CString strInstallLocation; + if ( GetExistingInstallationLocation( strInstallLocation ) ) + SetDlgItemText( IDC_INSTALL_LOCATION, strInstallLocation ); + else + SetDlgItemText( IDC_INSTALL_LOCATION, DEFAULT_INSTALL_LOCATION ); + + // Now, if they passed in a command line option . + if ( FindArg( __argc, __argv, "-install_quiet" ) ) + { + g_bReinstalling = true; + g_bNoOutput = true; + g_bDontTouchUI = (FindArg( __argc, __argv, "-DontTouchUI", NULL ) != 0); + OnInstall(); + EndDialog( 0 ); + } + else if ( FindArg( __argc, __argv, "-uninstall_quiet" ) ) + { + g_bNoOutput = true; + DoUninstall( false ); + EndDialog( 0 ); + } + else if ( FindArg( __argc, __argv, "-start" ) ) + { + OnStartExisting(); + } + + else if ( FindArg( __argc, __argv, "-stop" ) ) + { + OnStopExisting(); + } + + return TRUE; // return TRUE unless you set the focus to a control + // EXCEPTION: OCX Property Pages should return FALSE +} + + +void CServiceInstallDlg::OnCancel(void) +{ + EndDialog( 1 ); +} + +// This function registers the service with the service manager. +bool InstallService( SC_HANDLE hSCManager, const char *pBaseDir ) +{ + char filename[512], uiFilename[512]; + V_ComposeFileName( pBaseDir, "vmpi_service.exe", filename, sizeof( filename ) ); + V_ComposeFileName( pBaseDir, "vmpi_service_ui.exe", uiFilename, sizeof( uiFilename ) ); + + + // Try a to reinstall the service for up to 5 seconds. + Msg( "Creating new service...\n" ); + + SC_HANDLE hMyService = NULL; + DWORD startTime = GetTickCount(); + while ( GetTickCount() - startTime < 5000 ) + { + // Now reinstall it. + hMyService = CreateService( + hSCManager, // Service Control Manager database. + VMPI_SERVICE_NAME_INTERNAL, // Service name. + VMPI_SERVICE_NAME, // Display name. + SERVICE_ALL_ACCESS, + SERVICE_WIN32_OWN_PROCESS, + SERVICE_AUTO_START, // Start automatically on system bootup. + SERVICE_ERROR_NORMAL, + filename, // Executable to register for the service. + NULL, // no load ordering group + NULL, // no tag identifier + NULL, // no dependencies + NULL, // account + NULL // password + ); + + if ( hMyService ) + break; + else + Sleep( 300 ); + } + + if ( !hMyService ) + { + Warning( "CreateService failed (%s)!\n", GetLastErrorString() ); + CloseServiceHandle( hSCManager ); + return false; + } + + + // Now setup the UI executable to run when their system starts. + HKEY hUIKey = NULL; + RegCreateKey( HKEY_LOCAL_MACHINE, HLKM_WINDOWS_RUN_KEY, &hUIKey ); + if ( !hUIKey || RegSetValueEx( hUIKey, VMPI_SERVICE_UI_VALUE_NAME, 0, REG_SZ, (unsigned char*)uiFilename, strlen( uiFilename) + 1 ) != ERROR_SUCCESS ) + { + Warning( "Can't install registry key for %s\n", uiFilename ); + return false; + } + + CloseServiceHandle( hMyService ); + return true; +} + + +void SetupStartMenuLinks( const char *pInstallerFilename ) +{ + CreateStartMenuLink( "Valve\\VMPI", "Start VMPI Service", pInstallerFilename, "-start" ); + CreateStartMenuLink( "Valve\\VMPI", "Stop VMPI Service", pInstallerFilename, "-stop" ); + CreateStartMenuLink( "Valve\\VMPI", "Uninstall VMPI", pInstallerFilename, NULL ); +} + + +void RemoveStartMenuLinks() +{ + char fullFolderName[MAX_PATH]; + if ( !SetupStartMenuSubFolderName( "Valve\\VMPI", fullFolderName, sizeof( fullFolderName ) ) ) + return; + + char errorFile[MAX_PATH]; + if ( !DeleteDirectory( fullFolderName, true, errorFile ) ) + { + Msg( "Unable to remove Start Menu items in %s.\n", fullFolderName ); + } +} + + +void CServiceInstallDlg::OnInstall() +{ + // Get the install location. + Msg( "Verifying install location.\n" ); + CString strInstallLocation; + if ( !GetDlgItemText( IDC_INSTALL_LOCATION, strInstallLocation ) ) + { + Error( "Can't get install location." ); + return; + } + + if ( strchr( strInstallLocation, ':' ) == NULL ) + { + Warning( "Install location must be an absolute path (include a colon)." ); + return; + } + + // Stop the existing service. + if ( !DoUninstall( false ) ) + return; + + // Create the directory. + Msg( "Creating install directory %s.\n", strInstallLocation ); + if ( !CreateDirectory_R( strInstallLocation ) ) + { + Warning( "Unable to create directory: %s.", (const char*)strInstallLocation ); + return; + } + + // Copy the files down. + Msg( "Copying files.\n" ); + char chDir[MAX_PATH]; + GetModuleFileName( NULL, chDir, sizeof( chDir ) ); + V_StripFilename( chDir ); + for ( int i=0; i < ARRAYSIZE( g_pInstallFiles ); i++ ) + { + char srcFilename[MAX_PATH], destFilename[MAX_PATH]; + V_ComposeFileName( chDir, g_pInstallFiles[i], srcFilename, sizeof( srcFilename ) ); + V_ComposeFileName( strInstallLocation, g_pInstallFiles[i], destFilename, sizeof( destFilename ) ); + + if ( !CopyFile( srcFilename, destFilename, FALSE ) ) + { + Sleep( 2000 ); + + if ( !CopyFile( srcFilename, destFilename, FALSE ) ) + { + Error( "CopyFile() failed.\nSrc: %s\nDest: %s\n%s", srcFilename, destFilename, GetLastErrorString() ); + return; + } + } + } + + // Register the service. + if ( !InstallService( m_hSCManager, strInstallLocation ) ) + return; + + // Write the new location to the registry. + Msg( "Updating registry.\n" ); + if ( RegSetValueEx( g_hVMPIKey, SERVICE_INSTALL_LOCATION_KEY, 0, REG_SZ, (BYTE*)(const char*)strInstallLocation, V_strlen( strInstallLocation ) + 1 ) != ERROR_SUCCESS ) + { + Error( "RegSetValueEx( %s, %s ) failed.", SERVICE_INSTALL_LOCATION_KEY, (const char*)strInstallLocation ); + return; + } + + // Setup start menu links. + char installerFilename[MAX_PATH]; + V_ComposeFileName( strInstallLocation, "vmpi_service_install.exe", installerFilename, sizeof( installerFilename ) ); + SetupStartMenuLinks( installerFilename ); + + // Start the new service. + Msg( "Starting new service.\n" ); + if ( DoStartExisting() ) + { + Warning( "Installed successfully!" ); + } +} + +bool CServiceInstallDlg::DoUninstall( bool bShowMessage ) +{ + // Figure out where to uninstall from. + CString strInstallLocation; + if ( !GetDlgItemText( IDC_INSTALL_LOCATION, strInstallLocation ) ) + { + Error( "Can't get install location." ); + return false; + } + + if ( _access( strInstallLocation, 0 ) == 0 && !g_bNoOutput ) + { + // Don't ask if they care if we delete all the files in that directory if the only exes in there are the install exes. + if ( AnyNonInstallFilesInDirectory( strInstallLocation ) ) + { + char str[512]; + V_snprintf( str, sizeof( str ), "Warning: this will delete all files under this directory: \n%s\nContinue?", strInstallLocation ); + if ( AfxMessageBox( str, MB_YESNO ) != IDYES ) + return false; + } + } + + // Stop both the service and the win app. + bool bDone = StopRunningApp() && StopOrDeleteService( m_hSCManager, true ); + if ( !bDone ) + return false; + + bool bSuccess = true; + RemoveRegistryKeys(); + char errorFile[MAX_PATH]; + if ( !NukeDirectory( strInstallLocation, errorFile ) ) + { + // When reinstalling, the service may not be done exiting, so give it a sec. + Sleep( 2000 ); + if ( !NukeDirectory( strInstallLocation, errorFile ) ) + { + if ( errorFile[0] ) + Msg( "NukeDirectory( %s ) failed.\nError on file: %s\n", strInstallLocation, errorFile ); + else + Msg( "NukeDirectory( %s ) failed.\n", strInstallLocation ); + + Msg( "Uninstall complete, but files are left over in %s.\n", strInstallLocation ); + + bSuccess = false; + } + } + + RemoveStartMenuLinks(); + + if ( bShowMessage && bSuccess ) + AfxMessageBox( "Uninstall successful." ); + + return true; +} + +void CServiceInstallDlg::OnUninstall() +{ + DoUninstall( true ); +} + +void CServiceInstallDlg::OnStartExisting() +{ + if ( DoStartExisting() ) + AfxMessageBox( "Started successfully." ); +} + +bool CServiceInstallDlg::DoStartExisting() +{ + StopRunningApp(); + StopOrDeleteService( m_hSCManager, false ); + + CString strInstallLocation; + if ( !GetExistingInstallationLocation( strInstallLocation ) ) + { + Error( "The VMPI service is not installed." ); + return false; + } + + if ( StartVMPIService( m_hSCManager ) ) + { + return StartVMPIServiceUI( strInstallLocation ); + } + else + { + return false; + } +} + +void CServiceInstallDlg::OnStopExisting() +{ + + // Stop the app but don't delete it. + bool bDone = StopRunningApp() && StopOrDeleteService( m_hSCManager, false ); + if ( bDone ) + { + AfxMessageBox( "Service successfully stopped." ); + } +} + +bool CServiceInstallDlg::NukeDirectory( const char *pDir, char errorFile[MAX_PATH] ) +{ + // If the directory doesn't exist anyways, then return true.. + if ( _access( pDir, 0 ) != 0 ) + return true; + + return DeleteDirectory( pDir, true, errorFile ) == 0; +} + + +void CServiceInstallDlg::VerifyInstallFiles() +{ + char chDir[MAX_PATH]; + GetModuleFileName( NULL, chDir, sizeof( chDir ) ); + V_StripFilename( chDir ); + + for ( int i=0; i < ARRAYSIZE( g_pInstallFiles ); i++ ) + { + char filename[MAX_PATH]; + V_ComposeFileName( chDir, g_pInstallFiles[i], filename, sizeof( filename ) ); + + if ( _access( filename, 0 ) != 0 ) + { + char szErrorMessage[MAX_PATH]; + + V_snprintf( szErrorMessage, sizeof( szErrorMessage ), "Required installation file missing: %s", filename ); + + AfxMessageBox( szErrorMessage ); + return; + } + } +} + diff --git a/utils/vmpi/vmpi_service_install/ServiceInstallDlg.h b/utils/vmpi/vmpi_service_install/ServiceInstallDlg.h new file mode 100644 index 0000000..01dc433 --- /dev/null +++ b/utils/vmpi/vmpi_service_install/ServiceInstallDlg.h @@ -0,0 +1,72 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +#if !defined(AFX_SERVICEINSTALLDLG_H__761BDEEF_D549_4F10_817C_1C1FAF9FCA47__INCLUDED_) +#define AFX_SERVICEINSTALLDLG_H__761BDEEF_D549_4F10_817C_1C1FAF9FCA47__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 +// JobWatchDlg.h : header file +// + + +#include "resource.h" +#include "tier1/utlvector.h" + + + +///////////////////////////////////////////////////////////////////////////// +// CJobWatchDlg dialog + +class CServiceInstallDlg : public CDialog +{ +// Construction +public: + CServiceInstallDlg( CWnd* pParent = NULL); // standard constructor + virtual ~CServiceInstallDlg(); + +// Dialog Data + //{{AFX_DATA(CJobWatchDlg) + enum { IDD = IDD_SERVICE_INSTALL_DIALOG}; + //}}AFX_DATA + + +// Overrides + // ClassWizard generated virtual function overrides + //{{AFX_VIRTUAL(CJobWatchDlg) + protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support + //}}AFX_VIRTUAL + +// Implementation +protected: + + SC_HANDLE m_hSCManager; + + void VerifyInstallFiles(); + + bool DoStartExisting(); + bool NukeDirectory( const char *pDir, char errorFile[MAX_PATH] ); + bool DoUninstall( bool bShowMessage ); + + // Generated message map functions + //{{AFX_MSG(CJobWatchDlg) + virtual BOOL OnInitDialog(); + virtual void OnCancel(); + virtual void OnInstall(); + virtual void OnUninstall(); + virtual void OnStartExisting(); + virtual void OnStopExisting(); + //}}AFX_MSG + DECLARE_MESSAGE_MAP() +}; + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_SERVICEINSTALLDLG_H__761BDEEF_D549_4F10_817C_1C1FAF9FCA47__INCLUDED_) diff --git a/utils/vmpi/vmpi_service_install/StdAfx.cpp b/utils/vmpi/vmpi_service_install/StdAfx.cpp new file mode 100644 index 0000000..e10b100 --- /dev/null +++ b/utils/vmpi/vmpi_service_install/StdAfx.cpp @@ -0,0 +1,15 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// stdafx.cpp : source file that includes just the standard includes +// vmpi_service_install.pch will be the pre-compiled header +// stdafx.obj will contain the pre-compiled type information + +#include "stdafx.h" + +// TODO: reference any additional headers you need in STDAFX.H +// and not in this file diff --git a/utils/vmpi/vmpi_service_install/StdAfx.h b/utils/vmpi/vmpi_service_install/StdAfx.h new file mode 100644 index 0000000..d243112 --- /dev/null +++ b/utils/vmpi/vmpi_service_install/StdAfx.h @@ -0,0 +1,41 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, but +// are changed infrequently +// + +#if !defined(AFX_STDAFX_H__E8FBDA6A_CE57_4416_8329_90155CD6CEC3__INCLUDED_) +#define AFX_STDAFX_H__E8FBDA6A_CE57_4416_8329_90155CD6CEC3__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers + +#include "tier0/basetypes.h" + +#include <afxwin.h> // MFC core and standard components +#include <afxext.h> // MFC extensions +#include <afxdisp.h> // MFC Automation classes +#include <afxdtctl.h> // MFC support for Internet Explorer 4 Common Controls +#ifndef _AFX_NO_AFXCMN_SUPPORT +#include <afxcmn.h> // MFC support for Windows Common Controls +#endif // _AFX_NO_AFXCMN_SUPPORT + +#include <winsvc.h> +#include <io.h> + +#include "iphelpers.h" +#include "vmpi.h" + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_STDAFX_H__E8FBDA6A_CE57_4416_8329_90155CD6CEC3__INCLUDED_) diff --git a/utils/vmpi/vmpi_service_install/res/vmpi.ico b/utils/vmpi/vmpi_service_install/res/vmpi.ico Binary files differnew file mode 100644 index 0000000..24dc2cf --- /dev/null +++ b/utils/vmpi/vmpi_service_install/res/vmpi.ico diff --git a/utils/vmpi/vmpi_service_install/res/vmpi_service_install.ico b/utils/vmpi/vmpi_service_install/res/vmpi_service_install.ico Binary files differnew file mode 100644 index 0000000..7eef0bc --- /dev/null +++ b/utils/vmpi/vmpi_service_install/res/vmpi_service_install.ico diff --git a/utils/vmpi/vmpi_service_install/res/vmpi_service_install.rc2 b/utils/vmpi/vmpi_service_install/res/vmpi_service_install.rc2 new file mode 100644 index 0000000..6e93fd0 --- /dev/null +++ b/utils/vmpi/vmpi_service_install/res/vmpi_service_install.rc2 @@ -0,0 +1,13 @@ +// +// VMPI_BROWSER_JOB_WATCH.RC2 - resources Microsoft Visual C++ does not edit directly +// + +#ifdef APSTUDIO_INVOKED + #error this file is not editable by Microsoft Visual C++ +#endif //APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// Add manually edited resources here... + +///////////////////////////////////////////////////////////////////////////// diff --git a/utils/vmpi/vmpi_service_install/resource.h b/utils/vmpi/vmpi_service_install/resource.h new file mode 100644 index 0000000..9330dcb --- /dev/null +++ b/utils/vmpi/vmpi_service_install/resource.h @@ -0,0 +1,27 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +//{{NO_DEPENDENCIES}} +// Microsoft Visual C++ generated include file. +// Used by vmpi_service_install.rc +// +#define IDD_SERVICE_INSTALL_DIALOG 102 +#define IDR_MAINFRAME 128 +#define IDD_SERVICE_INSTALL 135 +#define IDC_TEXTOUTPUT 200 +#define IDC_COMMAND_LINE 201 +#define IDC_INSTALL_LOCATION 201 +#define IDC_INSTALL_BUTTON 1011 +#define IDC_CANCEL_BUTTON 1012 +#define IDC_UNINSTALL_BUTTON2 1013 +#define IDC_START_EXISTING_BUTTON 1014 +#define IDC_STOP_EXISTING_BUTTON 1015 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 131 +#define _APS_NEXT_COMMAND_VALUE 32771 +#define _APS_NEXT_CONTROL_VALUE 1012 +#define _APS_NEXT_SYMED_VALUE 101 +#endif +#endif diff --git a/utils/vmpi/vmpi_service_install/vmpi_service_install.cpp b/utils/vmpi/vmpi_service_install/vmpi_service_install.cpp new file mode 100644 index 0000000..f366efa --- /dev/null +++ b/utils/vmpi/vmpi_service_install/vmpi_service_install.cpp @@ -0,0 +1,75 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// vmpi_browser_job_watch.cpp : Defines the class behaviors for the application. +// + +#include "stdafx.h" +#include "vmpi_service_install.h" +#include "ServiceInstallDlg.h" + +#ifdef _DEBUG +#define new DEBUG_NEW +#undef THIS_FILE +static char THIS_FILE[] = __FILE__; +#endif + +///////////////////////////////////////////////////////////////////////////// +// CServiceInstallApp + +BEGIN_MESSAGE_MAP(CServiceInstallApp, CWinApp) + //{{AFX_MSG_MAP(CServiceInstallApp) + // NOTE - the ClassWizard will add and remove mapping macros here. + // DO NOT EDIT what you see in these blocks of generated code! + //}}AFX_MSG + ON_COMMAND(ID_HELP, CWinApp::OnHelp) +END_MESSAGE_MAP() + +///////////////////////////////////////////////////////////////////////////// +// CServiceInstallApp construction + +CServiceInstallApp::CServiceInstallApp() +{ + // TODO: add construction code here, + // Place all significant initialization in InitInstance +} + +///////////////////////////////////////////////////////////////////////////// +// The one and only CServiceInstallApp object + +CServiceInstallApp theApp; + +///////////////////////////////////////////////////////////////////////////// +// CServiceInstallApp initialization + +BOOL CServiceInstallApp::InitInstance() +{ + AfxEnableControlContainer(); + + // Standard initialization + // If you are not using these features and wish to reduce the size + // of your final executable, you should remove from the following + // the specific initialization routines you do not need. + + CServiceInstallDlg dlg; + m_pMainWnd = &dlg; + int nResponse = dlg.DoModal(); + if (nResponse == IDOK) + { + // TODO: Place code here to handle when the dialog is + // dismissed with OK + } + else if (nResponse == IDCANCEL) + { + // TODO: Place code here to handle when the dialog is + // dismissed with Cancel + } + + // Since the dialog has been closed, return FALSE so that we exit the + // application, rather than start the application's message pump. + return FALSE; +} diff --git a/utils/vmpi/vmpi_service_install/vmpi_service_install.h b/utils/vmpi/vmpi_service_install/vmpi_service_install.h new file mode 100644 index 0000000..e29f338 --- /dev/null +++ b/utils/vmpi/vmpi_service_install/vmpi_service_install.h @@ -0,0 +1,56 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// vmpi_browser_job_watch.h : main header file for the VMPI_BROWSER_JOB_WATCH application +// + +#if !defined(AFX_VMPI_SERVICE_INSTALL_H__1DF22047_F615_4799_913A_222E3701BE5E__INCLUDED_) +#define AFX_VMPI_SERVICE_INSTALL_H__1DF22047_F615_4799_913A_222E3701BE5E__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#ifndef __AFXWIN_H__ + #error include 'stdafx.h' before including this file for PCH +#endif + +#include "resource.h" // main symbols + +///////////////////////////////////////////////////////////////////////////// +// CVMPIBrowserJobWatchApp: +// See vmpi_browser_job_watch.cpp for the implementation of this class +// + +class CServiceInstallApp : public CWinApp +{ +public: + CServiceInstallApp(); + +// Overrides + // ClassWizard generated virtual function overrides + //{{AFX_VIRTUAL(CVMPIBrowserJobWatchApp) + public: + virtual BOOL InitInstance(); + //}}AFX_VIRTUAL + +// Implementation + + //{{AFX_MSG(CVMPIBrowserJobWatchApp) + // NOTE - the ClassWizard will add and remove member functions here. + // DO NOT EDIT what you see in these blocks of generated code ! + //}}AFX_MSG + DECLARE_MESSAGE_MAP() +}; + + +///////////////////////////////////////////////////////////////////////////// + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_VMPI_SERVICE_INSTALL_H__1DF22047_F615_4799_913A_222E3701BE5E__INCLUDED_) diff --git a/utils/vmpi/vmpi_service_install/vmpi_service_install.rc b/utils/vmpi/vmpi_service_install/vmpi_service_install.rc new file mode 100644 index 0000000..f9d59aa --- /dev/null +++ b/utils/vmpi/vmpi_service_install/vmpi_service_install.rc @@ -0,0 +1,173 @@ +// Microsoft Visual C++ generated resource script. +// +#include "resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#include "afxres.h" + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +// English (U.S.) resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +#ifdef _WIN32 +LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US +#pragma code_page(1252) +#endif //_WIN32 + +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE +BEGIN + "resource.h\0" +END + +2 TEXTINCLUDE +BEGIN + "#include ""afxres.h""\r\n" + "\0" +END + +3 TEXTINCLUDE +BEGIN + "#define _AFX_NO_SPLITTER_RESOURCES\r\n" + "#define _AFX_NO_OLE_RESOURCES\r\n" + "#define _AFX_NO_TRACKER_RESOURCES\r\n" + "#define _AFX_NO_PROPERTY_RESOURCES\r\n" + "\r\n" + "#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)\r\n" + "#ifdef _WIN32\r\n" + "LANGUAGE 9, 1\r\n" + "#pragma code_page(1252)\r\n" + "#endif //_WIN32\r\n" + "#include ""res\\vmpi_service_install.rc2"" // non-Microsoft Visual C++ edited resources\r\n" + "#include ""afxres.rc"" // Standard components\r\n" + "#endif\r\n" + "\0" +END + +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// Icon +// + +// Icon with lowest ID value placed first to ensure application icon +// remains consistent on all systems. +IDR_MAINFRAME ICON "res\\vmpi.ico" + +///////////////////////////////////////////////////////////////////////////// +// +// Version +// + +VS_VERSION_INFO VERSIONINFO + FILEVERSION 1,0,0,1 + PRODUCTVERSION 1,0,0,1 + FILEFLAGSMASK 0x3fL +#ifdef _DEBUG + FILEFLAGS 0x1L +#else + FILEFLAGS 0x0L +#endif + FILEOS 0x4L + FILETYPE 0x1L + FILESUBTYPE 0x0L +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904B0" + BEGIN + VALUE "FileDescription", "vmpi_service_install MFC Application" + VALUE "FileVersion", "1, 0, 0, 1" + VALUE "InternalName", "vmpi_service_install" + VALUE "LegalCopyright", "Copyright (C) 2003" + VALUE "OriginalFilename", "vmpi_service_install.EXE" + VALUE "ProductName", "vmpi_service_install Application" + VALUE "ProductVersion", "1, 0, 0, 1" + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 1200 + END +END + + +///////////////////////////////////////////////////////////////////////////// +// +// Dialog +// + +IDD_SERVICE_INSTALL_DIALOG DIALOGEX 0, 0, 467, 366 +STYLE DS_SETFONT | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME +CAPTION "VMPI Service Installer" +FONT 8, "MS Sans Serif", 0, 0, 0x0 +BEGIN + EDITTEXT IDC_INSTALL_LOCATION,69,52,388,14,ES_AUTOHSCROLL + PUSHBUTTON "&Install / Update",IDC_INSTALL_BUTTON,9,78,107,14 + PUSHBUTTON "&Uninstall",IDC_UNINSTALL_BUTTON2,9,103,50,14 + PUSHBUTTON "&Start Existing",IDC_START_EXISTING_BUTTON,66,103,50,14 + PUSHBUTTON "S&top Existing",IDC_STOP_EXISTING_BUTTON,123,103,50,14 + PUSHBUTTON "&Quit",IDC_CANCEL_BUTTON,180,103,50,14 + EDITTEXT IDC_TEXTOUTPUT,9,132,448,224,ES_MULTILINE | ES_READONLY | WS_VSCROLL | WS_HSCROLL + LTEXT "Install Directory:",IDC_STATIC,9,55,51,8 + LTEXT "This application will install the VMPI service onto your local machine.\nPlease enter a location to install it and click the Install button.",IDC_STATIC,15,9,442,36 +END + + +///////////////////////////////////////////////////////////////////////////// +// +// DESIGNINFO +// + +#ifdef APSTUDIO_INVOKED +GUIDELINES DESIGNINFO +BEGIN + IDD_SERVICE_INSTALL_DIALOG, DIALOG + BEGIN + VERTGUIDE, 9 + VERTGUIDE, 457 + END +END +#endif // APSTUDIO_INVOKED + +#endif // English (U.S.) resources +///////////////////////////////////////////////////////////////////////////// + + + +#ifndef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 3 resource. +// +#define _AFX_NO_SPLITTER_RESOURCES +#define _AFX_NO_OLE_RESOURCES +#define _AFX_NO_TRACKER_RESOURCES +#define _AFX_NO_PROPERTY_RESOURCES + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +#ifdef _WIN32 +LANGUAGE 9, 1 +#pragma code_page(1252) +#endif //_WIN32 +#include "res\vmpi_service_install.rc2" // non-Microsoft Visual C++ edited resources +#include "afxres.rc" // Standard components +#endif + +///////////////////////////////////////////////////////////////////////////// +#endif // not APSTUDIO_INVOKED + diff --git a/utils/vmpi/vmpi_service_install/vmpi_service_install.vpc b/utils/vmpi/vmpi_service_install/vmpi_service_install.vpc new file mode 100644 index 0000000..2c40ddb --- /dev/null +++ b/utils/vmpi/vmpi_service_install/vmpi_service_install.vpc @@ -0,0 +1,87 @@ +//----------------------------------------------------------------------------- +// VMPI_SERVICE_INSTALL.VPC +// +// Project Script +//----------------------------------------------------------------------------- + +$Macro SRCDIR "..\..\.." +$Macro OUTBINDIR "$SRCDIR\..\game\bin" +$Macro OUTBINNAME "vmpi_service_install" + +$Include "$SRCDIR\vpc_scripts\source_exe_win_win32_base.vpc" + +$Configuration "Debug" +{ + $Compiler + { + $AdditionalIncludeDirectories "$BASE,.\,..\,..\..\common,..\..\..\public" + $PreprocessorDefinitions "$BASE;PROTECTED_THINGS_DISABLE;WINVER=0x400" + $Create/UsePrecompiledHeader "Use Precompiled Header (/Yu)" + $Create/UsePCHThroughFile "stdafx.h" + } + + $Linker + { + $AdditionalDependencies "nafxcwd.lib" + $IgnoreSpecificLibrary "nafxcw.lib libcmt.lib libcmtd.lib" + } +} + +$Configuration "Release" +{ + $Compiler + { + $AdditionalIncludeDirectories "$BASE,.\,..\,..\..\common,..\..\..\public" + $PreprocessorDefinitions "$BASE;PROTECTED_THINGS_DISABLE;WINVER=0x400" + $Create/UsePrecompiledHeader "Use Precompiled Header (/Yu)" + $Create/UsePCHThroughFile "stdafx.h" + } + + $Linker + { + $AdditionalDependencies "nafxcw.lib libcmt.lib" + $IgnoreSpecificLibrary "nafxcwd.lib libcmtd.lib" + } +} + +$Project "Vmpi_service_install" +{ + $Folder "Source Files" + { + -$File "$SRCDIR\public\tier0\memoverride.cpp" + + $File "StdAfx.cpp" + { + $Configuration + { + $Compiler + { + $Create/UsePrecompiledHeader "Create Precompiled Header (/Yc)" + } + } + } + + $File "ServiceInstallDlg.cpp" + $File "vmpi_service_install.cpp" + $File "vmpi_service_install.rc" + } + + $Folder "Header Files" + { + $File "ServiceInstallDlg.h" + $File "Resource.h" + $File "StdAfx.h" + $File "vmpi_service_install.h" + } + + $Folder "Resource Files" + { + $File "res\vmpi_service_install.ico" + $File "res\vmpi_service_install.rc2" + } + + $Folder "Link Libraries" + { + $DynamicFile "$SRCDIR\lib\public\vmpi.lib" + } +} diff --git a/utils/vmpi/vmpi_service_ui/StdAfx.cpp b/utils/vmpi/vmpi_service_ui/StdAfx.cpp new file mode 100644 index 0000000..d22d5d4 --- /dev/null +++ b/utils/vmpi/vmpi_service_ui/StdAfx.cpp @@ -0,0 +1,15 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// stdafx.cpp : source file that includes just the standard includes +// vmpi_service_ui.pch will be the pre-compiled header +// stdafx.obj will contain the pre-compiled type information + +#include "stdafx.h" + +// TODO: reference any additional headers you need in STDAFX.H +// and not in this file diff --git a/utils/vmpi/vmpi_service_ui/StdAfx.h b/utils/vmpi/vmpi_service_ui/StdAfx.h new file mode 100644 index 0000000..31b5d12 --- /dev/null +++ b/utils/vmpi/vmpi_service_ui/StdAfx.h @@ -0,0 +1,30 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, but +// are changed infrequently +// + +#if !defined(AFX_STDAFX_H__A9DB83DB_A9FD_11D0_BFD1_444553540000__INCLUDED_) +#define AFX_STDAFX_H__A9DB83DB_A9FD_11D0_BFD1_444553540000__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers + +#include <windows.h> + + +// TODO: reference additional headers your program requires here + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_STDAFX_H__A9DB83DB_A9FD_11D0_BFD1_444553540000__INCLUDED_) diff --git a/utils/vmpi/vmpi_service_ui/idi_busy_icon.ico b/utils/vmpi/vmpi_service_ui/idi_busy_icon.ico Binary files differnew file mode 100644 index 0000000..ac62654 --- /dev/null +++ b/utils/vmpi/vmpi_service_ui/idi_busy_icon.ico diff --git a/utils/vmpi/vmpi_service_ui/idi_disabled_icon.ico b/utils/vmpi/vmpi_service_ui/idi_disabled_icon.ico Binary files differnew file mode 100644 index 0000000..e49e952 --- /dev/null +++ b/utils/vmpi/vmpi_service_ui/idi_disabled_icon.ico diff --git a/utils/vmpi/vmpi_service_ui/idi_waiting_icon.ico b/utils/vmpi/vmpi_service_ui/idi_waiting_icon.ico Binary files differnew file mode 100644 index 0000000..a52165d --- /dev/null +++ b/utils/vmpi/vmpi_service_ui/idi_waiting_icon.ico diff --git a/utils/vmpi/vmpi_service_ui/resource.h b/utils/vmpi/vmpi_service_ui/resource.h new file mode 100644 index 0000000..95b752b --- /dev/null +++ b/utils/vmpi/vmpi_service_ui/resource.h @@ -0,0 +1,47 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +//{{NO_DEPENDENCIES}} +// Microsoft Visual C++ generated include file. +// Used by vmpi_service_ui.rc +// +#define IDC_MYICON 2 +#define IDI_DISABLED_ICON 101 +#define IDD_VMPI_SERVICE_DIALOG 102 +#define IDI_BUSY_ICON 102 +#define IDD_ABOUTBOX 103 +#define IDS_APP_TITLE 103 +#define IDR_POPUP_MENU 103 +#define IDM_ABOUT 104 +#define IDM_EXIT 105 +#define IDI_WAITING_ICON 105 +#define IDS_HELLO 106 +#define IDI_VMPI_SERVICE 107 +#define IDI_SMALL 108 +#define IDC_VMPI_SERVICE 109 +#define IDR_MAINFRAME 128 +#define IDD_VMPI_SERVICE 129 +#define IDD_SET_PASSWORD 130 +#define IDI_UNCONNECTED 132 +#define ID_KILLCURRENTJOB 133 +#define IDC_DEBUG_OUTPUT 1000 +#define IDC_PASSWORD 1001 +#define ID_SET_PASSWORD 32771 +#define ID_IGNORECSXCOMPILES 32772 +#define ID_HIGHLIGHT_ICON_WHEN_BUSY 32773 +#define ID_SCREENSAVER_MODE 32774 +#define ID_ENABLE_WORKER 40001 +#define ID_DISABLE_WORKER 40003 +#define ID_EXIT_SERVICE 40004 +#define ID_SHOW_CONSOLE_WINDOW 40005 +#define ID_HIDE_CONSOLE_WINDOW 40006 +#define IDC_STATIC -1 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 133 +#define _APS_NEXT_COMMAND_VALUE 32775 +#define _APS_NEXT_CONTROL_VALUE 1002 +#define _APS_NEXT_SYMED_VALUE 110 +#endif +#endif diff --git a/utils/vmpi/vmpi_service_ui/shell_icon_mgr.cpp b/utils/vmpi/vmpi_service_ui/shell_icon_mgr.cpp new file mode 100644 index 0000000..cfdf759 --- /dev/null +++ b/utils/vmpi/vmpi_service_ui/shell_icon_mgr.cpp @@ -0,0 +1,187 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#include "stdafx.h" +#include "shell_icon_mgr.h" +#include "tier1/strtools.h" +#include "tier0/dbg.h" +#include "shellapi.h" + + +#define SHELLICONMGR_CLASSNAME "VMPI_ShellIconMgr" + + + +CShellIconMgr::CShellIconMgr() +{ + m_hWnd = NULL; + m_hWndClass = NULL; + m_uTaskbarRestart = (UINT)-1; + m_iCurIconResourceID = 0; + m_pHelper = NULL; +} + + +CShellIconMgr::~CShellIconMgr() +{ + Term(); +} + + +bool CShellIconMgr::Init( + IShellIconMgrHelper *pHelper, + const char *pToolTip, + int iCallbackMessage, + int iIconResourceID ) +{ + Term(); + + m_pHelper = pHelper; + m_iCallbackMessage = iCallbackMessage; + m_pToolTip = pToolTip; + + // Create the window class. + WNDCLASS wndclass; + memset( &wndclass, 0, sizeof( wndclass ) ); + wndclass.lpfnWndProc = &CShellIconMgr::StaticWindowProc; + wndclass.hInstance = (HINSTANCE)pHelper->GetHInstance(); + wndclass.hIcon = NULL; + wndclass.hCursor = LoadCursor( NULL, IDC_ARROW ); + wndclass.hbrBackground = (HBRUSH)GetStockObject( BLACK_BRUSH ); + wndclass.lpszMenuName = NULL; + wndclass.lpszClassName = SHELLICONMGR_CLASSNAME; + m_hWndClass = RegisterClass( &wndclass ); + if ( !m_hWndClass ) + { + Assert( false ); + Warning( "RegisterClass failed.\n" ); + Term(); + return false; + } + + + // Create the window. + m_hWnd = CreateWindow( + SHELLICONMGR_CLASSNAME, + SHELLICONMGR_CLASSNAME, + WS_DISABLED, // we only want shell notify messages + 0, 0, 0, 0, // position + NULL, // parent + NULL, // menu + pHelper->GetHInstance(), // hInstance + this // lpParam + ); + if ( !m_hWnd ) + { + Assert( false ); + Warning( "CreateWindow failed.\n" ); + Term(); + return false; + } + + m_uTaskbarRestart = RegisterWindowMessage( TEXT( "TaskbarCreated" ) ); + SetWindowLong( m_hWnd, GWL_USERDATA, (LONG)this ); + UpdateWindow( m_hWnd ); + + // Don't handle errors here because the taskbar may not be created yet if we are a service. + m_iCurIconResourceID = iIconResourceID; + CreateTrayIcon(); + return true; +} + + +void CShellIconMgr::Term() +{ + if ( m_hWndClass ) + { + UnregisterClass( SHELLICONMGR_CLASSNAME, m_pHelper->GetHInstance() ); + m_hWndClass = NULL; + } + + if ( m_hWnd ) + { + // Remove the shell icon if there is one. + NOTIFYICONDATA data; + memset( &data, 0, sizeof( data ) ); + data.cbSize = sizeof( data ); + data.hWnd = m_hWnd; + Shell_NotifyIcon( NIM_DELETE, &data ); + + DestroyWindow( m_hWnd ); + m_hWnd = NULL; + } +} + + +void CShellIconMgr::ChangeIcon( int iIconResourceID ) +{ + NOTIFYICONDATA data; + + memset( &data, 0, sizeof( data ) ); + data.cbSize = sizeof( data ); + data.uFlags = NIF_ICON; + data.hWnd = m_hWnd; + data.hIcon = LoadIcon( m_pHelper->GetHInstance(), MAKEINTRESOURCE( iIconResourceID ) ); + + Shell_NotifyIcon( NIM_MODIFY, &data ); + + m_iCurIconResourceID = iIconResourceID; +} + + +void CShellIconMgr::CreateTrayIcon() +{ + // Now create the shell icon. + NOTIFYICONDATA data; + + memset( &data, 0, sizeof( data ) ); + data.cbSize = sizeof( data ); + data.uFlags = NIF_ICON | NIF_TIP | NIF_MESSAGE; + data.uCallbackMessage = m_iCallbackMessage; + data.hWnd = m_hWnd; + data.hIcon = LoadIcon( m_pHelper->GetHInstance(), MAKEINTRESOURCE( m_iCurIconResourceID ) ); + Q_strncpy( data.szTip, m_pToolTip, sizeof( data.szTip ) ); + + Shell_NotifyIcon( NIM_ADD, &data ); +} + + +LRESULT CShellIconMgr::WindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam ) +{ + if ( hWnd != m_hWnd ) + { + return DefWindowProc( hWnd, uMsg, wParam, lParam ); + } + + if ( uMsg == m_uTaskbarRestart ) + { + CreateTrayIcon(); + return 0; + } + + return m_pHelper->WindowProc( hWnd, uMsg, wParam, lParam ); +} + + +LRESULT CShellIconMgr::StaticWindowProc( + HWND hwnd, // handle to window + UINT uMsg, // message identifier + WPARAM wParam, // first message parameter + LPARAM lParam // second message parameter + ) +{ + CShellIconMgr *pMgr = (CShellIconMgr*)GetWindowLong( hwnd, GWL_USERDATA ); + if ( pMgr ) + { + return pMgr->WindowProc( hwnd, uMsg, wParam, lParam ); + } + else + { + return DefWindowProc( hwnd, uMsg, wParam, lParam ); + } +} + diff --git a/utils/vmpi/vmpi_service_ui/shell_icon_mgr.h b/utils/vmpi/vmpi_service_ui/shell_icon_mgr.h new file mode 100644 index 0000000..81188d4 --- /dev/null +++ b/utils/vmpi/vmpi_service_ui/shell_icon_mgr.h @@ -0,0 +1,66 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#ifndef SHELL_ICON_MGR_H +#define SHELL_ICON_MGR_H +#ifdef _WIN32 +#pragma once +#endif + + +class IShellIconMgrHelper +{ +public: + virtual HINSTANCE GetHInstance() = 0; + virtual int WindowProc( void *hWnd, int uMsg, long wParam, long lParam ) = 0; +}; + +class CShellIconMgr +{ +public: + + CShellIconMgr(); + ~CShellIconMgr(); + + bool Init( + IShellIconMgrHelper *pHelper, + const char *pToolTip, // This must be allocated by the caller and must be valid as + // long as the CShellIconMgr exists. + int iCallbackMessage, + int iIconResourceID ); + + void Term(); + + void ChangeIcon( int iIconResourceID ); + + +private: + + void CreateTrayIcon(); + + LRESULT WindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam ); + + static LRESULT CALLBACK StaticWindowProc( + HWND hwnd, // handle to window + UINT uMsg, // message identifier + WPARAM wParam, // first message parameter + LPARAM lParam // second message parameter + ); + + HWND m_hWnd; // Invisible window to get timer and shell icon messages. + ATOM m_hWndClass; + + UINT m_uTaskbarRestart; // This message is sent to us when the taskbar is created. + int m_iCurIconResourceID; + int m_iCallbackMessage; + const char *m_pToolTip; + + IShellIconMgrHelper *m_pHelper; +}; + + +#endif // SHELL_ICON_MGR_H diff --git a/utils/vmpi/vmpi_service_ui/unconnec.ico b/utils/vmpi/vmpi_service_ui/unconnec.ico Binary files differnew file mode 100644 index 0000000..5cfdcdb --- /dev/null +++ b/utils/vmpi/vmpi_service_ui/unconnec.ico diff --git a/utils/vmpi/vmpi_service_ui/vmpi_service.ico b/utils/vmpi/vmpi_service_ui/vmpi_service.ico Binary files differnew file mode 100644 index 0000000..3868835 --- /dev/null +++ b/utils/vmpi/vmpi_service_ui/vmpi_service.ico diff --git a/utils/vmpi/vmpi_service_ui/vmpi_service_ui.cpp b/utils/vmpi/vmpi_service_ui/vmpi_service_ui.cpp new file mode 100644 index 0000000..7bb756f --- /dev/null +++ b/utils/vmpi/vmpi_service_ui/vmpi_service_ui.cpp @@ -0,0 +1,617 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// vmpi_service_ui.cpp : Defines the entry point for the application. +// + +#include "stdafx.h" +#include "consolewnd.h" +#include "resource.h" +#include "tier0/dbg.h" +#include "tier1/strtools.h" +#include "shell_icon_mgr.h" +#include "vmpi.h" +#include "service_conn_mgr.h" +#include <io.h> +#include <time.h> + + + +void UpdatePopupMenuState(); + + + +const char *g_pIconTooltip = VMPI_SERVICE_NAME; + +IConsoleWnd *g_pConsoleWnd = NULL; +HINSTANCE g_hInstance = NULL; + + +#define MYWM_NOTIFYICON (WM_APP+100) +CShellIconMgr g_ShellIconMgr; + +bool g_bHighlightIconWhenBusy = false; + + +// STATE THE SERVICE OWNS. +int g_iCurState = 0; // One of the VMPI_SERVICE_STATE_ defines. +char *g_pPassword = NULL; +bool g_bScreensaverMode = false; + + +void LogString( const char *pStr, ... ) +{ +#ifdef VMPI_SERVICE_LOGS + char str[4096]; + va_list marker; + va_start( marker, pStr ); + _vsnprintf( str, sizeof( str ), pStr, marker ); + va_end( marker ); + + static FILE *fp = fopen( "c:\\vmpi_service_ui.log", "wt" ); + if ( fp ) + { + fprintf( fp, "%s", str ); + fflush( fp ); + } +#endif +} + +char* GetLastErrorString() +{ + static char err[2048]; + + LPVOID lpMsgBuf; + FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpMsgBuf, 0, NULL ); + strncpy( err, (char*)lpMsgBuf, sizeof( err ) ); + LocalFree( lpMsgBuf ); + + err[ sizeof( err ) - 1 ] = 0; + return err; +} + + +// ------------------------------------------------------------------------------------------ // +// Persistent state in the registry. +// ------------------------------------------------------------------------------------------ // +void LoadStateFromRegistry() +{ + HKEY hKey = NULL; + RegCreateKey( HKEY_LOCAL_MACHINE, VMPI_SERVICE_KEY, &hKey ); + if ( hKey ) + { + DWORD val = 0; + DWORD type = REG_DWORD; + DWORD size = sizeof( val ); + if ( RegQueryValueEx( + hKey, + "HighlightIconWhenBusy", + 0, + &type, + (unsigned char*)&val, + &size ) == ERROR_SUCCESS && + type == REG_DWORD && + size == sizeof( val ) ) + { + g_bHighlightIconWhenBusy = (val != 0); + } + } +} + +void SaveStateToRegistry() +{ + HKEY hKey = NULL; + RegCreateKey( HKEY_LOCAL_MACHINE, VMPI_SERVICE_KEY, &hKey ); + if ( hKey ) + { + DWORD val = g_bHighlightIconWhenBusy; + RegSetValueEx( + hKey, + "HighlightIconWhenBusy", + 0, + REG_DWORD, + (unsigned char*)&val, + sizeof( val ) ); + } +} + + +// ------------------------------------------------------------------------------------------ // +// Our CServiceConnMgr packet handler. +// ------------------------------------------------------------------------------------------ // + +void UpdateAppIcon() +{ + if ( g_iCurState == VMPI_SERVICE_STATE_IDLE ) + { + g_ShellIconMgr.ChangeIcon( IDI_WAITING_ICON ); + } + else if ( g_iCurState == VMPI_SERVICE_STATE_BUSY ) + { + if ( g_bHighlightIconWhenBusy ) + g_ShellIconMgr.ChangeIcon( IDI_BUSY_ICON ); + else + g_ShellIconMgr.ChangeIcon( IDI_WAITING_ICON ); + } + else + { + g_ShellIconMgr.ChangeIcon( IDI_DISABLED_ICON ); + } +} + + +class CUIConnMgr : public CServiceConnMgr +{ +public: + virtual void HandlePacket( const char *pData, int len ); +}; + + +void CUIConnMgr::HandlePacket( const char *pData, int len ) +{ + if ( pData[0] != VMPI_SERVICE_UI_PROTOCOL_VERSION ) + return; + + int packetID = pData[1]; + + int offset = 2; + if ( packetID == VMPI_SERVICE_TO_UI_CONSOLE_TEXT ) + { + Msg( &pData[offset] ); + } + else if ( packetID == VMPI_SERVICE_TO_UI_STATE ) + { + // Get the new state out.. + g_iCurState = *((int*)&pData[offset]); + offset += 4; + + LogString( "New UI state: %d.\n", g_iCurState ); + + // Update our icon. + UpdateAppIcon(); + + g_bScreensaverMode = (*((char*)&pData[offset]) != 0); + ++offset; + + // Store the current password. + if ( g_pPassword ) + delete [] g_pPassword; + + const char *pStr = &pData[offset]; + g_pPassword = new char[ strlen( pStr ) + 1 ]; + strcpy( g_pPassword, pStr ); + offset += strlen( pStr ) + 1; + + UpdatePopupMenuState(); + } + else if ( packetID == VMPI_SERVICE_TO_UI_PATCHING ) + { + LogString( "Got a VMPI_SERVICE_TO_UI_PATCHING packet.\n" ); + + int bExitAfter = pData[offset]; + ++offset; + + char workingDir[MAX_PATH], commandLine[4096]; + V_strncpy( workingDir, &pData[offset], sizeof( workingDir ) ); + offset += V_strlen( workingDir ) + 1; + + V_strncpy( commandLine, &pData[offset], sizeof( commandLine ) ); + offset += V_strlen( commandLine ) + 1; + + // Run whatever they said to run. + STARTUPINFO si; + memset( &si, 0, sizeof( si ) ); + si.cb = sizeof( si ); + + PROCESS_INFORMATION pi; + memset( &pi, 0, sizeof( pi ) ); + if ( CreateProcess( NULL, commandLine, NULL, NULL, false, CREATE_NO_WINDOW, NULL, workingDir, &si, &pi ) ) + { + LogString( "CreateProcess succeeded:\n%s\n", commandLine ); + + CloseHandle( pi.hProcess ); + CloseHandle( pi.hThread ); + + if ( bExitAfter ) + PostQuitMessage( 0 ); + } + else + { + LogString( "CreateProcess failed: %s", GetLastErrorString() ); + } + } + else if ( packetID == VMPI_SERVICE_TO_UI_EXIT ) + { + // Exit. + PostQuitMessage( 0 ); + } +} + + +// ------------------------------------------------------------------------------------------ // +// Helpers. +// ------------------------------------------------------------------------------------------ // + +void InternalSpew( const char *pMsg ) +{ + if ( g_pConsoleWnd ) + { + g_pConsoleWnd->PrintToConsole( pMsg ); + } + + OutputDebugString( pMsg ); +} + + +SpewRetval_t MySpewOutputFunc( SpewType_t spewType, const char *pMsg ) +{ + // Prepend the time. + time_t aclock; + time( &aclock ); + struct tm *newtime = localtime( &aclock ); + + // Get rid of the \n. + char timeString[512]; + Q_strncpy( timeString, asctime( newtime ), sizeof( timeString ) ); + char *pEnd = strstr( timeString, "\n" ); + if ( pEnd ) + *pEnd = 0; + InternalSpew( timeString ); + + InternalSpew( " - " ); + InternalSpew( pMsg ); + + if ( spewType == SPEW_ASSERT ) + return SPEW_DEBUGGER; + else if( spewType == SPEW_ERROR ) + return SPEW_ABORT; + else + return SPEW_CONTINUE; +} + + + +CUIConnMgr g_ConnMgr; + +void InitConsoleWindow() +{ + // Only initialize it once. + if ( g_pConsoleWnd ) + return; + + g_pConsoleWnd = CreateConsoleWnd( + g_hInstance, + IDD_VMPI_SERVICE, + IDC_DEBUG_OUTPUT, + false ); +} + + +// ------------------------------------------------------------------------------------------ // +// Implementation of IShellIconMgrHelper. +// ------------------------------------------------------------------------------------------ // + +HMENU g_hMenu = NULL; +HMENU g_hPopupMenu = NULL; // This is just a submenu of g_hMenu. + + +bool LoadPopupMenu() +{ + g_hMenu = LoadMenu( g_hInstance, MAKEINTRESOURCE( IDR_POPUP_MENU ) ); + if ( !g_hMenu ) + { + Assert( false ); + Warning( "LoadMenu failed.\n" ); + return false; + } + + g_hPopupMenu = GetSubMenu( g_hMenu, 0 ); + return true; +} + + +void TermPopupMenu() +{ + if ( g_hMenu ) + { + DestroyMenu( g_hMenu ); + g_hMenu = NULL; + } + g_hPopupMenu = NULL; +} + + +void UpdatePopupMenuState() +{ + bool bEnabled = (g_iCurState == VMPI_SERVICE_STATE_IDLE || g_iCurState == VMPI_SERVICE_STATE_BUSY); + EnableMenuItem( g_hPopupMenu, ID_ENABLE_WORKER, bEnabled ? MF_GRAYED : MF_ENABLED ); + EnableMenuItem( g_hPopupMenu, ID_DISABLE_WORKER, !bEnabled ? MF_GRAYED : MF_ENABLED ); + + // Enable or disable console items. + EnableMenuItem( g_hPopupMenu, ID_SHOW_CONSOLE_WINDOW, g_pConsoleWnd->IsVisible() ? MF_GRAYED : MF_ENABLED ); + EnableMenuItem( g_hPopupMenu, ID_HIDE_CONSOLE_WINDOW, !g_pConsoleWnd->IsVisible() ? MF_GRAYED : MF_ENABLED ); + + CheckMenuItem( g_hPopupMenu, ID_SCREENSAVER_MODE, g_bScreensaverMode ? MF_CHECKED : MF_UNCHECKED ); + CheckMenuItem( g_hPopupMenu, ID_HIGHLIGHT_ICON_WHEN_BUSY, g_bHighlightIconWhenBusy ? MF_CHECKED : MF_UNCHECKED ); +} + + +int CALLBACK SetPasswordDlgProc( + HWND hwndDlg, // handle to dialog box + UINT uMsg, // message + WPARAM wParam, // first message parameter + LPARAM lParam // second message parameter +) +{ + switch( uMsg ) + { + case WM_INITDIALOG: + { + if ( g_pPassword ) + { + HWND hWnd = GetDlgItem( hwndDlg, IDC_PASSWORD ); + SetWindowText( hWnd, g_pPassword ); + } + } + break; + + case WM_COMMAND: + { + switch( wParam ) + { + case IDOK: + { + // Set our new password. + HWND hWnd = GetDlgItem( hwndDlg, IDC_PASSWORD ); + if ( hWnd ) + { + char tempBuf[512]; + GetWindowText( hWnd, tempBuf, sizeof( tempBuf ) ); + + // Send it to the service. + CUtlVector<char> data; + data.AddToTail( VMPI_SERVICE_UPDATE_PASSWORD ); + data.AddMultipleToTail( strlen( tempBuf ) + 1, tempBuf ); + g_ConnMgr.SendPacket( -1, data.Base(), data.Count() ); + } + EndDialog( hwndDlg, 0 ); + } + break; + + case IDCANCEL: + { + EndDialog( hwndDlg, 0 ); + } + break; + } + } + break; + } + + return FALSE; +} + + +class CShellIconMgrHelper : public IShellIconMgrHelper +{ +public: + virtual HINSTANCE GetHInstance() + { + return g_hInstance; + } + + virtual int WindowProc( void *pWnd, int uMsg, long wParam, long lParam ) + { + HWND hWnd = (HWND)pWnd; + + switch( uMsg ) + { + // Right button brings up the popup menu. + case MYWM_NOTIFYICON: + { + if ( lParam == WM_RBUTTONDOWN ) + { + POINT cursorPos; + GetCursorPos( &cursorPos ); + + UpdatePopupMenuState(); + + // Make a popup menu. + SetForegroundWindow( hWnd ); + TrackPopupMenu( g_hPopupMenu, TPM_RIGHTALIGN | TPM_BOTTOMALIGN, cursorPos.x, cursorPos.y, 0, hWnd, NULL ); + return 0; + } + else if ( lParam == WM_LBUTTONDOWN ) + { + // Left button brings up the console. + g_pConsoleWnd->SetVisible( true ); + UpdatePopupMenuState(); + return 0; + } + } + break; + + case WM_COMMAND: + { + switch( wParam ) + { + case ID_ENABLE_WORKER: + { + char cPacket = VMPI_SERVICE_ENABLE; + g_ConnMgr.SendPacket( -1, &cPacket, 1 ); + } + break; + + case ID_DISABLE_WORKER: + { + char cPacket = VMPI_SERVICE_DISABLE; + g_ConnMgr.SendPacket( -1, &cPacket, 1 ); + } + break; + + case ID_KILLCURRENTJOB: + { + char cPacket = VMPI_KILL_PROCESS; + g_ConnMgr.SendPacket( -1, &cPacket, 1 ); + } + break; + + case ID_HIGHLIGHT_ICON_WHEN_BUSY: + { + g_bHighlightIconWhenBusy = !g_bHighlightIconWhenBusy; + SaveStateToRegistry(); + UpdateAppIcon(); + UpdatePopupMenuState(); + } + break; + + case ID_SCREENSAVER_MODE: + { + g_bScreensaverMode = !g_bScreensaverMode; + char cPacket[2] = { VMPI_SERVICE_SCREENSAVER_MODE, g_bScreensaverMode }; + g_ConnMgr.SendPacket( -1, cPacket, sizeof( cPacket ) ); + } + break; + + + case ID_SHOW_CONSOLE_WINDOW: + { + g_pConsoleWnd->SetVisible( true ); + UpdatePopupMenuState(); + } + break; + + case ID_HIDE_CONSOLE_WINDOW: + { + g_pConsoleWnd->SetVisible( false ); + UpdatePopupMenuState(); + } + break; + + case ID_SET_PASSWORD: + { + DialogBox( g_hInstance, MAKEINTRESOURCE( IDD_SET_PASSWORD ), NULL, SetPasswordDlgProc ); + } + break; + + case ID_EXIT_SERVICE: + { + // Quit the service app.. + char cPacket = VMPI_SERVICE_EXIT; + g_ConnMgr.SendPacket( -1, &cPacket, 1 ); + + // Stop showing the icon. + g_ShellIconMgr.Term(); + + // Wait for a bit for the connection to go away. + DWORD startTime = GetTickCount(); + while ( GetTickCount()-startTime < 2000 ) + { + g_ConnMgr.Update(); + if ( !g_ConnMgr.IsConnected() ) + break; + else + Sleep( 10 ); + } + + // Quit the UI app. + PostQuitMessage( 0 ); + return 1; + } + break; + } + } + break; + } + + return DefWindowProc( (HWND)hWnd, uMsg, wParam, lParam ); + } +}; + +CShellIconMgrHelper g_ShellIconMgrHelper; + + + +int APIENTRY WinMain(HINSTANCE hInstance, + HINSTANCE hPrevInstance, + LPSTR lpCmdLine, + int nCmdShow) +{ + g_hInstance = hInstance; + + + LogString( "vmpi_service_ui startup.\n" ); + + // Don't run multiple instances. + HANDLE hMutex = CreateMutex( NULL, FALSE, "vmpi_service_ui_mutex" ); + if ( hMutex && GetLastError() == ERROR_ALREADY_EXISTS ) + return 1; + + + // Hook spew output. + SpewOutputFunc( MySpewOutputFunc ); + InitConsoleWindow(); + LogString( "Setup console window.\n" ); + + LoadStateFromRegistry(); + + // Setup the popup menu. + if( !LoadPopupMenu() ) + { + return false; + } + UpdatePopupMenuState(); + + + // Setup the tray icon. + Msg( "Waiting for jobs...\n" ); + if ( !g_ShellIconMgr.Init( &g_ShellIconMgrHelper, g_pIconTooltip, MYWM_NOTIFYICON, IDI_WAITING_ICON ) ) + { + return false; + } + + + // Connect to the VMPI service. + g_ConnMgr.InitClient(); + + LogString( "Entering main loop.\n" ); + + while ( 1 ) + { + MSG msg; + msg.message = !WM_QUIT; // So it doesn't accidentally exit. + while ( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) ) + { + if ( msg.message == WM_QUIT ) + break; + + TranslateMessage( &msg ); + DispatchMessage( &msg ); + } + if ( msg.message == WM_QUIT ) + break; + + g_ConnMgr.Update(); + if ( !g_ConnMgr.IsConnected() ) + { + g_ShellIconMgr.ChangeIcon( IDI_UNCONNECTED ); + } + + Sleep( 30 ); + } + + // Important that we call this instead of letting the destructor do it because it deletes its + // socket and it needs to cleanup some threads. + g_ConnMgr.Term(); + + g_ShellIconMgr.Term(); + + return 0; +} + + + diff --git a/utils/vmpi/vmpi_service_ui/vmpi_service_ui.rc b/utils/vmpi/vmpi_service_ui/vmpi_service_ui.rc new file mode 100644 index 0000000..c3a6c62 --- /dev/null +++ b/utils/vmpi/vmpi_service_ui/vmpi_service_ui.rc @@ -0,0 +1,171 @@ +// Microsoft Visual C++ generated resource script. +// +#include "resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#define APSTUDIO_HIDDEN_SYMBOLS +#include "windows.h" +#undef APSTUDIO_HIDDEN_SYMBOLS +#include "resource.h" + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +// English (U.S.) resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +#ifdef _WIN32 +LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US +#pragma code_page(1252) +#endif //_WIN32 + +///////////////////////////////////////////////////////////////////////////// +// +// Icon +// + +// Icon with lowest ID value placed first to ensure application icon +// remains consistent on all systems. +IDI_DISABLED_ICON ICON "idi_disabled_icon.ico" +IDI_VMPI_SERVICE ICON "vmpi_service.ICO" +IDI_BUSY_ICON ICON "idi_busy_icon.ico" +IDI_WAITING_ICON ICON "idi_waiting_icon.ico" +IDI_UNCONNECTED ICON "unconnec.ico" + +///////////////////////////////////////////////////////////////////////////// +// +// Menu +// + +IDR_POPUP_MENU MENU +BEGIN + POPUP "item1" + BEGIN + MENUITEM "&Enable", ID_ENABLE_WORKER + MENUITEM "&Disable", ID_DISABLE_WORKER + MENUITEM "&Kill Current Job", ID_KILLCURRENTJOB + MENUITEM SEPARATOR + MENUITEM "&Show Console Window", ID_SHOW_CONSOLE_WINDOW + MENUITEM "&Hide Console Window", ID_HIDE_CONSOLE_WINDOW + MENUITEM SEPARATOR + MENUITEM "Set &Password", ID_SET_PASSWORD + MENUITEM "Highlight Icon When Busy", ID_HIGHLIGHT_ICON_WHEN_BUSY + MENUITEM "Screensaver Mode", ID_SCREENSAVER_MODE + MENUITEM SEPARATOR + MENUITEM "&Exit Service", ID_EXIT_SERVICE + END +END + + +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +2 TEXTINCLUDE +BEGIN + "#define APSTUDIO_HIDDEN_SYMBOLS\r\n" + "#include ""windows.h""\r\n" + "#undef APSTUDIO_HIDDEN_SYMBOLS\r\n" + "#include ""resource.h""\r\n" + "\0" +END + +3 TEXTINCLUDE +BEGIN + "\r\n" + "\0" +END + +1 TEXTINCLUDE +BEGIN + "resource.h\0" +END + +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// Dialog +// + +IDD_VMPI_SERVICE DIALOG 0, 0, 454, 225 +STYLE DS_SETFONT | WS_POPUP | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME +CAPTION "Valve MPI Service" +FONT 8, "MS Sans Serif" +BEGIN + EDITTEXT IDC_DEBUG_OUTPUT,7,7,440,211,ES_MULTILINE | ES_READONLY | WS_VSCROLL | WS_HSCROLL +END + +IDD_SET_PASSWORD DIALOG 0, 0, 134, 50 +STYLE DS_SETFONT | DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Set Password (-mpi_pw)" +FONT 8, "MS Sans Serif" +BEGIN + EDITTEXT IDC_PASSWORD,7,7,120,14,ES_AUTOHSCROLL + DEFPUSHBUTTON "OK",IDOK,7,29,50,14 + PUSHBUTTON "Cancel",IDCANCEL,77,29,50,14 +END + + +///////////////////////////////////////////////////////////////////////////// +// +// DESIGNINFO +// + +#ifdef APSTUDIO_INVOKED +GUIDELINES DESIGNINFO +BEGIN + IDD_VMPI_SERVICE, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 447 + TOPMARGIN, 7 + BOTTOMMARGIN, 218 + END + + IDD_SET_PASSWORD, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 127 + TOPMARGIN, 7 + BOTTOMMARGIN, 43 + END +END +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// String Table +// + +STRINGTABLE +BEGIN + IDS_APP_TITLE "vmpi_service" + IDS_HELLO "Hello World!" + IDC_VMPI_SERVICE "VMPI_SERVICE" +END + +#endif // English (U.S.) resources +///////////////////////////////////////////////////////////////////////////// + + + +#ifndef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 3 resource. +// + + +///////////////////////////////////////////////////////////////////////////// +#endif // not APSTUDIO_INVOKED + diff --git a/utils/vmpi/vmpi_service_ui/vmpi_service_ui.vpc b/utils/vmpi/vmpi_service_ui/vmpi_service_ui.vpc new file mode 100644 index 0000000..0f33d66 --- /dev/null +++ b/utils/vmpi/vmpi_service_ui/vmpi_service_ui.vpc @@ -0,0 +1,58 @@ +//----------------------------------------------------------------------------- +// VMPI_SERVICE.VPC +// +// Project Script +//----------------------------------------------------------------------------- + +$Macro SRCDIR "..\..\.." +$Macro OUTBINDIR "$SRCDIR\..\game\bin" + +$Include "$SRCDIR\vpc_scripts\source_exe_base.vpc" + +$Configuration +{ + $Compiler + { + $AdditionalIncludeDirectories "$BASE,..\..\common,..\,..\vmpi_service" + $PreprocessorDefinitions "$BASE;PROTECTED_THINGS_DISABLE" + } + + $Linker + { + $AdditionalDependencies "$BASE ws2_32.lib odbc32.lib odbccp32.lib" + } +} + +$Project "Vmpi_service_ui" +{ + $Folder "Source Files" + { + $File "..\iphelpers.cpp" + $File "shell_icon_mgr.cpp" + $File "vmpi_service_ui.cpp" + $File "vmpi_service_ui.rc" + $File "StdAfx.cpp" + $File "..\tcpsocket_helpers.cpp" + $File "..\ThreadedTCPSocket.cpp" + $File "..\..\common\consolewnd.cpp" + $File "..\vmpi_service\service_conn_mgr.cpp" + $File "..\ThreadedTCPSocketEmu.cpp" + $File "..\threadhelpers.cpp" + } + + $Folder "Header Files" + { + $File "shell_icon_mgr.h" + $File "resource.h" + $File "StdAfx.h" + } + + $Folder "Resource Files" + { + $File "idi_busy_icon.ico" + $File "idi_disabled_icon.ico" + $File "idi_waiting_icon.ico" + $File "unconnec.ico" + $File "vmpi_service.ico" + } +} diff --git a/utils/vmpi/vmpi_services_watch/PatchTimeout.cpp b/utils/vmpi/vmpi_services_watch/PatchTimeout.cpp new file mode 100644 index 0000000..df242d8 --- /dev/null +++ b/utils/vmpi/vmpi_services_watch/PatchTimeout.cpp @@ -0,0 +1,50 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// PatchTimeout.cpp : implementation file +// + +#include "stdafx.h" +#include "PatchTimeout.h" + +#ifdef _DEBUG +#define new DEBUG_NEW +#undef THIS_FILE +static char THIS_FILE[] = __FILE__; +#endif + +///////////////////////////////////////////////////////////////////////////// +// CPatchTimeout dialog + + +CPatchTimeout::CPatchTimeout(CWnd* pParent /*=NULL*/) + : CDialog(CPatchTimeout::IDD, pParent) +{ + //{{AFX_DATA_INIT(CPatchTimeout) + //}}AFX_DATA_INIT +} + + +void CPatchTimeout::DoDataExchange(CDataExchange* pDX) +{ + CDialog::DoDataExchange(pDX); + //{{AFX_DATA_MAP(CPatchTimeout) + DDX_Text(pDX, IDC_COMMAND_LINE, m_PatchDirectory); + DDX_Text(pDX, IDC_VMPI_TRANSFER_DIRECTORY, m_VMPITransferDirectory); + DDX_Check(pDX, IDC_FORCE_PATCH, m_bForcePatch); + //}}AFX_DATA_MAP +} + + +BEGIN_MESSAGE_MAP(CPatchTimeout, CDialog) + //{{AFX_MSG_MAP(CPatchTimeout) + // NOTE: the ClassWizard will add message map macros here + //}}AFX_MSG_MAP +END_MESSAGE_MAP() + +///////////////////////////////////////////////////////////////////////////// +// CPatchTimeout message handlers diff --git a/utils/vmpi/vmpi_services_watch/PatchTimeout.h b/utils/vmpi/vmpi_services_watch/PatchTimeout.h new file mode 100644 index 0000000..1efb171 --- /dev/null +++ b/utils/vmpi/vmpi_services_watch/PatchTimeout.h @@ -0,0 +1,57 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +#if !defined(AFX_PATCHTIMEOUT_H__2D87CBF2_AC88_4F23_BB43_CC8A5C248B64__INCLUDED_) +#define AFX_PATCHTIMEOUT_H__2D87CBF2_AC88_4F23_BB43_CC8A5C248B64__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 +// PatchTimeout.h : header file +// + +#include "resource.h" + +///////////////////////////////////////////////////////////////////////////// +// CPatchTimeout dialog + +class CPatchTimeout : public CDialog +{ +// Construction +public: + CPatchTimeout(CWnd* pParent = NULL); // standard constructor + +// Dialog Data + //{{AFX_DATA(CPatchTimeout) + enum { IDD = IDD_TIMEOUT }; + CString m_PatchDirectory; + CString m_VMPITransferDirectory; + int m_bForcePatch; + //}}AFX_DATA + + +// Overrides + // ClassWizard generated virtual function overrides + //{{AFX_VIRTUAL(CPatchTimeout) + protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support + //}}AFX_VIRTUAL + +// Implementation +protected: + + // Generated message map functions + //{{AFX_MSG(CPatchTimeout) + // NOTE: the ClassWizard will add member functions here + //}}AFX_MSG + DECLARE_MESSAGE_MAP() +}; + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_PATCHTIMEOUT_H__2D87CBF2_AC88_4F23_BB43_CC8A5C248B64__INCLUDED_) diff --git a/utils/vmpi/vmpi_services_watch/ServicesDlg.cpp b/utils/vmpi/vmpi_services_watch/ServicesDlg.cpp new file mode 100644 index 0000000..dd8ea5f --- /dev/null +++ b/utils/vmpi/vmpi_services_watch/ServicesDlg.cpp @@ -0,0 +1,1161 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// ServicesDlg.cpp : implementation file +// + +#include "stdafx.h" +#include "ServicesDlg.h" +#include "vmpi.h" +#include "bitbuf.h" +#include "tier1/strtools.h" +#include "patchtimeout.h" +#include "SetPasswordDlg.h" +#include "vmpi_browser_helpers.h" +#include <io.h> + + +#ifdef _DEBUG +#define new DEBUG_NEW +#undef THIS_FILE +static char THIS_FILE[] = __FILE__; +#endif + +#define SERVICE_OFF_TIMEOUT (20*1000) // If we haven't heard from a service in this long, + // then we assume the service is off. + +#define SERVICES_PING_INTERVAL (3*1000) // ping the services every so often + +#define SERVICE_MAX_UPDATE_INTERVAL (8*1000) // Update each service in the listbox at least this often. + + + +int V_AfxMessageBox( int mbType, const char *pFormat, ... ) +{ + char msg[4096]; + va_list marker; + va_start( marker, pFormat ); + _vsnprintf( msg, sizeof( msg ), pFormat, marker ); + va_end( marker ); + + return AfxMessageBox( msg, mbType ); +} + + +bool CServiceInfo::IsOff() const +{ + return (Plat_MSTime() - m_LastPingTimeMS) > SERVICE_OFF_TIMEOUT; +} + + +// Returns the argument following pName. +// If pName is the last argument on the command line, returns pEndArgDefault. +// Returns NULL if there is no argument with pName. +const char* FindArg( const char *pName, const char *pEndArgDefault="" ) +{ + for ( int i=0; i < __argc; i++ ) + { + if ( stricmp( pName, __argv[i] ) == 0 ) + { + if ( (i+1) < __argc ) + return __argv[i+1]; + else + return pEndArgDefault; + } + } + return NULL; +} + +void AppendStr( char *dest, int destSize, const char *pFormat, ... ) +{ + char str[4096]; + va_list marker; + va_start( marker, pFormat ); + _vsnprintf( str, sizeof( str ), pFormat, marker ); + va_end( marker ); + str[sizeof( str ) - 1] = 0; + + V_strncat( dest, str, destSize ); +} + + +char* GetLastErrorString() +{ + static char err[2048]; + + LPVOID lpMsgBuf; + FormatMessage( + FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + GetLastError(), + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language + (LPTSTR) &lpMsgBuf, + 0, + NULL + ); + + strncpy( err, (char*)lpMsgBuf, sizeof( err ) ); + LocalFree( lpMsgBuf ); + + err[ sizeof( err ) - 1 ] = 0; + + return err; +} + +const char* GetStatusString( CServiceInfo *pInfo ) +{ + if ( pInfo->IsOff() ) + return "off"; + else if ( pInfo->m_iState == VMPI_STATE_BUSY ) + return "busy"; + else if ( pInfo->m_iState == VMPI_STATE_PATCHING ) + return "patching"; + else if ( pInfo->m_iState == VMPI_STATE_DISABLED ) + return "disabled"; + else if ( pInfo->m_iState == VMPI_STATE_SCREENSAVER_DISABLED ) + return "disabled (screensaver)"; + else if ( pInfo->m_iState == VMPI_STATE_DOWNLOADING ) + return "downloading"; + else + return "idle"; +} + + +// --------------------------------------------------------------------------------------------------------- // +// Column sort functions. +// --------------------------------------------------------------------------------------------------------- // +typedef int (CALLBACK *ServicesSortFn)( LPARAM iItem1, LPARAM iItem2, LPARAM lpParam ); + +static int CALLBACK SortByName( LPARAM iItem1, LPARAM iItem2, LPARAM lpParam ) +{ + CServiceInfo *pInfo1 = (CServiceInfo*)iItem1; + CServiceInfo *pInfo2 = (CServiceInfo*)iItem2; + + return strcmp( pInfo1->m_ComputerName, pInfo2->m_ComputerName ); +} + +static int CALLBACK SortByStatus( LPARAM iItem1, LPARAM iItem2, LPARAM lpParam ) +{ + CServiceInfo *pInfo1 = (CServiceInfo*)iItem1; + CServiceInfo *pInfo2 = (CServiceInfo*)iItem2; + + return -strcmp( GetStatusString( pInfo2 ), GetStatusString( pInfo1 ) ); +} + +static int CALLBACK SortByRunningTime( LPARAM iItem1, LPARAM iItem2, LPARAM lpParam ) +{ + CServiceInfo *pInfo1 = (CServiceInfo*)iItem1; + CServiceInfo *pInfo2 = (CServiceInfo*)iItem2; + + int v1 = pInfo1->m_LiveTimeMS / (1000*60); // Sort on minutes so it doesn't constantly resort the list. + int v2 = pInfo2->m_LiveTimeMS / (1000*60); + if ( v2 > v1 ) + return 1; + else if ( v2 < v1 ) + return -1; + else + return 0; +} + +static int CALLBACK SortByWorkerAppRunningTime( LPARAM iItem1, LPARAM iItem2, LPARAM lpParam ) +{ + CServiceInfo *pInfo1 = (CServiceInfo*)iItem1; + CServiceInfo *pInfo2 = (CServiceInfo*)iItem2; + + int v1 = pInfo1->m_WorkerAppTimeMS / (1000*60); // Sort on minutes so it doesn't constantly resort the list. + int v2 = pInfo2->m_WorkerAppTimeMS / (1000*60); + if ( v2 > v1 ) + return 1; + else if ( v2 < v1 ) + return -1; + else + return 0; +} + +static int CALLBACK SortByMasterName( LPARAM iItem1, LPARAM iItem2, LPARAM lpParam ) +{ + CServiceInfo *pInfo1 = (CServiceInfo*)iItem1; + CServiceInfo *pInfo2 = (CServiceInfo*)iItem2; + + return -strcmp( pInfo2->m_MasterName, pInfo1->m_MasterName ); +} + +static int CALLBACK SortByProtocol( LPARAM iItem1, LPARAM iItem2, LPARAM lpParam ) +{ + CServiceInfo *pInfo1 = (CServiceInfo*)iItem1; + CServiceInfo *pInfo2 = (CServiceInfo*)iItem2; + + return pInfo1->m_ProtocolVersion > pInfo2->m_ProtocolVersion; +} + +static int CALLBACK SortByPassword( LPARAM iItem1, LPARAM iItem2, LPARAM lpParam ) +{ + CServiceInfo *pInfo1 = (CServiceInfo*)iItem1; + CServiceInfo *pInfo2 = (CServiceInfo*)iItem2; + + return -strcmp( pInfo2->m_Password, pInfo1->m_Password ); +} + +static int CALLBACK SortByServiceVersion( LPARAM iItem1, LPARAM iItem2, LPARAM lpParam ) +{ + CServiceInfo *pInfo1 = (CServiceInfo*)iItem1; + CServiceInfo *pInfo2 = (CServiceInfo*)iItem2; + + return -strcmp( pInfo2->m_ServiceVersion, pInfo1->m_ServiceVersion ); +} + +static int CALLBACK SortByExe( LPARAM iItem1, LPARAM iItem2, LPARAM lpParam ) +{ + CServiceInfo *pInfo1 = (CServiceInfo*)iItem1; + CServiceInfo *pInfo2 = (CServiceInfo*)iItem2; + + return -strcmp( pInfo2->m_ExeName, pInfo1->m_ExeName ); +} + +static int CALLBACK SortByMap( LPARAM iItem1, LPARAM iItem2, LPARAM lpParam ) +{ + CServiceInfo *pInfo1 = (CServiceInfo*)iItem1; + CServiceInfo *pInfo2 = (CServiceInfo*)iItem2; + + return -strcmp( pInfo2->m_MapName, pInfo1->m_MapName ); +} + +static int CALLBACK SortByCPUPercentage( LPARAM iItem1, LPARAM iItem2, LPARAM lpParam ) +{ + CServiceInfo *pInfo1 = (CServiceInfo*)iItem1; + CServiceInfo *pInfo2 = (CServiceInfo*)iItem2; + + if ( pInfo2->m_CPUPercentage > pInfo1->m_CPUPercentage ) + return 1; + else if ( pInfo2->m_CPUPercentage < pInfo1->m_CPUPercentage ) + return -1; + else + return 0; +} + +static int CALLBACK SortByMemUsage( LPARAM iItem1, LPARAM iItem2, LPARAM lpParam ) +{ + CServiceInfo *pInfo1 = (CServiceInfo*)iItem1; + CServiceInfo *pInfo2 = (CServiceInfo*)iItem2; + + if ( pInfo2->m_MemUsageMB > pInfo1->m_MemUsageMB ) + return 1; + else if ( pInfo2->m_MemUsageMB < pInfo1->m_MemUsageMB ) + return -1; + else + return 0; +} + +// --------------------------------------------------------------------------------------------------------- // +// Column information. +// --------------------------------------------------------------------------------------------------------- // + +struct +{ + char *pText; + int width; + ServicesSortFn sortFn; +} g_ColumnInfos[] = +{ + {"Computer Name", 150, SortByName}, + {"Status", 95, SortByStatus}, + {"Service Run Time", 100, SortByRunningTime}, + {"Worker App Run Time", 125, SortByWorkerAppRunningTime}, + {"Master", 150, SortByMasterName}, + {"Password", 60, SortByPassword}, + {"Protocol", 60, SortByProtocol}, + {"Version", 50, SortByServiceVersion}, + {"CPU", 50, SortByCPUPercentage}, + {"Memory (MB)", 80, SortByMemUsage}, + {"Exe", 80, SortByExe}, + {"Map", 90, SortByMap}, +}; +#define COLUMN_COMPUTER_NAME 0 +#define COLUMN_STATUS 1 +#define COLUMN_RUNNING_TIME 2 +#define COLUMN_WORKER_APP_RUNNING_TIME 3 +#define COLUMN_MASTER_NAME 4 +#define COLUMN_PASSWORD 5 +#define COLUMN_PROTOCOL_VERSION 6 +#define COLUMN_SERVICE_VERSION 7 +#define COLUMN_CPU_PERCENTAGE 8 +#define COLUMN_MEM_USAGE 9 +#define COLUMN_EXE_NAME 10 +#define COLUMN_MAP_NAME 11 + + +// Used to sort all the columns. +// When they click on a column, we add that index to entry 0 in here. +// Then when sorting, if 2 columns are equal, we move to the next sort function. +CUtlVector<int> g_SortColumns; + +static void PushSortColumn( int iColumn ) +{ + // First, get rid of all entries with this same index. + int iPrev = g_SortColumns.Find( iColumn ); + if ( iPrev != g_SortColumns.InvalidIndex() ) + g_SortColumns.Remove( iPrev ); + + // Now add this one. + g_SortColumns.AddToTail( iColumn ); +} + +static int CALLBACK MainSortFn( LPARAM iItem1, LPARAM iItem2, LPARAM lpParam ) +{ + int curStatus = 0; + for ( int i = (int)g_SortColumns.Count()-1; i >= 0; i-- ) + { + curStatus = g_ColumnInfos[g_SortColumns[i]].sortFn( iItem1, iItem2, lpParam ); + if ( curStatus != 0 ) + break; + } + return curStatus; +} + + +///////////////////////////////////////////////////////////////////////////// +// CServicesDlg dialog + + +CServicesDlg::CServicesDlg(CWnd* pParent /*=NULL*/) + : CIdleDialog(CServicesDlg::IDD, pParent) +{ + //{{AFX_DATA_INIT(CServicesDlg) + // NOTE: the ClassWizard will add member initialization here + //}}AFX_DATA_INIT + m_pServicesPingSocket = NULL; +} + + +void CServicesDlg::DoDataExchange(CDataExchange* pDX) +{ + CDialog::DoDataExchange(pDX); + //{{AFX_DATA_MAP(CServicesDlg) + DDX_Control(pDX, IDC_NUM_SERVICES, m_NumServicesControl); + DDX_Control(pDX, IDC_NUM_DISABLED_SERVICES, m_NumDisabledServicesControl); + DDX_Control(pDX, IDC_NUM_WORKING_SERVICES, m_NumWorkingServicesControl); + DDX_Control(pDX, IDC_NUM_WAITING_SERVICES, m_NumWaitingServicesControl); + DDX_Control(pDX, IDC_NUM_OFF_SERVICES, m_NumOffServicesControl); + DDX_Control(pDX, IDC_CURRENT_PASSWORD, m_PasswordDisplay); + DDX_Control(pDX, IDC_SERVICES_LIST, m_ServicesList); + //}}AFX_DATA_MAP +} + + +BEGIN_MESSAGE_MAP(CServicesDlg, CIdleDialog) + //{{AFX_MSG_MAP(CServicesDlg) + ON_BN_CLICKED(ID_PATCH_SERVICES, OnPatchServices) + ON_BN_CLICKED(ID_STOP_SERVICES, OnStopServices) + ON_BN_CLICKED(ID_STOP_JOBS, OnStopJobs) + ON_BN_CLICKED(ID_FILTER_BY_PASSWORD, OnFilterByPassword) + ON_BN_CLICKED(ID_FORCE_PASSWORD, OnForcePassword) + ON_BN_CLICKED(ID_COPY_TO_CLIPBOARD, OnCopyToClipboard) + ON_NOTIFY(NM_DBLCLK, IDC_SERVICES_LIST, OnDblclkServicesList) + ON_WM_SIZE() + //}}AFX_MSG_MAP +END_MESSAGE_MAP() + +///////////////////////////////////////////////////////////////////////////// +// CServicesDlg message handlers + +BOOL CServicesDlg::OnInitDialog() +{ + CDialog::OnInitDialog(); + + // Initially, just sort by computer name. + PushSortColumn( COLUMN_COMPUTER_NAME ); + + HICON hIcon = LoadIcon( AfxGetInstanceHandle(), MAKEINTRESOURCE( IDR_MAINFRAME ) ); + SetIcon( hIcon, true ); + + m_ServicesList.SetExtendedStyle( LVS_EX_FULLROWSELECT ); + + // Setup the headers. + for ( int i=0; i < ARRAYSIZE( g_ColumnInfos ); i++ ) + { + m_ServicesList.InsertColumn( i, g_ColumnInfos[i].pText, LVCFMT_LEFT, g_ColumnInfos[i].width, i ); + } + + m_pServicesPingSocket = CreateIPSocket(); + if ( m_pServicesPingSocket ) + { + m_pServicesPingSocket->BindToAny( 0 ); + } + + m_dwLastServicesPing = GetTickCount() - SERVICES_PING_INTERVAL; + StartIdleProcessing( 100 ); // get idle messages every half second + + m_AnchorMgr.AddAnchor( this, GetDlgItem( IDC_NUM_SERVICES_LABEL ), ANCHOR_LEFT, ANCHOR_BOTTOM, ANCHOR_LEFT, ANCHOR_BOTTOM ); + m_AnchorMgr.AddAnchor( this, GetDlgItem( IDC_NUM_SERVICES ), ANCHOR_LEFT, ANCHOR_BOTTOM, ANCHOR_LEFT, ANCHOR_BOTTOM ); + + m_AnchorMgr.AddAnchor( this, GetDlgItem( IDC_NUM_DISABLED_SERVICES_LABEL ), ANCHOR_LEFT, ANCHOR_BOTTOM, ANCHOR_LEFT, ANCHOR_BOTTOM ); + m_AnchorMgr.AddAnchor( this, GetDlgItem( IDC_NUM_DISABLED_SERVICES ), ANCHOR_LEFT, ANCHOR_BOTTOM, ANCHOR_LEFT, ANCHOR_BOTTOM ); + + m_AnchorMgr.AddAnchor( this, GetDlgItem( IDC_NUM_WORKING_SERVICES_LABEL ), ANCHOR_LEFT, ANCHOR_BOTTOM, ANCHOR_LEFT, ANCHOR_BOTTOM ); + m_AnchorMgr.AddAnchor( this, GetDlgItem( IDC_NUM_WORKING_SERVICES ), ANCHOR_LEFT, ANCHOR_BOTTOM, ANCHOR_LEFT, ANCHOR_BOTTOM ); + + m_AnchorMgr.AddAnchor( this, GetDlgItem( IDC_NUM_WAITING_SERVICES_LABEL ), ANCHOR_LEFT, ANCHOR_BOTTOM, ANCHOR_LEFT, ANCHOR_BOTTOM ); + m_AnchorMgr.AddAnchor( this, GetDlgItem( IDC_NUM_WAITING_SERVICES ), ANCHOR_LEFT, ANCHOR_BOTTOM, ANCHOR_LEFT, ANCHOR_BOTTOM ); + + m_AnchorMgr.AddAnchor( this, GetDlgItem( IDC_NUM_OFF_SERVICES_LABEL ), ANCHOR_LEFT, ANCHOR_BOTTOM, ANCHOR_LEFT, ANCHOR_BOTTOM ); + m_AnchorMgr.AddAnchor( this, GetDlgItem( IDC_NUM_OFF_SERVICES ), ANCHOR_LEFT, ANCHOR_BOTTOM, ANCHOR_LEFT, ANCHOR_BOTTOM ); + + m_AnchorMgr.AddAnchor( this, GetDlgItem( IDC_CURRENT_PASSWORD_LABEL ), ANCHOR_LEFT, ANCHOR_BOTTOM, ANCHOR_LEFT, ANCHOR_BOTTOM ); + m_AnchorMgr.AddAnchor( this, GetDlgItem( IDC_CURRENT_PASSWORD ), ANCHOR_LEFT, ANCHOR_BOTTOM, ANCHOR_LEFT, ANCHOR_BOTTOM ); + m_AnchorMgr.AddAnchor( this, GetDlgItem( ID_PATCH_SERVICES ), ANCHOR_LEFT, ANCHOR_BOTTOM, ANCHOR_LEFT, ANCHOR_BOTTOM ); + m_AnchorMgr.AddAnchor( this, GetDlgItem( ID_STOP_SERVICES ), ANCHOR_LEFT, ANCHOR_BOTTOM, ANCHOR_LEFT, ANCHOR_BOTTOM ); + m_AnchorMgr.AddAnchor( this, GetDlgItem( ID_STOP_JOBS ), ANCHOR_LEFT, ANCHOR_BOTTOM, ANCHOR_LEFT, ANCHOR_BOTTOM ); + m_AnchorMgr.AddAnchor( this, GetDlgItem( ID_FORCE_PASSWORD ), ANCHOR_LEFT, ANCHOR_BOTTOM, ANCHOR_LEFT, ANCHOR_BOTTOM ); + m_AnchorMgr.AddAnchor( this, GetDlgItem( ID_FILTER_BY_PASSWORD ), ANCHOR_LEFT, ANCHOR_BOTTOM, ANCHOR_LEFT, ANCHOR_BOTTOM ); + + m_AnchorMgr.AddAnchor( this, GetDlgItem( ID_COPY_TO_CLIPBOARD ), ANCHOR_LEFT, ANCHOR_BOTTOM, ANCHOR_LEFT, ANCHOR_BOTTOM ); + + m_AnchorMgr.AddAnchor( this, GetDlgItem( IDC_SERVICES_LIST ), ANCHOR_LEFT, ANCHOR_TOP, ANCHOR_RIGHT, ANCHOR_BOTTOM ); + + // Unless they specify admin mode, hide all the controls that can mess with the services. + if ( !FindArg( "-Admin" ) ) + { + ::ShowWindow( ::GetDlgItem( m_hWnd, ID_PATCH_SERVICES ), SW_HIDE ); + ::ShowWindow( ::GetDlgItem( m_hWnd, ID_STOP_SERVICES ), SW_HIDE ); + ::ShowWindow( ::GetDlgItem( m_hWnd, ID_STOP_JOBS ), SW_HIDE ); + ::ShowWindow( ::GetDlgItem( m_hWnd, ID_FORCE_PASSWORD ), SW_HIDE ); + } + + m_NetViewThread.Init(); + + return TRUE; // return TRUE unless you set the focus to a control + // EXCEPTION: OCX Property Pages should return FALSE +} + + +void CServicesDlg::BuildVMPIPingPacket( CUtlVector<char> &out, char cPacketID, unsigned char protocolVersion, bool bIgnorePassword ) +{ + out.Purge(); + out.AddToTail( protocolVersion ); + + const char *pPassword = m_Password; + if ( pPassword[0] == 0 || bIgnorePassword ) + { + // If they haven't set a password to filter by, then we want all services to report in. + out.AddToTail( VMPI_PASSWORD_OVERRIDE ); + out.AddToTail( 0 ); + } + else + { + out.AddMultipleToTail( strlen( pPassword ) + 1, pPassword ); // password. + } + + out.AddToTail( cPacketID ); +} + + +void CServicesDlg::UpdateServicesFromNetMessages() +{ + while ( 1 ) + { + char in[1024]; + CIPAddr ipFrom; + + int len = m_pServicesPingSocket->RecvFrom( in, sizeof( in ), &ipFrom ); + if ( len < 4 ) + break; + + bf_read buf( in, len ); + unsigned char protocolVersion = buf.ReadByte(); + if ( protocolVersion == 4 || protocolVersion == VMPI_PROTOCOL_VERSION ) // Protocol version 4 is almost the same. + { + int packetID = buf.ReadByte(); + if ( packetID == VMPI_PING_RESPONSE ) + { + int iState = buf.ReadByte(); + unsigned long liveTimeMS = (unsigned long)buf.ReadLong(); + + int iPort = buf.ReadLong(); + char computerName[512]; + buf.ReadString( computerName, sizeof( computerName ) ); + + char masterName[512]; + if ( buf.GetNumBitsLeft() ) + buf.ReadString( masterName, sizeof( masterName ) ); + else + masterName[0] = 0; + + unsigned long workerAppTimeMS = 0; + if ( buf.GetNumBitsLeft() ) + workerAppTimeMS = buf.ReadLong(); + + char password[512] = {0}; + if ( protocolVersion == VMPI_PROTOCOL_VERSION ) + buf.ReadString( password, sizeof( password ) ); + + char serviceVersion[32]; + if ( protocolVersion == VMPI_PROTOCOL_VERSION ) + buf.ReadString( serviceVersion, sizeof( serviceVersion ) ); + else + V_strncpy( serviceVersion, "old", sizeof( serviceVersion ) ); + + int cpuPercentage = -1; + if ( buf.GetNumBytesLeft() >= 1 ) + cpuPercentage = buf.ReadByte(); + + char exeName[512]; + if ( buf.GetNumBytesLeft() >= 1 ) + buf.ReadString( exeName, sizeof( exeName ) ); + else + V_strncpy( exeName, "-", sizeof( exeName ) ); + + short memUsage = -1; + if ( buf.GetNumBytesLeft() >= 2 ) + memUsage = buf.ReadShort(); + + char mapName[256]; + if ( buf.GetNumBytesLeft() >= 1 ) + buf.ReadString( mapName, sizeof( mapName ) ); + else + V_strncpy( mapName, "-", sizeof( mapName ) ); + + + CServiceInfo *pInfo = FindServiceByComputerName( computerName ); + if ( !pInfo ) + { + pInfo = new CServiceInfo; + m_Services.AddToTail( pInfo ); + pInfo->m_ComputerName = computerName; + + pInfo->m_pLastStatusText = NULL; + + pInfo->m_Addr.port = iPort; + pInfo->m_LastPingTimeMS = Plat_MSTime(); + pInfo->m_MasterName = "?"; + + int iItem = m_ServicesList.InsertItem( COLUMN_COMPUTER_NAME, pInfo->m_ComputerName, NULL ); + m_ServicesList.SetItemData( iItem, (DWORD)pInfo ); + + // Update the display of # of services. + UpdateServiceCountDisplay(); + } + + pInfo->m_ProtocolVersion = protocolVersion; + V_strncpy( pInfo->m_ServiceVersion, serviceVersion, sizeof( pInfo->m_ServiceVersion ) ); + pInfo->m_Addr = ipFrom; + pInfo->m_CPUPercentage = cpuPercentage; + pInfo->m_MemUsageMB = memUsage; + pInfo->m_ExeName = exeName; + pInfo->m_MapName = mapName; + pInfo->m_MasterName = masterName; + pInfo->m_LiveTimeMS = liveTimeMS; + pInfo->m_WorkerAppTimeMS = workerAppTimeMS; + pInfo->m_iState = iState; + pInfo->m_LastPingTimeMS = Plat_MSTime(); + pInfo->m_Password = password; + + UpdateServiceInListbox( pInfo ); + } + } + } +} + + +void CServicesDlg::UpdateServicesFromNetView() +{ + CUtlVector<char*> computerNames; + m_NetViewThread.GetComputerNames( computerNames ); + + for ( int i=0; i < computerNames.Count(); i++ ) + { + CServiceInfo *pInfo = FindServiceByComputerName( computerNames[i] ); + if ( !pInfo ) + { + pInfo = new CServiceInfo; + m_Services.AddToTail( pInfo ); + pInfo->m_ComputerName = computerNames[i]; + pInfo->m_LastPingTimeMS = Plat_MSTime() - SERVICE_OFF_TIMEOUT*2; // so it's marked as "off" + pInfo->m_LastLiveTimeMS = Plat_MSTime(); + pInfo->m_LiveTimeMS = 0; + pInfo->m_WorkerAppTimeMS = 0; + pInfo->m_ProtocolVersion = 0; + pInfo->m_ServiceVersion[0] = 0; + pInfo->m_CPUPercentage = -1; + pInfo->m_MemUsageMB = -1; + + int iItem = m_ServicesList.InsertItem( COLUMN_COMPUTER_NAME, pInfo->m_ComputerName, NULL ); + m_ServicesList.SetItemData( iItem, (DWORD)pInfo ); + + // Update the display of # of services. + UpdateServiceCountDisplay(); + + UpdateServiceInListbox( pInfo ); + } + } + + computerNames.PurgeAndDeleteElements(); +} + + +void CServicesDlg::OnIdle() +{ + DWORD curTime = GetTickCount(); + + if ( !m_pServicesPingSocket ) + return; + + // Broadcast out to all the services? + if ( curTime - m_dwLastServicesPing >= SERVICES_PING_INTERVAL ) + { + m_dwLastServicesPing = curTime; + + for ( int i=VMPI_SERVICE_PORT; i <= VMPI_LAST_SERVICE_PORT; i++ ) + { + CUtlVector<char> data; + BuildVMPIPingPacket( data, VMPI_PING_REQUEST ); + m_pServicesPingSocket->Broadcast( data.Base(), data.Count(), i ); + + // Also send out a version 4 one because we understand a version 4 response. + BuildVMPIPingPacket( data, VMPI_PING_REQUEST, 4 ); + m_pServicesPingSocket->Broadcast( data.Base(), data.Count(), i ); + } + + UpdateServiceCountDisplay(); + } + + m_ServicesList.SetRedraw( false ); + + // Check for messages from services. + UpdateServicesFromNetMessages(); + + // Issue a "net view" command, parse the output, and add any computers it lists. + // This lets us figure out which PCs on the network are not running the service. + UpdateServicesFromNetView(); + + + FOR_EACH_LL( m_Services, iService ) + { + CServiceInfo *pInfo = m_Services[iService]; + if ( Plat_MSTime() - pInfo->m_LastUpdateTime > SERVICE_MAX_UPDATE_INTERVAL ) + { + UpdateServiceInListbox( pInfo ); + } + } + + if ( m_bListChanged ) + { + ResortItems(); + m_bListChanged = false; + } + + m_ServicesList.SetRedraw( true ); +} + + +CServiceInfo* CServicesDlg::FindServiceByComputerName( const char *pComputerName ) +{ + FOR_EACH_LL( m_Services, i ) + { + if ( Q_stricmp( m_Services[i]->m_ComputerName, pComputerName ) == 0 ) + return m_Services[i]; + } + return NULL; +} + + +void CServicesDlg::SendToSelectedServices( const char *pData, int len ) +{ + POSITION pos = m_ServicesList.GetFirstSelectedItemPosition(); + while ( pos ) + { + int iItem = m_ServicesList.GetNextSelectedItem( pos ); + + CServiceInfo *pInfo = (CServiceInfo*)m_ServicesList.GetItemData( iItem ); + m_pServicesPingSocket->SendTo( &pInfo->m_Addr, pData, len ); + } +} + + +void UpdateItemText( CListCtrl &ctrl, int iItem, int iColumn, const char *pNewVal ) +{ + CString str = ctrl.GetItemText( iItem, iColumn ); + if ( V_stricmp( str, pNewVal ) != 0 ) + ctrl.SetItemText( iItem, iColumn, pNewVal ); +} + + +void CServicesDlg::UpdateServiceInListbox( CServiceInfo *pInfo ) +{ + // First, find this item in the listbox. + LVFINDINFO info; + info.flags = LVFI_PARAM; + info.lParam = (LPARAM)pInfo; + int iItem = m_ServicesList.FindItem( &info ); + if ( iItem != -1 ) + { + UpdateItemText( m_ServicesList, iItem, COLUMN_COMPUTER_NAME, pInfo->m_ComputerName ); + + const char *pText = GetStatusString( pInfo ); + UpdateItemText( m_ServicesList, iItem, COLUMN_STATUS, pText ); + + char timeStr[512]; + FormatTimeString( pInfo->m_LiveTimeMS / 1000, timeStr, sizeof( timeStr ) ); + UpdateItemText( m_ServicesList, iItem, COLUMN_RUNNING_TIME, timeStr ); + + FormatTimeString( pInfo->m_WorkerAppTimeMS / 1000, timeStr, sizeof( timeStr ) ); + UpdateItemText( m_ServicesList, iItem, COLUMN_WORKER_APP_RUNNING_TIME, timeStr ); + + UpdateItemText( m_ServicesList, iItem, COLUMN_MASTER_NAME, pInfo->m_MasterName ); + + char str[512]; + V_snprintf( str, sizeof( str ), "%d", pInfo->m_ProtocolVersion ); + UpdateItemText( m_ServicesList, iItem, COLUMN_PROTOCOL_VERSION, str ); + + UpdateItemText( m_ServicesList, iItem, COLUMN_PASSWORD, pInfo->m_Password ); + UpdateItemText( m_ServicesList, iItem, COLUMN_SERVICE_VERSION, pInfo->m_ServiceVersion ); + + if ( pInfo->m_CPUPercentage == -1 ) + V_snprintf( str, sizeof( str ), "-" ); + else if ( pInfo->m_CPUPercentage == 101 ) + V_snprintf( str, sizeof( str ), "(err)" ); + else + V_snprintf( str, sizeof( str ), "%d%%", pInfo->m_CPUPercentage ); + UpdateItemText( m_ServicesList, iItem, COLUMN_CPU_PERCENTAGE, str ); + + UpdateItemText( m_ServicesList, iItem, COLUMN_EXE_NAME, pInfo->m_ExeName ); + UpdateItemText( m_ServicesList, iItem, COLUMN_MAP_NAME, pInfo->m_MapName ); + + if ( pInfo->m_MemUsageMB == -1 ) + V_snprintf( str, sizeof( str ), "-" ); + else + V_snprintf( str, sizeof( str ), "%d", pInfo->m_MemUsageMB ); + UpdateItemText( m_ServicesList, iItem, COLUMN_MEM_USAGE, str ); + + pInfo->m_pLastStatusText = pText; + pInfo->m_LastLiveTimeMS = pInfo->m_LiveTimeMS; + pInfo->m_LastMasterName = pInfo->m_MasterName; + pInfo->m_LastUpdateTime = Plat_MSTime(); + + // Detect changes. + if ( !m_bListChanged && iItem > 0 ) + { + CServiceInfo *pPrevItem = (CServiceInfo*)m_ServicesList.GetItemData( iItem-1 ); + if ( pPrevItem && MainSortFn( (LPARAM)pPrevItem, (LPARAM)pInfo, NULL ) > 0 ) + m_bListChanged = true; + } + + if ( !m_bListChanged && (iItem+1) < m_ServicesList.GetItemCount() ) + { + CServiceInfo *pNextItem = (CServiceInfo*)m_ServicesList.GetItemData( iItem+1 ); + if ( pNextItem && MainSortFn( (LPARAM)pInfo, (LPARAM)pNextItem, NULL ) > 0 ) + m_bListChanged = true; + } + } +} + + +void CServicesDlg::ResortItems() +{ + m_ServicesList.SortItems( MainSortFn, (LPARAM)this ); +} + + +void CServicesDlg::UpdateServiceCountDisplay() +{ + char str[512]; + Q_snprintf( str, sizeof( str ), "%d", m_Services.Count() ); + m_NumServicesControl.SetWindowText( str ); + + // Now count the various types. + int nDisabled = 0, nWorking = 0, nWaiting = 0, nOff = 0; + FOR_EACH_LL( m_Services, i ) + { + if ( m_Services[i]->IsOff() ) + { + ++nOff; + } + else if ( m_Services[i]->m_iState == VMPI_STATE_BUSY || m_Services[i]->m_iState == VMPI_STATE_DOWNLOADING ) + { + ++nWorking; + } + else if ( m_Services[i]->m_iState == VMPI_STATE_IDLE ) + { + ++nWaiting; + } + else + { + ++nDisabled; + } + } + + Q_snprintf( str, sizeof( str ), "%d", nDisabled ); + m_NumDisabledServicesControl.SetWindowText( str ); + + Q_snprintf( str, sizeof( str ), "%d", nWorking ); + m_NumWorkingServicesControl.SetWindowText( str ); + + Q_snprintf( str, sizeof( str ), "%d", nWaiting ); + m_NumWaitingServicesControl.SetWindowText( str ); + + Q_snprintf( str, sizeof( str ), "%d", nOff ); + m_NumOffServicesControl.SetWindowText( str ); +} + + +// This monstrosity is here because of the way they bundle string resources into groups in an exe file. +// See http://support.microsoft.com/kb/q196774/. +bool FindStringResourceEx( HINSTANCE hinst, UINT uId, UINT langId, char *pStr, int outLen ) +{ + // Convert the string ID into a bundle number + bool bRet = false; + HRSRC hrsrc = FindResourceEx(hinst, RT_STRING, MAKEINTRESOURCE(uId / 16 + 1), langId); + if (hrsrc) + { + HGLOBAL hglob = LoadResource(hinst, hrsrc); + if (hglob) + { + LPCWSTR pwsz = reinterpret_cast<LPCWSTR>( LockResource(hglob) ); + if (pwsz) + { + // okay now walk the string table + for (UINT i = 0; i < (uId & 15); i++) + { + pwsz += 1 + (UINT)*pwsz; + } + + // First word in the resource is the length and the rest is the data. + int nChars = min( (int)pwsz[0], outLen-1 ); + ++pwsz; + V_wcstostr( pwsz, nChars, pStr, outLen ); + pStr[nChars] = 0; + bRet = true; + } + FreeResource(hglob); + } + } + return bRet; +} + + +int CheckServiceVersion( const char *pPatchDir, char *pServiceVersion, int maxServiceVersionLen ) +{ + char filename[MAX_PATH]; + V_ComposeFileName( pPatchDir, "vmpi_service.exe", filename, sizeof( filename ) ); + + int ret = IDCANCEL; + HINSTANCE hInst = LoadLibrary( filename ); + if ( hInst ) + { + bool bFound = FindStringResourceEx( hInst, VMPI_SERVICE_IDS_VERSION_STRING, MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), pServiceVersion, maxServiceVersionLen ); + if ( bFound ) + { + ret = V_AfxMessageBox( MB_YESNOCANCEL, "Service version in %s is %s.\n\nIs this correct?", filename, pServiceVersion ); + } + else + { + V_AfxMessageBox( MB_OK, "Can't get IDS_VERSION_STRING resource from %s.", filename ); + } + + FreeLibrary( hInst ); + } + else + { + V_AfxMessageBox( MB_OK, "Can't load %s to get service version.", filename ); + } + + return ret; +} + +void CServicesDlg::OnPatchServices() +{ + // Inquire about the timeout. + CPatchTimeout dlg; + dlg.m_PatchDirectory = "\\\\fileserver\\vmpi\\testservice"; + dlg.m_VMPITransferDirectory = dlg.m_PatchDirectory; + dlg.m_bForcePatch = false; + +TryAgain:; + + if ( dlg.DoModal() == IDOK ) + { + // Launch the transfer app. + char commandLine[32 * 1024] = {0}; + + char transferExe[MAX_PATH]; + V_ComposeFileName( dlg.m_VMPITransferDirectory, "vmpi_transfer.exe", transferExe, sizeof( transferExe ) ); + if ( _access( transferExe, 0 ) != 0 ) + { + V_AfxMessageBox( MB_OK, "Can't find '%s' to run the patch.", transferExe ); + goto TryAgain; + } + + char strServiceVersion[64]; + int ret = CheckServiceVersion( dlg.m_PatchDirectory, strServiceVersion, sizeof( strServiceVersion ) ); + if ( ret == IDCANCEL ) + return; + else if ( ret == IDNO ) + goto TryAgain; + + AppendStr( commandLine, sizeof( commandLine ), "\"%s\" -PatchHost", transferExe ); + AppendStr( commandLine, sizeof( commandLine ), " -mpi_PatchVersion %s", strServiceVersion ); + AppendStr( commandLine, sizeof( commandLine ), " -mpi_PatchDirectory \"%s\"", (const char*)dlg.m_PatchDirectory ); + + if ( dlg.m_bForcePatch ) + AppendStr( commandLine, sizeof( commandLine ), " -mpi_ForcePatch" ); + + // Collect the list of addresses. + CUtlVector<CIPAddr> addrs; + POSITION pos = m_ServicesList.GetFirstSelectedItemPosition(); + while ( pos ) + { + int iItem = m_ServicesList.GetNextSelectedItem( pos ); + + CServiceInfo *pInfo = (CServiceInfo*)m_ServicesList.GetItemData( iItem ); + if ( pInfo->m_Addr.ip[0] != 0 ) // "off" services won't have an IP + addrs.AddToTail( pInfo->m_Addr ); + } + if ( addrs.Count() == 0 ) + { + AfxMessageBox( "No workers selected, or they all are off." ); + return; + } + + AppendStr( commandLine, sizeof( commandLine ), " -mpi_PatchWorkers %d", addrs.Count() ); + for ( int i=0; i < addrs.Count(); i++ ) + { + AppendStr( commandLine, sizeof( commandLine ), " %d.%d.%d.%d", addrs[i].ip[0], addrs[i].ip[1], addrs[i].ip[2], addrs[i].ip[3] ); + } + + STARTUPINFO si; + memset( &si, 0, sizeof( si ) ); + si.cb = sizeof( si ); + + PROCESS_INFORMATION pi; + memset( &pi, 0, sizeof( pi ) ); + + if ( CreateProcess( NULL, commandLine, + NULL, NULL, false, + 0, + NULL, + (const char *)dlg.m_PatchDirectory, + &si, + &pi ) ) + { + CloseHandle( pi.hProcess ); + CloseHandle( pi.hThread ); + + V_AfxMessageBox( MB_OK, "Patch master successfully started.\nServices patching now.\nClose the patch master console app when finished." ); + } + else + { + V_AfxMessageBox( MB_OK, "Error starting patch master: %s", GetLastErrorString() ); + } + } +} + + +void CServicesDlg::OnStopServices() +{ + if ( MessageBox( "Warning: if you stop these services, you won't be able to control them from this application, and must restart them manually. Contine?", "Warning", MB_YESNO ) == IDYES ) + { + CUtlVector<char> data; + BuildVMPIPingPacket( data, VMPI_STOP_SERVICE ); + SendToSelectedServices( data.Base(), data.Count() ); + } +} + +void CServicesDlg::OnStopJobs() +{ + CUtlVector<char> data; + BuildVMPIPingPacket( data, VMPI_KILL_PROCESS ); + SendToSelectedServices( data.Base(), data.Count() ); +} + + +void CServicesDlg::OnFilterByPassword() +{ + CSetPasswordDlg dlg( IDD_SET_PASSWORD ); + dlg.m_Password = m_Password; + + if ( dlg.DoModal() == IDOK ) + { + m_Password = dlg.m_Password; + m_PasswordDisplay.SetWindowText( m_Password ); + + m_Services.PurgeAndDeleteElements(); + m_ServicesList.DeleteAllItems(); + + UpdateServiceCountDisplay(); + + // Re-ping everyone immediately. + m_dwLastServicesPing = GetTickCount() - SERVICES_PING_INTERVAL; + } +} + +// This sets a new password on the selected services. +void CServicesDlg::OnForcePassword() +{ + CSetPasswordDlg dlg( IDD_FORCE_PASSWORD ); + dlg.m_Password = "password"; + + if ( dlg.DoModal() == IDOK ) + { + CUtlVector<char> data; + + BuildVMPIPingPacket( data, VMPI_FORCE_PASSWORD_CHANGE, VMPI_PROTOCOL_VERSION, true ); + const char *pNewPassword = dlg.m_Password; + data.AddMultipleToTail( V_strlen( pNewPassword ) + 1, pNewPassword ); + + SendToSelectedServices( data.Base(), data.Count() ); + } +} + +void CServicesDlg::OnDblclkServicesList(NMHDR* pNMHDR, LRESULT* pResult) +{ + POSITION pos = m_ServicesList.GetFirstSelectedItemPosition(); + if ( pos ) + { + int iItem = m_ServicesList.GetNextSelectedItem( pos ); + if ( iItem != -1 ) + { + CServiceInfo *pInfo = (CServiceInfo*)m_ServicesList.GetItemData( iItem ); + if ( pInfo ) + { + // Launch vmpi_browser_job_search and have it auto-select this worker. + char cmdLine[1024]; + Q_snprintf( cmdLine, sizeof( cmdLine ), "vmpi_job_search -SelectWorker %s", (const char*)pInfo->m_ComputerName ); + + STARTUPINFO si; + memset( &si, 0, sizeof( si ) ); + si.cb = sizeof( si ); + + PROCESS_INFORMATION pi; + memset( &pi, 0, sizeof( pi ) ); + + if ( !CreateProcess( + NULL, + (char*)(const char*)cmdLine, + NULL, // security + NULL, + TRUE, + 0, // flags + NULL, // environment + NULL, // current directory + &si, + &pi ) ) + { + char err[512]; + Q_snprintf( err, sizeof( err ), "Can't run '%s'", (LPCTSTR)cmdLine ); + MessageBox( err, "Error", MB_OK ); + } + } + } + } + + *pResult = 0; +} + +void CServicesDlg::OnSize(UINT nType, int cx, int cy) +{ + CIdleDialog::OnSize(nType, cx, cy); + + m_AnchorMgr.UpdateAnchors( this ); +} + + +BOOL CServicesDlg::OnNotify(WPARAM wParam, LPARAM lParam, LRESULT* pResult) +{ + NMHDR *pHdr = (NMHDR*)lParam; + if ( pHdr->idFrom == IDC_SERVICES_LIST ) + { + if ( pHdr->code == LVN_COLUMNCLICK ) + { + LPNMLISTVIEW pListView = (LPNMLISTVIEW)lParam; + + // Now sort by this column. + int iSortColumn = max( 0, min( pListView->iSubItem, (int)ARRAYSIZE( g_ColumnInfos ) - 1 ) ); + PushSortColumn( iSortColumn ); + ResortItems(); + } + } + + return CIdleDialog::OnNotify(wParam, lParam, pResult); +} + + +void CServicesDlg::BuildClipboardText( CUtlVector<char> &clipboardText ) +{ + // Add the header information. + CHeaderCtrl *pHeader = m_ServicesList.GetHeaderCtrl(); + for ( int i=0; i < pHeader->GetItemCount(); i++ ) + { + char tempBuffer[512]; + HDITEM item; + memset( &item, 0, sizeof( item ) ); + item.mask = HDI_TEXT; + item.pszText = tempBuffer; + item.cchTextMax = sizeof( tempBuffer ) - 1; + + if ( !pHeader->GetItem( i, &item ) ) + item.pszText = "<bug>"; + + clipboardText.AddMultipleToTail( strlen( item.pszText ), item.pszText ); + clipboardText.AddToTail( '\t' ); + } + clipboardText.AddMultipleToTail( 2, "\r\n" ); + + // Now add each line of data. + int nItem = -1; + while ( (nItem = m_ServicesList.GetNextItem( nItem, LVNI_ALL )) != -1 ) + { + char tempBuffer[512]; + LVITEM item; + memset( &item, 0, sizeof( item ) ); + item.mask = LVIF_TEXT; + item.iItem = nItem; + item.pszText = tempBuffer; + item.cchTextMax = sizeof( tempBuffer ) - 1; + + for ( int i=0; i < pHeader->GetItemCount(); i++ ) + { + item.iSubItem = i; + if ( !m_ServicesList.GetItem( &item ) ) + { + item.pszText = "<bug>"; + } + + clipboardText.AddMultipleToTail( strlen( item.pszText ), item.pszText ); + clipboardText.AddToTail( '\t' ); + } + clipboardText.AddMultipleToTail( 2, "\r\n" ); + } + clipboardText.AddToTail( 0 ); +} + + +void CServicesDlg::OnCopyToClipboard() +{ + // Open and clear the clipboard. + if ( !OpenClipboard() ) + return; + + EmptyClipboard(); + + // Setup the clipboard text. + CUtlVector<char> clipboardText; + BuildClipboardText( clipboardText ); + + // Put the clipboard text into a global memory object. + HANDLE hMem = GlobalAlloc( GMEM_MOVEABLE, clipboardText.Count() ); + void *ptr = GlobalLock( hMem ); + memcpy( ptr, clipboardText.Base(), clipboardText.Count() ); + GlobalUnlock( hMem ); + + // Put it in the clipboard. + SetClipboardData( CF_TEXT, hMem ); + + // Cleanup. + GlobalFree( hMem ); + CloseClipboard(); +} diff --git a/utils/vmpi/vmpi_services_watch/ServicesDlg.h b/utils/vmpi/vmpi_services_watch/ServicesDlg.h new file mode 100644 index 0000000..8ff35e3 --- /dev/null +++ b/utils/vmpi/vmpi_services_watch/ServicesDlg.h @@ -0,0 +1,150 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +#if !defined(AFX_SERVICESDLG_H__FD755233_0A7A_4CBB_BA5E_A5D0B3B5F830__INCLUDED_) +#define AFX_SERVICESDLG_H__FD755233_0A7A_4CBB_BA5E_A5D0B3B5F830__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 +// ServicesDlg.h : header file +// + +#include "iphelpers.h" +#include "idle_dialog.h" +#include "utllinkedlist.h" +#include "resource.h" +#include "window_anchor_mgr.h" +#include "net_view_thread.h" +#include "vmpi_defs.h" + + +class CServiceInfo +{ +public: + + bool IsOff() const; // Returns true if the time since we've heard from this guy is too long. + + +public: + + CString m_ComputerName; + CString m_MasterName; + CString m_Password; + int m_iState; + + // Since the live time is always changing, we only update it every 10 seconds or so. + DWORD m_LiveTimeMS; // How long the service has been running (in milliseconds). + + DWORD m_WorkerAppTimeMS; // How long the worker app has been running (0 if it's not running). + + DWORD m_LastPingTimeMS; // Last time we heard from this machine. Used to detect if the service + // is off or not. + + // Used to detect if we need to re-sort the list. + const char *m_pLastStatusText; + DWORD m_LastLiveTimeMS; + CString m_LastMasterName; + + int m_CPUPercentage; + CString m_ExeName; + CString m_MapName; + int m_MemUsageMB; + + // Last time we updated the service in the listbox.. used to make sure we update its on/off status + // every once in a while. + DWORD m_LastUpdateTime; + + int m_ProtocolVersion; // i.e. the service's VMPI_SERVICE_PROTOCOL_VERSION. + char m_ServiceVersion[32]; // Version string. + + CIPAddr m_Addr; +}; + + + +///////////////////////////////////////////////////////////////////////////// +// CServicesDlg dialog + +class CServicesDlg : public CIdleDialog +{ +// Construction +public: + CServicesDlg(CWnd* pParent = NULL); // standard constructor + +// Dialog Data + //{{AFX_DATA(CServicesDlg) + enum { IDD = IDD_SERVICES }; + CStatic m_NumServicesControl; + CStatic m_NumDisabledServicesControl; + CStatic m_NumWorkingServicesControl; + CStatic m_NumWaitingServicesControl; + CStatic m_NumOffServicesControl; + CStatic m_PasswordDisplay; + CListCtrl m_ServicesList; + //}}AFX_DATA + + +// Overrides + // ClassWizard generated virtual function overrides + //{{AFX_VIRTUAL(CServicesDlg) + protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support + virtual BOOL OnNotify(WPARAM wParam, LPARAM lParam, LRESULT* pResult); + //}}AFX_VIRTUAL + +// Implementation +protected: + void BuildVMPIPingPacket( CUtlVector<char> &out, char cPacketID, unsigned char cProtocolVersion=VMPI_PROTOCOL_VERSION, bool bIgnorePassword=false ); + + virtual void OnIdle(); + + + CServiceInfo* FindServiceByComputerName( const char *pComputerName ); + void SendToSelectedServices( const char *pData, int len ); + void UpdateServiceInListbox( CServiceInfo *pInfo ); + void UpdateServiceCountDisplay(); + void ResortItems(); + + void UpdateServicesFromNetMessages(); + void UpdateServicesFromNetView(); + void BuildClipboardText( CUtlVector<char> &clipboardText ); + + + ISocket *m_pServicesPingSocket; + DWORD m_dwLastServicesPing; // Last time we pinged all the services. + + // Restricts the password so we only see a particular set of VMPI services. + CString m_Password; + + CUtlLinkedList<CServiceInfo*, int> m_Services; + CNetViewThread m_NetViewThread; + + + CWindowAnchorMgr m_AnchorMgr; + + bool m_bListChanged; // Used to detect if we need to re-sort the list. + + // Generated message map functions + //{{AFX_MSG(CServicesDlg) + virtual BOOL OnInitDialog(); + afx_msg void OnPatchServices(); + afx_msg void OnStopServices(); + afx_msg void OnStopJobs(); + afx_msg void OnFilterByPassword(); + afx_msg void OnForcePassword(); + afx_msg void OnCopyToClipboard(); + afx_msg void OnDblclkServicesList(NMHDR* pNMHDR, LRESULT* pResult); + afx_msg void OnSize(UINT nType, int cx, int cy); + //}}AFX_MSG + DECLARE_MESSAGE_MAP() +}; + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_SERVICESDLG_H__FD755233_0A7A_4CBB_BA5E_A5D0B3B5F830__INCLUDED_) diff --git a/utils/vmpi/vmpi_services_watch/SetPasswordDlg.cpp b/utils/vmpi/vmpi_services_watch/SetPasswordDlg.cpp new file mode 100644 index 0000000..ebe0b6a --- /dev/null +++ b/utils/vmpi/vmpi_services_watch/SetPasswordDlg.cpp @@ -0,0 +1,49 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// SetPasswordDlg.cpp : implementation file +// + +#include "stdafx.h" +#include "SetPasswordDlg.h" + +#ifdef _DEBUG +#define new DEBUG_NEW +#undef THIS_FILE +static char THIS_FILE[] = __FILE__; +#endif + +///////////////////////////////////////////////////////////////////////////// +// CSetPasswordDlg dialog + + +CSetPasswordDlg::CSetPasswordDlg(int dlgID, CWnd* pParent /*=NULL*/) + : CDialog(dlgID, pParent) +{ + //{{AFX_DATA_INIT(CSetPasswordDlg) + m_Password = _T(""); + //}}AFX_DATA_INIT +} + + +void CSetPasswordDlg::DoDataExchange(CDataExchange* pDX) +{ + CDialog::DoDataExchange(pDX); + //{{AFX_DATA_MAP(CSetPasswordDlg) + DDX_Text(pDX, IDC_PASSWORD, m_Password); + //}}AFX_DATA_MAP +} + + +BEGIN_MESSAGE_MAP(CSetPasswordDlg, CDialog) + //{{AFX_MSG_MAP(CSetPasswordDlg) + // NOTE: the ClassWizard will add message map macros here + //}}AFX_MSG_MAP +END_MESSAGE_MAP() + +///////////////////////////////////////////////////////////////////////////// +// CSetPasswordDlg message handlers diff --git a/utils/vmpi/vmpi_services_watch/SetPasswordDlg.h b/utils/vmpi/vmpi_services_watch/SetPasswordDlg.h new file mode 100644 index 0000000..f738af1 --- /dev/null +++ b/utils/vmpi/vmpi_services_watch/SetPasswordDlg.h @@ -0,0 +1,54 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +#if !defined(AFX_SETPASSWORDDLG_H__A349B943_49B8_4C7E_863B_BF1929AD5443__INCLUDED_) +#define AFX_SETPASSWORDDLG_H__A349B943_49B8_4C7E_863B_BF1929AD5443__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 +// SetPasswordDlg.h : header file +// + +#include "resource.h" + +///////////////////////////////////////////////////////////////////////////// +// CSetPasswordDlg dialog + +class CSetPasswordDlg : public CDialog +{ +// Construction +public: + CSetPasswordDlg(int dlgID, CWnd* pParent = NULL); // standard constructor + +// Dialog Data + //{{AFX_DATA(CSetPasswordDlg) + CString m_Password; + //}}AFX_DATA + + +// Overrides + // ClassWizard generated virtual function overrides + //{{AFX_VIRTUAL(CSetPasswordDlg) + protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support + //}}AFX_VIRTUAL + +// Implementation +protected: + + // Generated message map functions + //{{AFX_MSG(CSetPasswordDlg) + // NOTE: the ClassWizard will add member functions here + //}}AFX_MSG + DECLARE_MESSAGE_MAP() +}; + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_SETPASSWORDDLG_H__A349B943_49B8_4C7E_863B_BF1929AD5443__INCLUDED_) diff --git a/utils/vmpi/vmpi_services_watch/StdAfx.cpp b/utils/vmpi/vmpi_services_watch/StdAfx.cpp new file mode 100644 index 0000000..5ee32bc --- /dev/null +++ b/utils/vmpi/vmpi_services_watch/StdAfx.cpp @@ -0,0 +1,15 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// stdafx.cpp : source file that includes just the standard includes +// vmpi_browser_services.pch will be the pre-compiled header +// stdafx.obj will contain the pre-compiled type information + +#include "stdafx.h" + + + diff --git a/utils/vmpi/vmpi_services_watch/StdAfx.h b/utils/vmpi/vmpi_services_watch/StdAfx.h new file mode 100644 index 0000000..a73914f --- /dev/null +++ b/utils/vmpi/vmpi_services_watch/StdAfx.h @@ -0,0 +1,35 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, but +// are changed infrequently +// + +#if !defined(AFX_STDAFX_H__BC4FB757_77BB_4E3A_8842_290307F41798__INCLUDED_) +#define AFX_STDAFX_H__BC4FB757_77BB_4E3A_8842_290307F41798__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers + +#include "tier0/wchartypes.h" +#include <afxwin.h> // MFC core and standard components +#include <afxext.h> // MFC extensions +#include <afxdisp.h> // MFC Automation classes +#include <afxdtctl.h> // MFC support for Internet Explorer 4 Common Controls +#ifndef _AFX_NO_AFXCMN_SUPPORT +#include <afxcmn.h> // MFC support for Windows Common Controls +#endif // _AFX_NO_AFXCMN_SUPPORT + + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_STDAFX_H__BC4FB757_77BB_4E3A_8842_290307F41798__INCLUDED_) diff --git a/utils/vmpi/vmpi_services_watch/res/vmpi.ico b/utils/vmpi/vmpi_services_watch/res/vmpi.ico Binary files differnew file mode 100644 index 0000000..09720c0 --- /dev/null +++ b/utils/vmpi/vmpi_services_watch/res/vmpi.ico diff --git a/utils/vmpi/vmpi_services_watch/res/vmpi_browser_services.ico b/utils/vmpi/vmpi_services_watch/res/vmpi_browser_services.ico Binary files differnew file mode 100644 index 0000000..7eef0bc --- /dev/null +++ b/utils/vmpi/vmpi_services_watch/res/vmpi_browser_services.ico diff --git a/utils/vmpi/vmpi_services_watch/res/vmpi_browser_services.rc2 b/utils/vmpi/vmpi_services_watch/res/vmpi_browser_services.rc2 new file mode 100644 index 0000000..a322a2e --- /dev/null +++ b/utils/vmpi/vmpi_services_watch/res/vmpi_browser_services.rc2 @@ -0,0 +1,13 @@ +// +// VMPI_BROWSER_SERVICES.RC2 - resources Microsoft Visual C++ does not edit directly +// + +#ifdef APSTUDIO_INVOKED + #error this file is not editable by Microsoft Visual C++ +#endif //APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// Add manually edited resources here... + +///////////////////////////////////////////////////////////////////////////// diff --git a/utils/vmpi/vmpi_services_watch/resource.h b/utils/vmpi/vmpi_services_watch/resource.h new file mode 100644 index 0000000..1f172da --- /dev/null +++ b/utils/vmpi/vmpi_services_watch/resource.h @@ -0,0 +1,48 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +//{{NO_DEPENDENCIES}} +// Microsoft Visual C++ generated include file. +// Used by vmpi_browser_services.rc +// +#define IDD_VMPI_BROWSER_SERVICES_DIALOG 102 +#define IDR_MAINFRAME 128 +#define IDD_SET_PASSWORD 130 +#define IDD_SERVICES 133 +#define IDD_TIMEOUT 134 +#define IDD_FORCE_PASSWORD 135 +#define IDC_CURRENT_PASSWORD_LABEL 1000 +#define IDC_PASSWORD 1001 +#define IDC_NUM_SERVICES_LABEL 1001 +#define IDC_NUM_DISABLED_SERVICES_LABEL 1002 +#define IDC_COMMAND_LINE 1002 +#define IDC_NUM_WORKING_SERVICES_LABEL 1003 +#define IDC_VMPI_TRANSFER_DIRECTORY 1003 +#define IDC_NUM_WAITING_SERVICES_LABEL 1004 +#define IDC_CHECK1 1004 +#define IDC_FORCE_PATCH 1004 +#define IDC_TIMEOUT_SECONDS 1005 +#define IDC_NUM_OFF_SERVICES_LABEL 1005 +#define IDC_SERVICES_LIST 1009 +#define ID_PATCH_SERVICES 1010 +#define ID_STOP_SERVICES 1011 +#define ID_STOP_JOBS 1012 +#define ID_CHANGE_PASSWORD 1013 +#define ID_FILTER_BY_PASSWORD 1013 +#define IDC_CURRENT_PASSWORD 1014 +#define ID_COPY_TO_CLIPBOARD 1015 +#define IDC_NUM_SERVICES 1016 +#define IDC_NUM_DISABLED_SERVICES 1017 +#define IDC_NUM_WORKING_SERVICES 1018 +#define IDC_NUM_WAITING_SERVICES 1019 +#define IDC_NUM_OFF_SERVICES 1020 +#define ID_FORCE_PASSWORD 1022 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 129 +#define _APS_NEXT_COMMAND_VALUE 32771 +#define _APS_NEXT_CONTROL_VALUE 1005 +#define _APS_NEXT_SYMED_VALUE 101 +#endif +#endif diff --git a/utils/vmpi/vmpi_services_watch/vmpi_browser_services.cpp b/utils/vmpi/vmpi_services_watch/vmpi_browser_services.cpp new file mode 100644 index 0000000..168e4ef --- /dev/null +++ b/utils/vmpi/vmpi_services_watch/vmpi_browser_services.cpp @@ -0,0 +1,81 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// vmpi_browser_services.cpp : Defines the class behaviors for the application. +// + +#include "stdafx.h" +#include "vmpi_browser_services.h" +#include "ServicesDlg.h" + +#ifdef _DEBUG +#define new DEBUG_NEW +#undef THIS_FILE +static char THIS_FILE[] = __FILE__; +#endif + +///////////////////////////////////////////////////////////////////////////// +// CVMPIBrowserServicesApp + +BEGIN_MESSAGE_MAP(CVMPIBrowserServicesApp, CWinApp) + //{{AFX_MSG_MAP(CVMPIBrowserServicesApp) + // NOTE - the ClassWizard will add and remove mapping macros here. + // DO NOT EDIT what you see in these blocks of generated code! + //}}AFX_MSG + ON_COMMAND(ID_HELP, CWinApp::OnHelp) +END_MESSAGE_MAP() + +///////////////////////////////////////////////////////////////////////////// +// CVMPIBrowserServicesApp construction + +CVMPIBrowserServicesApp::CVMPIBrowserServicesApp() +{ + // TODO: add construction code here, + // Place all significant initialization in InitInstance +} + +///////////////////////////////////////////////////////////////////////////// +// The one and only CVMPIBrowserServicesApp object + +CVMPIBrowserServicesApp theApp; + +///////////////////////////////////////////////////////////////////////////// +// CVMPIBrowserServicesApp initialization + +BOOL CVMPIBrowserServicesApp::InitInstance() +{ + AfxEnableControlContainer(); + + // Standard initialization + // If you are not using these features and wish to reduce the size + // of your final executable, you should remove from the following + // the specific initialization routines you do not need. + +#ifdef _AFXDLL + Enable3dControls(); // Call this when using MFC in a shared DLL +#else + Enable3dControlsStatic(); // Call this when linking to MFC statically +#endif + + CServicesDlg dlg; + m_pMainWnd = &dlg; + int nResponse = dlg.DoModal(); + if (nResponse == IDOK) + { + // TODO: Place code here to handle when the dialog is + // dismissed with OK + } + else if (nResponse == IDCANCEL) + { + // TODO: Place code here to handle when the dialog is + // dismissed with Cancel + } + + // Since the dialog has been closed, return FALSE so that we exit the + // application, rather than start the application's message pump. + return FALSE; +} diff --git a/utils/vmpi/vmpi_services_watch/vmpi_browser_services.h b/utils/vmpi/vmpi_services_watch/vmpi_browser_services.h new file mode 100644 index 0000000..6bfe0f8 --- /dev/null +++ b/utils/vmpi/vmpi_services_watch/vmpi_browser_services.h @@ -0,0 +1,56 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// vmpi_browser_services.h : main header file for the VMPI_BROWSER_SERVICES application +// + +#if !defined(AFX_VMPI_BROWSER_SERVICES_H__B03E2165_4E70_48AC_A991_EB0289A3471E__INCLUDED_) +#define AFX_VMPI_BROWSER_SERVICES_H__B03E2165_4E70_48AC_A991_EB0289A3471E__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#ifndef __AFXWIN_H__ + #error include 'stdafx.h' before including this file for PCH +#endif + +#include "resource.h" // main symbols + +///////////////////////////////////////////////////////////////////////////// +// CVMPIBrowserServicesApp: +// See vmpi_browser_services.cpp for the implementation of this class +// + +class CVMPIBrowserServicesApp : public CWinApp +{ +public: + CVMPIBrowserServicesApp(); + +// Overrides + // ClassWizard generated virtual function overrides + //{{AFX_VIRTUAL(CVMPIBrowserServicesApp) + public: + virtual BOOL InitInstance(); + //}}AFX_VIRTUAL + +// Implementation + + //{{AFX_MSG(CVMPIBrowserServicesApp) + // NOTE - the ClassWizard will add and remove member functions here. + // DO NOT EDIT what you see in these blocks of generated code ! + //}}AFX_MSG + DECLARE_MESSAGE_MAP() +}; + + +///////////////////////////////////////////////////////////////////////////// + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_VMPI_BROWSER_SERVICES_H__B03E2165_4E70_48AC_A991_EB0289A3471E__INCLUDED_) diff --git a/utils/vmpi/vmpi_services_watch/vmpi_browser_services.rc b/utils/vmpi/vmpi_services_watch/vmpi_browser_services.rc new file mode 100644 index 0000000..e3e3245 --- /dev/null +++ b/utils/vmpi/vmpi_services_watch/vmpi_browser_services.rc @@ -0,0 +1,249 @@ +// Microsoft Visual C++ generated resource script. +// +#include "resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#include "afxres.h" + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +// English (U.S.) resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +#ifdef _WIN32 +LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US +#pragma code_page(1252) +#endif //_WIN32 + +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE +BEGIN + "resource.h\0" +END + +2 TEXTINCLUDE +BEGIN + "#include ""afxres.h""\r\n" + "\0" +END + +3 TEXTINCLUDE +BEGIN + "#define _AFX_NO_SPLITTER_RESOURCES\r\n" + "#define _AFX_NO_OLE_RESOURCES\r\n" + "#define _AFX_NO_TRACKER_RESOURCES\r\n" + "#define _AFX_NO_PROPERTY_RESOURCES\r\n" + "\r\n" + "#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)\r\n" + "#ifdef _WIN32\r\n" + "LANGUAGE 9, 1\r\n" + "#pragma code_page(1252)\r\n" + "#endif //_WIN32\r\n" + "#include ""res\\vmpi_browser_services.rc2"" // non-Microsoft Visual C++ edited resources\r\n" + "#include ""afxres.rc"" // Standard components\r\n" + "#endif\r\n" + "\0" +END + +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// Icon +// + +// Icon with lowest ID value placed first to ensure application icon +// remains consistent on all systems. +IDR_MAINFRAME ICON "res\\vmpi.ico" + +///////////////////////////////////////////////////////////////////////////// +// +// Version +// + +VS_VERSION_INFO VERSIONINFO + FILEVERSION 1,0,0,1 + PRODUCTVERSION 1,0,0,1 + FILEFLAGSMASK 0x3fL +#ifdef _DEBUG + FILEFLAGS 0x1L +#else + FILEFLAGS 0x0L +#endif + FILEOS 0x4L + FILETYPE 0x1L + FILESUBTYPE 0x0L +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904B0" + BEGIN + VALUE "FileDescription", "vmpi_browser_services MFC Application" + VALUE "FileVersion", "1, 0, 0, 1" + VALUE "InternalName", "vmpi_browser_services" + VALUE "LegalCopyright", "Copyright (C) 2003" + VALUE "OriginalFilename", "vmpi_browser_services.EXE" + VALUE "ProductName", "vmpi_browser_services Application" + VALUE "ProductVersion", "1, 0, 0, 1" + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 1200 + END +END + + +///////////////////////////////////////////////////////////////////////////// +// +// DESIGNINFO +// + +#ifdef APSTUDIO_INVOKED +GUIDELINES DESIGNINFO +BEGIN + IDD_SERVICES, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 791 + TOPMARGIN, 7 + BOTTOMMARGIN, 246 + END + + IDD_TIMEOUT, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 355 + TOPMARGIN, 7 + BOTTOMMARGIN, 159 + END + + IDD_SET_PASSWORD, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 212 + TOPMARGIN, 7 + BOTTOMMARGIN, 91 + END + + IDD_FORCE_PASSWORD, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 212 + TOPMARGIN, 7 + BOTTOMMARGIN, 71 + END +END +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// Dialog +// + +IDD_SERVICES DIALOGEX 0, 0, 798, 253 +STYLE DS_SETFONT | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME +CAPTION "VMPI Services" +FONT 8, "MS Sans Serif", 0, 0, 0x0 +BEGIN + CONTROL "List1",IDC_SERVICES_LIST,"SysListView32",LVS_REPORT | LVS_SHOWSELALWAYS | LVS_SORTASCENDING | WS_BORDER | WS_TABSTOP,7,7,784,155 + DEFPUSHBUTTON "Filter By Password",ID_FILTER_BY_PASSWORD,715,166,76,14 + DEFPUSHBUTTON "Copy To Clipboard",ID_COPY_TO_CLIPBOARD,7,232,76,14 + DEFPUSHBUTTON "Force Password",ID_FORCE_PASSWORD,184,232,76,14 + DEFPUSHBUTTON "Stop Service(s)",ID_STOP_SERVICES,361,232,76,14 + DEFPUSHBUTTON "Stop Job(s)",ID_STOP_JOBS,538,232,76,14 + DEFPUSHBUTTON "Patch Services",ID_PATCH_SERVICES,715,232,76,14 + LTEXT "Filtering By Password:",IDC_CURRENT_PASSWORD_LABEL,128,169,70,8 + LTEXT "",IDC_CURRENT_PASSWORD,198,169,55,8 + LTEXT "# Machines:",IDC_NUM_SERVICES_LABEL,7,169,40,8 + LTEXT "2",IDC_NUM_SERVICES,47,169,55,8 + LTEXT "# Disabled:",IDC_NUM_DISABLED_SERVICES_LABEL,7,181,37,8 + LTEXT "2",IDC_NUM_DISABLED_SERVICES,47,181,55,8 + LTEXT "# Working:",IDC_NUM_WORKING_SERVICES_LABEL,7,192,36,8 + LTEXT "2",IDC_NUM_WORKING_SERVICES,47,192,55,8 + LTEXT "# Waiting:",IDC_NUM_WAITING_SERVICES_LABEL,7,203,34,8 + LTEXT "2",IDC_NUM_WAITING_SERVICES,47,203,55,8 + LTEXT "# Off:",IDC_NUM_OFF_SERVICES_LABEL,7,214,19,8 + LTEXT "2",IDC_NUM_OFF_SERVICES,47,214,55,8 +END + +IDD_TIMEOUT DIALOGEX 0, 0, 362, 166 +STYLE DS_SETFONT | DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Patch" +FONT 8, "MS Sans Serif", 0, 0, 0x0 +BEGIN + EDITTEXT IDC_COMMAND_LINE,93,78,262,14,ES_AUTOHSCROLL + EDITTEXT IDC_VMPI_TRANSFER_DIRECTORY,93,98,262,14,ES_AUTOHSCROLL + CONTROL "Force Patch (otherwise, the service will ignore the patch if the new version is not higher)",IDC_FORCE_PATCH, + "Button",BS_AUTOCHECKBOX | WS_TABSTOP,7,121,291,10 + DEFPUSHBUTTON "OK",IDOK,123,145,50,14 + PUSHBUTTON "Cancel",IDCANCEL,189,145,50,14 + LTEXT "This will setup all the selected services to be patched.",IDC_STATIC,7,7,348,11 + LTEXT "Patch Directory:",IDC_STATIC,7,81,52,8 + LTEXT "First, it will run vmpi_transfer from the VMPI_Transfer directory. This is kept separate because the vmpi_transfer.exe in that directory might be a different version than the new one in the patch directory.",IDC_STATIC,7,21,348,18 + LTEXT "VMPI_Transfer Directory:",IDC_STATIC,7,101,80,8 + LTEXT "The selected services will download the patch files, then run vmpi_service_install.",IDC_STATIC,7,42,348,13 +END + +IDD_SET_PASSWORD DIALOGEX 0, 0, 219, 98 +STYLE DS_SETFONT | DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Filter By Password" +FONT 8, "MS Sans Serif", 0, 0, 0x0 +BEGIN + EDITTEXT IDC_PASSWORD,7,56,205,14,ES_AUTOHSCROLL + DEFPUSHBUTTON "OK",IDOK,7,77,50,14 + PUSHBUTTON "Cancel",IDCANCEL,162,77,50,14 + LTEXT "This will cause the services browser to only show services that are using the specified password.\n\nIf you enter a blank password, then all services will be shown regardless of their password.",IDC_CURRENT_PASSWORD_LABEL,7,7,195,46 +END + +IDD_FORCE_PASSWORD DIALOGEX 0, 0, 219, 78 +STYLE DS_SETFONT | DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Force Password" +FONT 8, "MS Sans Serif", 0, 0, 0x0 +BEGIN + EDITTEXT IDC_PASSWORD,7,38,205,14,ES_AUTOHSCROLL + DEFPUSHBUTTON "OK",IDOK,7,57,50,14 + PUSHBUTTON "Cancel",IDCANCEL,162,57,50,14 + LTEXT "This will set the specified password on all selected services. VMPI jobs must run with -mpi_pw <password> to use those services.",IDC_CURRENT_PASSWORD_LABEL,7,7,195,27 +END + +#endif // English (U.S.) resources +///////////////////////////////////////////////////////////////////////////// + + + +#ifndef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 3 resource. +// +#define _AFX_NO_SPLITTER_RESOURCES +#define _AFX_NO_OLE_RESOURCES +#define _AFX_NO_TRACKER_RESOURCES +#define _AFX_NO_PROPERTY_RESOURCES + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +#ifdef _WIN32 +LANGUAGE 9, 1 +#pragma code_page(1252) +#endif //_WIN32 +#include "res\vmpi_browser_services.rc2" // non-Microsoft Visual C++ edited resources +#include "afxres.rc" // Standard components +#endif + +///////////////////////////////////////////////////////////////////////////// +#endif // not APSTUDIO_INVOKED + diff --git a/utils/vmpi/vmpi_services_watch/vmpi_services_watch.vpc b/utils/vmpi/vmpi_services_watch/vmpi_services_watch.vpc new file mode 100644 index 0000000..a58e2a6 --- /dev/null +++ b/utils/vmpi/vmpi_services_watch/vmpi_services_watch.vpc @@ -0,0 +1,72 @@ +//----------------------------------------------------------------------------- +// vmpi_services_watch.VPC +// +// Project Script +//----------------------------------------------------------------------------- + +$Macro SRCDIR "..\..\.." +$Macro OUTBINDIR "$SRCDIR\..\game\bin" +$Macro OUTBINNAME "vmpi_services_watch" + +$Include "$SRCDIR\vpc_scripts\source_exe_base.vpc" + +$Configuration +{ + $Compiler + { + $AdditionalIncludeDirectories "$BASE;.\;..\;..\..\common" + $PreprocessorDefinitions "$BASE;PROTECTED_THINGS_DISABLE;WINVER=0x501;NO_WARN_MBCS_MFC_DEPRECATION" + $EnableC++Exceptions "Yes (/EHsc)" + } + + $Linker + { + $AdditionalDependencies "$BASE ws2_32.lib" + } +} + +$Project "vmpi_services_watch" +{ + $Folder "Source Files" + { + -$File "$SRCDIR\public\tier0\memoverride.cpp" + + $File "..\idle_dialog.cpp" + $File "..\net_view_thread.cpp" + $File "PatchTimeout.cpp" + $File "ServicesDlg.cpp" + $File "SetPasswordDlg.cpp" + $File "..\vmpi_browser_helpers.cpp" + $File "vmpi_browser_services.cpp" + $File "vmpi_browser_services.rc" + $File "..\win_idle.cpp" + $File "..\window_anchor_mgr.cpp" + $File "StdAfx.cpp" + } + + $Folder "Header Files" + { + $File "..\idle_dialog.h" + $File "..\net_view_thread.h" + $File "PatchTimeout.h" + $File "Resource.h" + $File "ServicesDlg.h" + $File "SetPasswordDlg.h" + $File "StdAfx.h" + $File "vmpi_browser_services.h" + $File "..\vmpi_defs.h" + $File "..\win_idle.h" + $File "..\window_anchor_mgr.h" + } + + $Folder "Resources" + { + $File "res\vmpi_browser_services.ico" + $File "res\vmpi_browser_services.rc2" + } + + $Folder "Link Libraries" + { + $Lib vmpi + } +} diff --git a/utils/vmpi/vmpi_transfer/vmpi_transfer.cpp b/utils/vmpi/vmpi_transfer/vmpi_transfer.cpp new file mode 100644 index 0000000..fadf3fd --- /dev/null +++ b/utils/vmpi/vmpi_transfer/vmpi_transfer.cpp @@ -0,0 +1,172 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//============================================================================= + +#include <windows.h> +#include "vmpi.h" +#include "vmpi_transfer.h" +#include "cmdlib.h" +#include "tier0/icommandline.h" +#include "vmpi_tools_shared.h" +#include "tools_minidump.h" +#include <conio.h> + + +void MyDisconnectHandler( int procID, const char *pReason ) +{ + Error( "Premature disconnect.\n" ); +} + +void DownloadFile( const char *pCachePath, const char *pRemoteFileBase, const char *pFilename ) +{ + // Setup local and remote filenames. + char remoteFilename[MAX_PATH]; + char localFilename[MAX_PATH]; + V_ComposeFileName( pRemoteFileBase, pFilename, remoteFilename, sizeof( remoteFilename ) ); + V_ComposeFileName( pCachePath, pFilename, localFilename, sizeof( localFilename ) ); + + // Read the file in. + FileHandle_t fpSrc = g_pFileSystem->Open( remoteFilename, "rb" ); + if ( fpSrc == FILESYSTEM_INVALID_HANDLE ) + { + Error( "Unable to open %s on master.\n", remoteFilename ); + } + + unsigned int fileSize = g_pFileSystem->Size( fpSrc ); + CUtlVector<char> data; + data.SetSize( fileSize ); + g_pFileSystem->Read( data.Base(), fileSize, fpSrc ); + g_pFileSystem->Close( fpSrc ); + + // Now write the file to disk. + FILE *fpDest = fopen( localFilename, "wb" ); + if ( !fpDest ) + { + Error( "Can't open %s for writing.\n", localFilename ); + } + fwrite( data.Base(), 1, data.Count(), fpDest ); + fclose( fpDest ); + +Warning( "Got file: %s\n", pFilename ); +} + +#if 0 +SpewRetval_t MySpewFunc( SpewType_t spewType, const tchar *pMsg ) +{ + printf( "%s", pMsg ); + if ( spewType == SPEW_ERROR ) + { + printf( "\nWaiting for keypress to quit...\n" ); + getch(); + TerminateProcess( GetCurrentProcess(), 1 ); + } + + return SPEW_CONTINUE; +} +#endif + +int RunVMPITransferWorker( int argc, char **argv ) +{ + if ( !VMPI_Init( argc, argv, NULL, MyDisconnectHandler, VMPI_RUN_NETWORKED, true ) ) + { + return 1; + } + + SetupToolsMinidumpHandler( VMPI_ExceptionFilter ); + + if ( !FileSystem_Init( ".", 0, FS_INIT_COMPATIBILITY_MODE ) ) + return 1; + + ICommandLine *pCommandLine = CommandLine(); + + // Look for the cache path and file base args. + const char *pCachePath = pCommandLine->ParmValue( "-CachePath", (char*)NULL ); + if ( !pCachePath ) + Error( "No -CachePath specified." ); + + const char *pRemoteFileBase = pCommandLine->ParmValue( "-mpi_filebase", (char*)NULL ); + if ( !pRemoteFileBase ) + Error( "No -mpi_filebase specified." ); + + // Now just ask the master for each file. + for ( int i=1; i < pCommandLine->ParmCount()-1; i++ ) + { + const char *pParm = pCommandLine->GetParm( i ); + if ( V_stricmp( pParm, "-mpi_file" ) == 0 ) + { + const char *pNextParm = pCommandLine->GetParm( i+1 ); + DownloadFile( pCachePath, pRemoteFileBase, pNextParm ); + ++i; + } + } + + // Ok, we're done. Write the status file so the service knows all the files are ready to go. + char statusFilename[MAX_PATH]; + V_ComposeFileName( pCachePath, "ReadyToGo.txt", statusFilename, sizeof( statusFilename ) ); + FILE *fp = fopen( statusFilename, "wb" ); + fclose( fp ); + + return 0; +} + + +// In this mode, we just initialize VMPI appropriately, and it'll host out the specified files. +// The command line to vmpi_transfer is -PatchHost -PatchDirectory <directory> +// Sample: vmpi_transfer -PatchHost -mpi_PatchDirectory \\fileserver\vmpi\patch1 -mpi_PatchWorkers <count> <ip1> <ip2>... +// Then it'll tell those workers to connect and it'll send them the files in the specified directory. +int RunVMPITransferMaster( int argc, char **argv ) +{ + // Since we didn't use -mpi_worker on the command line, VMPI will init as the master. + // We put a special character in front of the dependency filename, which tells it the dependencies + // consist of every file in the specified directory. + VMPI_Init_PatchMaster( argc, argv ); + + if ( !FileSystem_Init( ".", 0, FS_INIT_COMPATIBILITY_MODE ) ) + return 1; + + Msg( "Hosting patch files. Press ESC to exit. " ); + while ( 1 ) + { + VMPI_DispatchNextMessage( 100 ); + if ( kbhit() ) + { + if ( getch() == 27 ) + break; + } + } + + return 0; +} + + +// --------------------------------------------------------------------------------- // +// Purpose: This app is used by vmpi_service to acquire the executables for +// a VMPI job. When the service is asked to join a job, it runs this program +// to connect to the VMPI master and download all the exes for the job. +// +// This app is ALSO used to do patches. vmpi_browser_services runs it with a list +// of machines it wants to patch. Then it runs as the VMPI master and instead of +// broadcasting its presence, it sends messages to the specific list of machines. +// --------------------------------------------------------------------------------- // +int main( int argc, char **argv ) +{ + InstallSpewFunction(); + CommandLine()->CreateCmdLine( argc, argv ); + + int ret; + if ( CommandLine()->FindParm( "-PatchHost" ) == 0 ) + { + ret = RunVMPITransferWorker( argc, argv ); + } + else + { + ret = RunVMPITransferMaster( argc, argv ); + } + + CmdLib_Cleanup(); + return ret; +} + + diff --git a/utils/vmpi/vmpi_transfer/vmpi_transfer.h b/utils/vmpi/vmpi_transfer/vmpi_transfer.h new file mode 100644 index 0000000..95c8b67 --- /dev/null +++ b/utils/vmpi/vmpi_transfer/vmpi_transfer.h @@ -0,0 +1,14 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//============================================================================= + +#ifndef VMPI_TRANSFER_H +#define VMPI_TRANSFER_H +#ifdef _WIN32 +#pragma once +#endif + + +#endif // VMPI_TRANSFER_H diff --git a/utils/vmpi/vmpi_transfer/vmpi_transfer.vpc b/utils/vmpi/vmpi_transfer/vmpi_transfer.vpc new file mode 100644 index 0000000..baa9cc6 --- /dev/null +++ b/utils/vmpi/vmpi_transfer/vmpi_transfer.vpc @@ -0,0 +1,155 @@ +//----------------------------------------------------------------------------- +// VMPI_TRANSFER.VPC +// +// Project Script +//----------------------------------------------------------------------------- + +$Macro SRCDIR "..\..\.." +$Macro OUTBINDIR "$SRCDIR\..\game\bin" +$Macro OUTBINNAME "vmpi_transfer" + +$Include "$SRCDIR\vpc_scripts\source_exe_con_base.vpc" + +$Configuration +{ + $Compiler + { + $AdditionalIncludeDirectories "$BASE,..\..\common,.." + $PreprocessorDefinitions "$BASE;MPI;PROTECTED_THINGS_DISABLE" + } + + $Linker + { + $AdditionalDependencies "$BASE ws2_32.lib" + } +} + +$Project "vmpi_transfer" +{ + $Folder "Source Files" + { + $File "..\..\common\vmpi_tools_shared.cpp" + $File "..\..\common\vmpi_tools_shared.h" + $File "vmpi_transfer.cpp" + + $Folder "Common Files" + { + $File "..\..\common\threads.cpp" + $File "..\..\common\pacifier.cpp" + $File "..\..\common\cmdlib.cpp" + $File "..\..\common\tools_minidump.cpp" + $File "..\..\common\tools_minidump.h" + } + + $Folder "Public Files" + { + $File "$SRCDIR\public\filesystem_helpers.cpp" + } + } + + $Folder "Header Files" + { + $File "vmpi_transfer.h" + + $Folder "Common Header Files" + { + $File "..\..\common\cmdlib.h" + $File "..\iphelpers.h" + $File "..\messbuf.h" + $File "..\mysql_wrapper.h" + $File "..\threadhelpers.h" + $File "..\vmpi_defs.h" + $File "..\vmpi_dispatch.h" + $File "..\vmpi_distribute_work.h" + $File "..\vmpi_filesystem.h" + } + + $Folder "Public Header Files" + { + $File "$SRCDIR\public\mathlib\amd3dx.h" + $File "$SRCDIR\public\mathlib\ANORMS.H" + $File "$SRCDIR\public\basehandle.h" + $File "$SRCDIR\public\tier0\basetypes.h" + $File "$SRCDIR\public\tier1\bitbuf.h" + $File "$SRCDIR\public\bitvec.h" + $File "$SRCDIR\public\BSPFILE.H" + $File "$SRCDIR\public\bspflags.h" + $File "$SRCDIR\public\BSPTreeData.h" + $File "$SRCDIR\public\builddisp.h" + $File "$SRCDIR\public\mathlib\bumpvects.h" + $File "$SRCDIR\public\tier1\byteswap.h" + $File "$SRCDIR\public\tier1\characterset.h" + $File "$SRCDIR\public\tier1\checksum_crc.h" + $File "$SRCDIR\public\tier1\checksum_md5.h" + $File "$SRCDIR\public\ChunkFile.h" + $File "$SRCDIR\public\cmodel.h" + $File "$SRCDIR\public\CollisionUtils.h" + $File "$SRCDIR\public\tier0\commonmacros.h" + $File "$SRCDIR\public\mathlib\compressed_vector.h" + $File "$SRCDIR\public\const.h" + $File "$SRCDIR\public\coordsize.h" + $File "$SRCDIR\public\tier0\dbg.h" + $File "$SRCDIR\public\disp_common.h" + $File "$SRCDIR\public\disp_powerinfo.h" + $File "$SRCDIR\public\disp_vertindex.h" + $File "$SRCDIR\public\DispColl_Common.h" + $File "$SRCDIR\public\tier0\fasttimer.h" + $File "$SRCDIR\public\filesystem.h" + $File "$SRCDIR\public\filesystem_helpers.h" + $File "$SRCDIR\public\GameBSPFile.h" + $File "$SRCDIR\public\gametrace.h" + $File "$SRCDIR\public\mathlib\halton.h" + $File "$SRCDIR\public\materialsystem\hardwareverts.h" + $File "$SRCDIR\public\appframework\IAppSystem.h" + $File "$SRCDIR\public\tier0\icommandline.h" + $File "$SRCDIR\public\ihandleentity.h" + $File "$SRCDIR\public\materialsystem\imaterial.h" + $File "$SRCDIR\public\materialsystem\imaterialsystem.h" + $File "$SRCDIR\public\materialsystem\imaterialvar.h" + $File "$SRCDIR\public\tier1\interface.h" + $File "$SRCDIR\public\iscratchpad3d.h" + $File "$SRCDIR\public\ivraddll.h" + $File "$SRCDIR\public\materialsystem\materialsystem_config.h" + $File "$SRCDIR\public\mathlib\mathlib.h" + $File "$SRCDIR\public\tier0\memdbgon.h" + $File "$SRCDIR\public\optimize.h" + $File "$SRCDIR\public\tier0\platform.h" + $File "$SRCDIR\public\tier0\protected_things.h" + $File "$SRCDIR\public\vstdlib\random.h" + $File "$SRCDIR\public\ScratchPad3D.h" + $File "$SRCDIR\public\ScratchPadUtils.h" + $File "$SRCDIR\public\string_t.h" + $File "$SRCDIR\public\tier1\strtools.h" + $File "$SRCDIR\public\studio.h" + $File "$SRCDIR\public\tier1\tokenreader.h" + $File "$SRCDIR\public\trace.h" + $File "$SRCDIR\public\tier1\utlbuffer.h" + $File "$SRCDIR\public\tier1\utldict.h" + $File "$SRCDIR\public\tier1\utlhash.h" + $File "$SRCDIR\public\tier1\utllinkedlist.h" + $File "$SRCDIR\public\tier1\utlmemory.h" + $File "$SRCDIR\public\tier1\utlrbtree.h" + $File "$SRCDIR\public\tier1\utlsymbol.h" + $File "$SRCDIR\public\tier1\utlvector.h" + $File "$SRCDIR\public\vcollide.h" + $File "$SRCDIR\public\mathlib\vector.h" + $File "$SRCDIR\public\mathlib\vector2d.h" + $File "$SRCDIR\public\mathlib\vector4d.h" + $File "$SRCDIR\public\mathlib\vmatrix.h" + $File "..\vmpi.h" + $File "$SRCDIR\public\vphysics_interface.h" + $File "$SRCDIR\public\mathlib\vplane.h" + $File "$SRCDIR\public\tier0\vprof.h" + $File "$SRCDIR\public\vstdlib\vstdlib.h" + $File "$SRCDIR\public\vtf\vtf.h" + $File "$SRCDIR\public\wadtypes.h" + $File "$SRCDIR\public\worldsize.h" + } + } + + $Folder "Link Libraries" + { + $Lib tier2 + $Lib vmpi + } +} diff --git a/utils/vmpi/win_idle.cpp b/utils/vmpi/win_idle.cpp new file mode 100644 index 0000000..5b453bc --- /dev/null +++ b/utils/vmpi/win_idle.cpp @@ -0,0 +1,122 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// Class for sending idle messages to a window + +#include "stdafx.h" +#include "win_idle.h" + +// Stub function to get into the object's main thread loop +DWORD WINAPI CWinIdle::ThreadStub(LPVOID pIdle) +{ + return ((CWinIdle *)pIdle)->RunIdle(); +} + +CWinIdle::CWinIdle() : + m_hIdleThread(NULL), + m_hIdleEvent(NULL), + m_hStopEvent(NULL), + m_hWnd(0), + m_uMsg(0), + m_dwDelay(0) +{ +} + +CWinIdle::~CWinIdle() +{ + EndIdle(); +} + +DWORD CWinIdle::RunIdle() +{ + // Set up an event list + HANDLE aEvents[2]; + + aEvents[0] = m_hStopEvent; + aEvents[1] = m_hIdleEvent; + + // Wait for a stop or idle event + while (WaitForMultipleObjects(2, aEvents, FALSE, INFINITE) != WAIT_OBJECT_0) + { + // Send an idle message + PostMessage(m_hWnd, m_uMsg, m_wParam, m_lParam); + // Wait for a bit... + Sleep(m_dwDelay); + } + + return 0; +} + +BOOL CWinIdle::StartIdle(HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam, DWORD dwDelay) +{ + // Make sure it's not already running + if (m_hIdleThread) + return FALSE; + + // Make sure they send in a valid handle.. + if (!hWnd) + return FALSE; + + // Create the events + m_hIdleEvent = CreateEvent(NULL, FALSE, FALSE, NULL); + m_hStopEvent = CreateEvent(NULL, FALSE, FALSE, NULL); + + // Make sure the events got created + if ((!m_hIdleEvent) || (!m_hStopEvent)) + return FALSE; + + // Create the thread + DWORD dwThreadID; + m_hIdleThread = CreateThread(NULL, 0, CWinIdle::ThreadStub, (void *)this, 0, &dwThreadID); + + if (m_hIdleThread) + { + SetThreadPriority(m_hIdleThread, THREAD_PRIORITY_IDLE); + + m_hWnd = hWnd; + m_uMsg = uMessage; + m_wParam = wParam; + m_lParam = lParam; + + m_dwDelay = dwDelay; + } + + return m_hIdleThread != 0; +} + +BOOL CWinIdle::EndIdle() +{ + // Make sure it's running + if (!m_hIdleThread) + return FALSE; + + // Stop the idle thread + SetEvent(m_hStopEvent); + WaitForSingleObject(m_hIdleThread, INFINITE); + CloseHandle(m_hIdleThread); + + // Get rid of the event objects + CloseHandle(m_hIdleEvent); + CloseHandle(m_hStopEvent); + + // Set everything back to 0 + m_hIdleEvent = 0; + m_hStopEvent = 0; + m_hIdleThread = 0; + + return TRUE; +} + +void CWinIdle::NextIdle() +{ + // Make sure the thread's running + if (!m_hIdleThread) + return; + + // Signal an idle message + SetEvent(m_hIdleEvent); +} diff --git a/utils/vmpi/win_idle.h b/utils/vmpi/win_idle.h new file mode 100644 index 0000000..6e2e3f3 --- /dev/null +++ b/utils/vmpi/win_idle.h @@ -0,0 +1,78 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// WinIdle.h - Defines a class for sending idle messages to a window from a secondary thread + +#ifndef __WINIDLE_H__ +#define __WINIDLE_H__ + + +class CWinIdle +{ +protected: + HANDLE m_hIdleEvent, m_hStopEvent; + + HWND m_hWnd; + UINT m_uMsg; + WPARAM m_wParam; + LPARAM m_lParam; + + DWORD m_dwDelay; + + HANDLE m_hIdleThread; + + // The thread calling stub + static DWORD WINAPI ThreadStub(LPVOID pIdle); + // The actual idle loop + virtual DWORD RunIdle(); + +public: + CWinIdle(); + virtual ~CWinIdle(); + + inline DWORD GetDelay() {return m_dwDelay;} + inline void SetDelay(DWORD delay) {m_dwDelay = delay;} + + // Member access + virtual HANDLE GetThreadHandle() const { return m_hIdleThread; }; + + // Start idling, and define the message and window to use + // Returns TRUE on success + virtual BOOL StartIdle(HWND hWnd, UINT uMessage, WPARAM wParam = 0, LPARAM lParam = 0, DWORD dwDelay = 0); + // Stop idling + // Returns TRUE on success + virtual BOOL EndIdle(); + // Notify the idle process that the message was received. + // Note : If this function is not called, the idle thread will not send any messages + virtual void NextIdle(); +}; + + +// Used to slow down the idle thread while dialogs are up. +class IdleChanger +{ +public: + IdleChanger(CWinIdle *pIdle, DWORD msDelay) + { + m_pIdle = pIdle; + m_OldDelay = pIdle->GetDelay(); + pIdle->SetDelay(msDelay); + } + + ~IdleChanger() + { + m_pIdle->SetDelay(m_OldDelay); + } + + CWinIdle *m_pIdle; + DWORD m_OldDelay; +}; + + + +#endif //__WINIDLE_H__ + diff --git a/utils/vmpi/window_anchor_mgr.cpp b/utils/vmpi/window_anchor_mgr.cpp new file mode 100644 index 0000000..2e76daf --- /dev/null +++ b/utils/vmpi/window_anchor_mgr.cpp @@ -0,0 +1,94 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#include "stdafx.h" +#include "window_anchor_mgr.h" + + +// ------------------------------------------------------------------------------------ // +// CWindowAnchor. +// ------------------------------------------------------------------------------------ // + +bool CWindowAnchor::Init( CWnd *pParentWnd, CWnd *pChildWnd, int aLeft, int aTop, int aRight, int aBottom ) +{ + m_pWnd = pChildWnd; + + m_aLeft = aLeft; + m_aTop = aTop; + m_aRight = aRight; + m_aBottom = aBottom; + + if ( m_pWnd && pParentWnd ) + { + pParentWnd->GetWindowRect( m_ParentRect ); + pChildWnd->GetWindowRect( m_Rect ); + return true; + } + else + { + return false; + } +} + + +void AnchorElement( long *pOut, CRect &rcParent, int startElement, CRect &rcParentStart, int flags ) +{ + if ( flags == ANCHOR_LEFT ) + *pOut = rcParent.left + ( startElement - rcParentStart.left ); + else if ( flags == ANCHOR_TOP ) + *pOut = rcParent.top + ( startElement - rcParentStart.top ); + else if ( flags == ANCHOR_RIGHT ) + *pOut = rcParent.right - ( rcParentStart.right - startElement ); + else if ( flags == ANCHOR_BOTTOM ) + *pOut = rcParent.bottom - ( rcParentStart.bottom - startElement ); + else if ( flags == ANCHOR_WIDTH_PERCENT ) + *pOut = rcParent.left + (rcParent.Width() * ( startElement - rcParentStart.left )) / rcParentStart.Width(); + else if ( flags == ANCHOR_HEIGHT_PERCENT ) + *pOut = rcParent.top + (rcParent.Height() * ( startElement - rcParentStart.top )) / rcParentStart.Height(); +} + + +void CWindowAnchor::Update( CWnd *pParentWnd ) +{ + if ( !m_pWnd ) + return; + + CRect rcParent; + pParentWnd->GetWindowRect( rcParent ); + + CRect rcNew; + AnchorElement( &rcNew.left, rcParent, m_Rect.left, m_ParentRect, m_aLeft ); + AnchorElement( &rcNew.top, rcParent, m_Rect.top, m_ParentRect, m_aTop ); + AnchorElement( &rcNew.right, rcParent, m_Rect.right, m_ParentRect, m_aRight ); + AnchorElement( &rcNew.bottom, rcParent, m_Rect.bottom, m_ParentRect, m_aBottom ); + + pParentWnd->ScreenToClient( rcNew ); + m_pWnd->SetWindowPos( NULL, rcNew.left, rcNew.top, rcNew.Width(), rcNew.Height(), SWP_NOZORDER ); + m_pWnd->InvalidateRect( NULL ); +} + + + +// ------------------------------------------------------------------------------------ // +// CWindowAnchorMgr. +// ------------------------------------------------------------------------------------ // + +bool CWindowAnchorMgr::AddAnchor( CWnd *pParentWnd, CWnd *pChildWnd, int aLeft, int aTop, int aRight, int aBottom ) +{ + int index = m_Anchors.AddToTail(); + return m_Anchors[index].Init( pParentWnd, pChildWnd, aLeft, aTop, aRight, aBottom ); +} + + +void CWindowAnchorMgr::UpdateAnchors( CWnd *pParentWnd ) +{ + FOR_EACH_LL( m_Anchors, i ) + { + m_Anchors[i].Update( pParentWnd ); + } +} + diff --git a/utils/vmpi/window_anchor_mgr.h b/utils/vmpi/window_anchor_mgr.h new file mode 100644 index 0000000..5d5014c --- /dev/null +++ b/utils/vmpi/window_anchor_mgr.h @@ -0,0 +1,59 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#ifndef WINDOW_ANCHOR_MGR_H +#define WINDOW_ANCHOR_MGR_H +#ifdef _WIN32 +#pragma once +#endif + + +#include "utllinkedlist.h" + + +enum +{ + ANCHOR_LEFT = 1, + ANCHOR_RIGHT, + ANCHOR_TOP, + ANCHOR_BOTTOM, + ANCHOR_WIDTH_PERCENT, + ANCHOR_HEIGHT_PERCENT +}; + + +class CWindowAnchor +{ +public: + + bool Init( CWnd *pParentWnd, CWnd *pChildWnd, int aLeft, int aTop, int aRight, int aBottom ); + void Update( CWnd *pParentWnd ); + + +private: + CWnd *m_pWnd; + CRect m_Rect; // The rectangle in client coordinates of the parent. + CRect m_ParentRect; + + int m_aLeft, m_aTop, m_aRight, m_aBottom; +}; + + +class CWindowAnchorMgr +{ +public: + + bool AddAnchor( CWnd *pParentWnd, CWnd *pChildWnd, int aLeft, int aTop, int aRight, int aBottom ); + void UpdateAnchors( CWnd *pParentWnd ); + + +private: + CUtlLinkedList<CWindowAnchor,int> m_Anchors; +}; + + +#endif // WINDOW_ANCHOR_MGR_H |