clientconnect.cpp

我写的SQL Server网络备份工具。（服务器端用VC开发

//---------------------------------------------------------------------------


#pragma hdrstop

#include <stdio.h>
#include "ClientConnect.h"
#include "Message.h"
#define BUFFER_SIZE 10240
//---------------------------------------------------------------------------

#pragma package(smart_init)
char * NetError = "未知网络错误";
char * NoConnectError = "没有连接到服务器上";
ClientConnect::ClientConnect()
    :m_sockConnect(AF_INET , SOCK_STREAM , IPPROTO_IP) ,
    m_bConnected(FALSE) , m_uSendTimeout(60000) , m_uRecvTimeout(60000)
{
}

BOOL ClientConnect::Connect(char *pAddress)
{
     if(m_sockConnect == INVALID_SOCKET)
     {
         return FALSE;
     }
     struct sockaddr_in sin;
     memset(&sin , 0 , sizeof(sin));
     sin.sin_family = AF_INET;
     sin.sin_port   = htons(1888);
     sin.sin_addr.S_un.S_addr = inet_addr(pAddress);

     m_bConnected = connect(m_sockConnect , (struct sockaddr *)&sin , sizeof(sin)) != SOCKET_ERROR;
     return m_bConnected;
}

BOOL ClientConnect::GetDatabase(StringArray &Databases)
{
    _ASSERT(Databases.size() == 0);

    if(m_bConnected == FALSE)
    {
        m_strError = NoConnectError;
        return FALSE;
    }

    {
        struct Request _request;

        _request.sign = 0x7171;
        _request.type = RT_QUERYDATABASE;
        _request.size = sizeof(_request);

        setsockopt(m_sockConnect , SOL_SOCKET  , SO_SNDTIMEO	 , (char *)&m_uSendTimeout , sizeof(m_uSendTimeout));

        if(sendn(m_sockConnect , (char *)&_request , sizeof(_request)) != sizeof(_request))
        {
             m_strError = NetError;
             return FALSE;
        }
    }


    {
        struct Response _response;

        setsockopt(m_sockConnect , SOL_SOCKET  , SO_RCVTIMEO , (char *)&m_uRecvTimeout , sizeof(m_uRecvTimeout));
        if(readn(m_sockConnect , (char *)&_response , sizeof(_response)) != sizeof(_response))
        {
            m_strError = NetError;
            return FALSE;
        }

        if(_response.sign != 0x7171)
        {
            m_strError = "非法连接";
            return FALSE;
        }

        int len = _response.size - sizeof(_response);
        if(len < 1)
        {
           m_strError = NetError;
           return FALSE;
        }
        PChar pBuff(new char[len + 1]);
        if(readn(m_sockConnect , pBuff , len) != len)
        {
           m_strError = NetError;
           return FALSE;
        }
        if(_response.type == RT_ERROR)
        {
           m_strError = pBuff;
           return FALSE;
        }
        if(_response.type != RT_SUCCEED)
        {
            m_strError = NetError;
            return FALSE;
        }
        char *pLast , *pCurr;
        char Database[MAXDATABASE];
        pCurr = pBuff;
        if(*pCurr == '#')
            pCurr++;
        for(pLast = pCurr ; *pCurr ; pCurr++)
        {
            if(*pCurr == '#')
            {
                strncpy(Database , pLast , pCurr - pLast);
                Database[pCurr - pLast] = '\0';
                Databases.push_back(Database);
                pLast = pCurr + 1;
            }
        }
        if(pCurr != pLast)
        {
            strncpy(Database , pLast , pCurr - pLast);
            Database[pCurr - pLast] = '\0';
            Databases.push_back(Database);
        }
    }
    return TRUE;
}

const string & ClientConnect::GetError()
{
    return m_strError;
}

