C++ Socket發送文件服務端代碼

/*
**服務端代碼頭文件
*/

pragma comment(lib, “WS2_32”)

include

include

//#include

include

ifndef COMMONDEF_H

define COMMONDEF_H

define MAX_PACKET_SIZE 10240 // 數據包的最大長度,單位是sizeof(char)

define MAXFILEDIRLENGTH 256 // 存放文件路徑的最大長度

define PORT 4096 // 端口號

define SERVER_IP “127.0.0.1” // server端的IP地址

// 各種消息的宏定義

define INVALID_MSG -1 // 無效的消息標識

define MSG_FILENAME 1 // 文件的名稱

define MSG_FILELENGTH 2 // 傳送文件的長度

define MSG_CLIENT_READY 3 // 客戶端準備接收文件

define MSG_FILE 4 // 傳送文件

define MSG_SENDFILESUCCESS 5 // 傳送文件成功

define MSG_OPENFILE_ERROR 10 // 打開文件失敗,可能是文件路徑錯誤找不到文件等原因

define MSG_FILEALREADYEXIT_ERROR 11 // 要保存的文件已經存在了

class CCSDef
{
public:

pragma pack(1) // 使結構體的數據按照1字節來對齊,省空間

// 消息頭
struct TMSG_HEADER
{
    char    cMsgID;    // 消息標識

    TMSG_HEADER(char MsgID = INVALID_MSG)
        : cMsgID(MsgID)
    {
    }
};

// 請求傳送的文件名
// 客戶端傳給服務器端的是全路徑名稱
// 服務器傳回給客戶端的是文件名
struct TMSG_FILENAME : public TMSG_HEADER
{
    char szFileName[256];   // 保存文件名的字符數組

    TMSG_FILENAME()
        : TMSG_HEADER(MSG_FILENAME)
    {
    }
};

// 傳送文件長度
struct TMSG_FILELENGTH : public TMSG_HEADER
{
    long lLength;

    TMSG_FILELENGTH(long length)
        : TMSG_HEADER(MSG_FILELENGTH), lLength(length) 
    {

    }
};

// Client端已經準備好了,要求Server端開始傳送文件
struct TMSG_CLIENT_READY : public TMSG_HEADER
{
    TMSG_CLIENT_READY()
        : TMSG_HEADER(MSG_CLIENT_READY)
    {
    }
};

// 傳送文件
struct TMSG_FILE : public TMSG_HEADER
{
    union     // 採用union保證了數據包的大小不大於MAX_PACKET_SIZE * sizeof(char)
    {
        char szBuff[MAX_PACKET_SIZE];
        struct
        {
            int nStart;
            int nSize;
            char szBuff[MAX_PACKET_SIZE - 2 * sizeof(int)];
        }tFile;
    };

    TMSG_FILE()
        : TMSG_HEADER(MSG_FILE)
    {

    }
};

// 傳送文件成功
struct TMSG_SENDFILESUCCESS : public TMSG_HEADER
{
    TMSG_SENDFILESUCCESS()
        : TMSG_HEADER(MSG_SENDFILESUCCESS)
    {
    }
};

// 傳送出錯信息,包括:
// MSG_OPENFILE_ERROR:打開文件失敗
// MSG_FILEALREADYEXIT_ERROR:要保存的文件已經存在了
struct TMSG_ERROR_MSG : public TMSG_HEADER
{
    TMSG_ERROR_MSG(char cErrorMsg)
        : TMSG_HEADER(cErrorMsg)
    {
    }
};

pragma pack()

};

endif

/*
**服務端代碼源文件
*/

include “SocketTransfer.h”

char g_szNewFileName[MAXFILEDIRLENGTH];
char g_szBuff[MAX_PACKET_SIZE + 1];
long g_lLength;
char* g_pBuff = NULL;

// 初始化socket庫
bool InitSocket();
// 關閉socket庫
bool CloseSocket();
// 解析消息進行相應的處理
bool ProcessMsg(SOCKET sClient);
// 監聽Client的消息
void ListenToClient();
// 打開文件
bool OpenFile(CCSDef::TMSG_HEADER* pMsgHeader, SOCKET sClient);
// 傳送文件
bool SendFile(SOCKET sClient);
// 讀取文件進入緩衝區
bool ReadFile(SOCKET sClient);

int main()
{
InitSocket();
ListenToClient();
CloseSocket();

return 0;

}

void ListenToClient()
{
// 創建socket套接字
SOCKET sListen = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (SOCKET_ERROR == sListen)
{
printf(“Init Socket Error!\n”);
return;
}

// 綁定socket到一個本地地址
sockaddr_in sin;
sin.sin_family = AF_INET;
sin.sin_port = htons(PORT);
sin.sin_addr.S_un.S_addr = INADDR_ANY;
if (::bind(sListen, (LPSOCKADDR)&sin, sizeof(sockaddr_in)) == SOCKET_ERROR)
{
    printf("Bind Error!\n");
    return;
}

// 設置socket進入監聽狀態
if (::listen(sListen, 10) == SOCKET_ERROR)
{
    printf("Listen Error!\n");
    return;
}

printf("Listening To Client...\n");

// 循環接收client端的連接請求
sockaddr_in ClientAddr;
int nAddrLen = sizeof(sockaddr_in);
SOCKET sClient;

while (INVALID_SOCKET == (sClient = ::accept(sListen, (sockaddr*)&ClientAddr, &nAddrLen)))
{
}

while (true == ProcessMsg(sClient))
{
}

// 關閉同客戶端的連接
::closesocket(sClient);

::closesocket(sListen);

}

