clientthread.cpp

来自「著名的SecureBlackBox控件完整源码」· C++ 代码 · 共 549 行 · 第 1/2 页

            Conn->FThread->Connection->Disconnect();
        }
        else if ((Conn->FOutState == ocsActive) && (Conn->FInState == icsClosing || Conn->FInState == icsClosed))
        {
            Conn->FOutState = ocsClosing;
            FCS->Acquire();
            try
            {
                Conn->FChannel->Close(true);
            }
            __finally
            {
                FCS->Release();
            }
        }
        else if ((Conn->FInState == icsClosing) && (!AThread->Connection->Connected()))
        {
            Conn->FInState = icsClosed;
        }

        if (!FNoGUI)
        {
            FGuiCS->Acquire();
            try
            {
                DoConnectionChange(Conn);
            }
            __finally
            {
                FGuiCS->Release();
            }
        }
        ::Sleep(50);
    }
    // clearing the 'Data' property due to a bug in Indy 9 implementation
    // (the FreeAndNil is called for object referenced by Data property)
    if (!FNoGUI)
    {
        FGuiCS->Acquire();
        try
        {
            DoConnectionRemove(Conn);
        }
        __finally
        {
            FGuiCS->Release();
        }
    }
    delete ((TConnection*)(AThread->Data));
    AThread->Data = NULL;
}
//---------------------------------------------------------------------------
void __fastcall TClientThread::TCPServerThreadTerminate(TObject* Sender)
{
}
//---------------------------------------------------------------------------
void __fastcall TClientThread::Execute(void)
{
    try
    {
        FError = false;
        // opening listening socket
        FTCPServer->Active = true;
        // establishing TCP connection
        FTCPClient->Connect();
        // opening SSH client
        FSSHClient->Open();
        // running client loop
        while ((!Terminated) && (!FError) && (FTCPClient->Connected()))
        {
            try
            {
                while ((FTCPClient->Socket != NULL) && (FTCPClient->Socket->Readable()))
                {
                    FCS->Acquire();
                    try
                    {
                        FSSHClient->DataAvailable();
                    }
                    __finally
                    {
                        FCS->Release();
                    }
                }
                ::Sleep(50);
            }
            catch(Exception &e)
            {
                break;
            }
        }
        // closing sockets
        if (FTCPClient->Connected())
            FTCPClient->Disconnect();
        if (FTCPServer->Active)
            FTCPServer->Active = false;
    }
    catch(Exception &e)
    {
        Log((AnsiString)"Error: " + e.Message, true);
    }
}
//---------------------------------------------------------------------------
void TClientThread::Log(const AnsiString S, bool Error)
{
    if (!FNoGUI)
    {
        FGuiCS->Acquire();
        try
        {
            FLogString = S;
            FLogError = Error;
            Synchronize(TriggerLog);
        }
        __finally
        {
            FGuiCS->Release();
        }
    }
}
//---------------------------------------------------------------------------
void TClientThread::DoConnectionAdd(TConnection* Conn)
{
    FConn = Conn;
    Synchronize(TriggerConnectionAdd);
}
//---------------------------------------------------------------------------
void TClientThread::DoConnectionRemove(TConnection* Conn)
{
    FConn = Conn;
    Synchronize(TriggerConnectionRemove);
}
//---------------------------------------------------------------------------
void TClientThread::DoConnectionChange(TConnection* Conn)
{
    FConn = Conn;
    Synchronize(TriggerConnectionChange);
}
//---------------------------------------------------------------------------
void __fastcall TClientThread::TriggerLog(void)
{
    if (FOnLog != NULL)
        FOnLog(this, FLogString, FLogError);
}
//---------------------------------------------------------------------------
void __fastcall TClientThread::TriggerConnectionChange(void)
{
    if (FOnChange != NULL)
        FOnChange(this, FConn);
}
//---------------------------------------------------------------------------
void __fastcall TClientThread::TriggerConnectionAdd(void)
{
    if (FOnConnectionAdd)
        FOnConnectionAdd(this, FConn);
}
//---------------------------------------------------------------------------
void __fastcall TClientThread::TriggerConnectionRemove(void)
{
    if (FOnConnectionRemove)
        FOnConnectionRemove(this, FConn);
}

////////////////////////////////////////////////////////////////////////////////
// TConnection class
TConnection::TConnection()
{
    FChannel = NULL;
    FThread = NULL;
    FChannelBuffer = NULL;
    FSocketBuffer = NULL;
    FChannelBufferSize = 0;
    FSocketBufferSize = 0;

  //  SetLength(FChannelBuffer, 0);
  //  SetLength(FSocketBuffer, 0);
    FSharedResource = new TElSharedResource;
    FInState = icsActive;
    FOutState = ocsEstablishing;
    FSent = 0;
    FReceived = 0;
}
//---------------------------------------------------------------------------
TConnection::~TConnection()
{
    delete FSharedResource;
}
//---------------------------------------------------------------------------
int TConnection::ReadFromSocketBuffer(void* Buffer, int MaxSize)
{
    int Result = 0;
    FSharedResource->WaitToRead();
    try
    {
        Result = Idglobal::Min(MaxSize, FSocketBufferSize);
        Move(FSocketBuffer, Buffer, Result);

        char* pTempBuff = FSocketBuffer;
        FSocketBufferSize = FSocketBufferSize - Result;
        FSocketBuffer = new char[FSocketBufferSize];

        Move(pTempBuff+Result, FSocketBuffer, FSocketBufferSize);
        delete[] pTempBuff;
    }
    __finally
    {
        FSharedResource->Done();
    }
    return Result;
}
//---------------------------------------------------------------------------
int TConnection::ReadFromChannelBuffer(void* Buffer, int MaxSize)
{
    int Result = 0;
    FSharedResource->WaitToRead();
    try
    {
        Result = Idglobal::Min(MaxSize, FChannelBufferSize);
        Move(FChannelBuffer, Buffer, Result);

        char* pTempBuff = FChannelBuffer;
        FChannelBufferSize = FChannelBufferSize - Result;
        FChannelBuffer = new char[FChannelBufferSize];

        Move(pTempBuff+Result, FChannelBuffer, FChannelBufferSize);
        delete[] pTempBuff;
    }
    __finally
    {
        FSharedResource->Done();
    }
    return Result;
}
//---------------------------------------------------------------------------
void TConnection::WriteToSocketBuffer(void* Buffer, int Size)
{
    FSharedResource->WaitToWrite();
    try
    {
        int OldLen = FSocketBufferSize;
        char* pTempBuff = FSocketBuffer;
        FSocketBufferSize = FSocketBufferSize + Size;
        FSocketBuffer = new char[FSocketBufferSize];
        Move(pTempBuff, FSocketBuffer, OldLen);
        Move(Buffer, FSocketBuffer + OldLen, Size);
        delete[] pTempBuff;
    }
    __finally
    {
        FSharedResource->Done();
    }
}
//---------------------------------------------------------------------------
void TConnection::WriteToChannelBuffer(void* Buffer, int Size)
{
    FSharedResource->WaitToWrite();
    try
    {
        int OldLen = FChannelBufferSize;
        char* pTempBuff = FChannelBuffer;
        FChannelBufferSize = FChannelBufferSize + Size;
        FChannelBuffer = new char[FChannelBufferSize];
        Move(pTempBuff, FChannelBuffer, OldLen);
        Move(Buffer, FChannelBuffer + OldLen, Size);
        delete[] pTempBuff;
    }
    __finally
    {
        FSharedResource->Done();
    }
}
//---------------------------------------------------------------------------