BOOL ClientConnect::Backup(char * pDBName, char * pFileName)
{

    _ASSERT(pDBName);
    _ASSERT(pFileName);

    if(!m_bConnected)
    {
        m_strError = NoConnectError;
        return FALSE;
    }

    {
        struct Request *pRequest;

        int len = strlen(pDBName);

        _ASSERT(len);

        len += sizeof(struct Request) + 1;
        PChar pBuff(new char[len]);
        pRequest = (struct Request *)(char *)pBuff;

        pRequest->sign = 0x7171;
        pRequest->type = RT_BACKUP;
        pRequest->size = len;
        strcpy(pBuff + sizeof(struct Request) , pDBName);

        setsockopt(m_sockConnect , SOL_SOCKET  , SO_SNDTIMEO	 , (char *)&m_uSendTimeout , sizeof(m_uSendTimeout));
        if(len != sendn(m_sockConnect , (char *)pBuff , len))
        {
            m_strError = NetError;
            return FALSE;
        }
    }

    {
        struct Response _response;

        setsockopt(m_sockConnect , SOL_SOCKET  , SO_RCVTIMEO , (char *)&m_uRecvTimeout , sizeof(m_uRecvTimeout));
        if(readn(m_sockConnect , (char *)&_response , sizeof(_response)) != sizeof(_response))
        {
            m_strError = NetError;
            return FALSE;
        }

        if(_response.sign != 0x7171)
        {
            m_strError = "非法连接";
            return FALSE;
        }

        int len = _response.size - sizeof(_response);
        if(len < 1)
        {
           m_strError = NetError;
           return FALSE;
        }

        if(_response.type == RT_ERROR)
        {
           PChar pBuff(new char[len]);
           if(readn(m_sockConnect , pBuff , len) != len)
           {
              m_strError = NetError;
              return FALSE;
            }
           m_strError = pBuff;
           return FALSE;
        }
        if(_response.type != RT_SUCCEED)
        {
            m_strError = NetError;
            return FALSE;
        }

        FILE *pFile;

        pFile = fopen(pFileName , "wb+");
        if(pFile == NULL)
        {
            m_strError = "文件创建不成功";
            return FALSE;
        }

        int nReadLen;
        PChar pBuff(new char[BUFFER_SIZE]);
        while(len > 0)
        {
            if(len - BUFFER_SIZE >= 0)
                nReadLen = BUFFER_SIZE;
            else
                nReadLen = len;

            if(readn(m_sockConnect , (char *)pBuff , nReadLen) != nReadLen)
            {
                m_strError = NetError;
                fclose(pFile);
                return FALSE;
            }
            len -= nReadLen;
            fwrite((char *)pBuff , nReadLen , 1 , pFile);
        }
        fclose(pFile);
    }
    return TRUE;
}
/*
BOOL ClientConnect::CheckConnect()
{
    if(!m_bConnected)
    {
        m_strError = NoConnectError;
        return FALSE;
    }

    {
        struct Request _request;

        _request.sign = 0x7171;
        _request.type = RT_CONNECT;
        _request.size = sizeof(_request);

        setsockopt(m_sockConnect , SOL_SOCKET  , SO_SNDTIMEO	 , (char *)&m_uSendTimeout , sizeof(m_uSendTimeout));

        if(sendn(m_sockConnect , (char *)&_request , sizeof(_request)) != sizeof(_request))
        {
             m_strError = NetError;
             return FALSE;
        }
    }
    {
        struct Response _response;
        setsockopt(m_sockConnect , SOL_SOCKET  , SO_RCVTIMEO , (char *)&m_uRecvTimeout , sizeof(m_uRecvTimeout));
        if(readn(m_sockConnect , (char *)&_response , sizeof(_response)) != sizeof(_response))
        {
            m_strError = NetError;
            return FALSE;
        }

        if(_response.sign != 0x7171)
        {
            m_strError = "非法连接";
            return FALSE;
        }
        return  _response.type == RT_SUCCEED;
     }
}
*/