bool InitSocket()
{
// 初始化socket dll
WSADATA wsaData;
WORD socketVersion = MAKEWORD(2, 2);
if (::WSAStartup(socketVersion, &wsaData) != 0)
{
printf(“Init socket dll error\n”);
return false;
}

return true;

}

bool CloseSocket()
{
// 釋放winsock庫
::WSACleanup();

if (NULL != g_pBuff)
{
    delete [] g_pBuff;
    g_pBuff = NULL;
}

return true;

}

bool ProcessMsg(SOCKET sClient)
{
int nRecv = ::recv(sClient, g_szBuff, MAX_PACKET_SIZE + 1, 0);
if (nRecv > 0)
{
g_szBuff[nRecv] = ‘\0’;
}

// 解析命令
CCSDef::TMSG_HEADER* pMsgHeader = (CCSDef::TMSG_HEADER*)g_szBuff;
switch (pMsgHeader->cMsgID)
{
case MSG_FILENAME:    // 文件名
    {
        OpenFile(pMsgHeader, sClient);
    }
    break;
case MSG_CLIENT_READY:   // 客戶端準備好了,開始傳送文件
    {
        SendFile(sClient);
    }
    break;
case MSG_SENDFILESUCCESS: // 傳送文件成功
    {
        printf("Send File Success!\n");
        return false;
    }
    break;
case MSG_FILEALREADYEXIT_ERROR: // 要保存的文件已經存在了
    {
        printf("The file reay to send already exit!\n");
        return false;
    }
    break;
}

return true;

}

bool ReadFile(SOCKET sClient)
{
if (NULL != g_pBuff)
{
return true;
}

// 打開文件
FILE *pFile;
if (NULL == (pFile = fopen(g_szNewFileName, "rb")))   // 打開文件失敗
{
    printf("Cannot find the file, request the client input file name again\n");
    CCSDef::TMSG_ERROR_MSG tMsgErrorMsg(MSG_OPENFILE_ERROR);
    ::send(sClient, (char*)(&tMsgErrorMsg), sizeof(CCSDef::TMSG_ERROR_MSG), 0);
    return false;
}

// 把文件的長度傳回到client去
fseek(pFile, 0, SEEK_END);
g_lLength = ftell(pFile);
printf("File Length = %d\n", g_lLength);
CCSDef::TMSG_FILELENGTH tMsgFileLength(g_lLength);
::send(sClient, (char*)(&tMsgFileLength), sizeof(CCSDef::TMSG_FILELENGTH), 0);

// 處理文件全路徑名,把文件名分解出來
char szDrive[_MAX_DRIVE], szDir[_MAX_DIR], szFname[_MAX_FNAME], szExt[_MAX_EXT];
_splitpath(g_szNewFileName, szDrive, szDir, szFname, szExt);
strcat(szFname,szExt);
CCSDef::TMSG_FILENAME tMsgFileName;
strcpy(tMsgFileName.szFileName, szFname);
printf("Send File Name: %s\n", tMsgFileName.szFileName);
::send(sClient, (char*)(&tMsgFileName), sizeof(CCSDef::TMSG_FILENAME), 0);

// 分配緩衝區讀取文件內容
g_pBuff = new char[g_lLength + 1];
if (NULL == g_pBuff)
{
    return false;
}

fseek(pFile, 0, SEEK_SET);
fread(g_pBuff, sizeof(char), g_lLength, pFile);
g_pBuff[g_lLength] = '\0';
fclose(pFile);

return true;

}

// 打開文件
bool OpenFile(CCSDef::TMSG_HEADER* pMsgHeader, SOCKET sClient)
{
CCSDef::TMSG_FILENAME* pRequestFilenameMsg = (CCSDef::TMSG_FILENAME*)pMsgHeader;

// 對文件路徑名進行一些處理
char *p1, *p2;
for (p1 = pRequestFilenameMsg->szFileName, p2 = g_szNewFileName;
    '\0' != *p1;
    ++p1, ++p2)
{
    if ('\n' != *p1)
    {
        *p2 = *p1;
    }
    if ('\\' == *p2)
    {
        *(++p2) = '\\';
    }
}
*p2 = '\0';

ReadFile(sClient);

return true;

}

// 傳送文件
bool SendFile(SOCKET sClient)
{
if (NULL == g_pBuff)
{
ReadFile(sClient);
}

int nPacketBufferSize = MAX_PACKET_SIZE - 2 * sizeof(int); // 每個數據包存放文件的buffer大小
// 如果文件的長度大於每個數據包所能傳送的buffer長度那麼就分塊傳送
for (int i = 0; i < g_lLength; i += nPacketBufferSize)
{  
    CCSDef::TMSG_FILE tMsgFile;
    tMsgFile.tFile.nStart = i;
    if (i + nPacketBufferSize + 1> g_lLength)
    {
        tMsgFile.tFile.nSize = g_lLength - i;
    }
    else
    {
        tMsgFile.tFile.nSize = nPacketBufferSize;
    }
    //printf("start = %d, size = %d\n", tMsgFile.tFile.nStart, tMsgFile.tFile.nSize);
    memcpy(tMsgFile.tFile.szBuff, g_pBuff + tMsgFile.tFile.nStart, tMsgFile.tFile.nSize);
    ::send(sClient, (char*)(&tMsgFile), sizeof(CCSDef::TMSG_FILE), 0);
    Sleep(0.5);
}

delete [] g_pBuff;
g_pBuff = NULL;

return true;

}