tcp recv 함수에서 문자열 수신 받지 못하는 문제 질문입니다.

// 생성자
CNetwork::CNetwork()
{
	// 변수 초기화
	m_FdMax = 0;
	m_StrLen = 0;
	m_FdNum = 0;
	m_i = 0;
	m_nPacketSize = 0;
 
	m_SqlTypeRetValue = 0;
 
	UB2 m_ubMsgType = 0;
 
	bzero(m_szSqlText, sizeof(m_szSqlText));
	bzero(m_szTmp, sizeof(m_szTmp));
 
	m_pStr = NULL;
 
	m_pBuf = new char[2048];
	if(m_pBuf == NULL)
	{
		cout << "CNetwork Memomry Allocate fail" << endl;
		exit(1); //
	}
}
 
// 소멸자
CNetwork::~CNetwork()
{
	delete []m_pBuf; //
	close(m_nSock);
}
 
// 소켓 설정 및 연결
int CNetwork::CNetworkRelayInit()
{
 
	m_nSock = socket(PF_INET, SOCK_STREAM, 0);
	memset(&m_ServAddr, 0, sizeof(m_ServAddr));
 
	m_ServAddr.sin_family = AF_INET;
	m_ServAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
	m_ServAddr.sin_port = htons(8687);
 
	m_nSock = socket(PF_INET, SOCK_STREAM, 0);
 
	if(bind(m_nSock, (struct sockaddr *)&m_ServAddr, sizeof(m_ServAddr)) == -1)
	{
		perror("CNetworkRelayInit() Bind Error");
		return PROGRAM_EXIT;
	}
 
	if(listen(m_nSock, 5) == -1)
	{
		perror("CNetworkRelay Listen Error..");
		return PROGRAM_EXIT;
	}
 
	return SUCCESS;
}
 
// 멀티 플렉싱 서버 설정
void CNetwork::CNetworkRelayMultiplexing()
{
	int nIdx;
	int retValue;
	UB2 msgType;
 
	FD_ZERO(&m_reads);
	FD_SET(m_nDBSock, &m_reads);
	FD_SET(m_nSock, &m_reads);
 
	m_FdMax = m_nSock;
 
	cout << "Proxy Server Service Start" << endl;
	while(true)
	{
		m_cpy_reads = m_reads;
		m_timeout.tv_sec = 5;
		m_timeout.tv_usec = 5000;
 
		if((m_FdNum = select(m_FdMax + 1, &m_cpy_reads, 0, 0, &m_timeout)) == -1)
		{
			cout << "Gateway_Select() Select Error" << endl;
			break;
		}
 
		if(m_FdNum == 0)
		{
			cout << "Gateway_Select() Time Out.." << endl;
			continue;
		}
 
		for(nIdx = 0; nIdx < m_FdMax + 1; nIdx++)
		{
			// cout << "select for state" << endl;
			if(FD_ISSET(nIdx, &m_cpy_reads))
			{
				if(nIdx == m_nSock) // request connection.
				{
					m_adrSz = sizeof(m_ClntAddr);
					m_nClntSock = accept(m_nSock, (struct sockaddr *)&m_ClntAddr, &m_adrSz);
					FD_SET(m_nClntSock, &m_reads);
 
					if(m_FdMax < m_nClntSock)
					{
						m_FdMax = m_nClntSock;
						cout << "========== CONNECTED CLIENT ==========" << endl;
					}
				}
				else
				{
					// 리턴 값에 따른 처리 분기
					cout << "select error" << endl;
					retValue = CNetworkRelayRecvPacket((char *)m_pBuf, &msgType, &nIdx);
					CNetworkRelayCheckMsgService((char *)m_pBuf, msgType, nIdx);
				}
			}
		}
	}
}
 
// 메세지 타입 별 서비스 호출
void CNetwork::CNetworkRelayCheckMsgService(char * a_pBuf, UB2 a_ubMsgType, int nIdx)
{
	cout << "CNetworkRelayCheckMsgService" << a_ubMsgType << endl;
	// 로그인 요청 메세지, SQL 요청 메세지, 서버로부터 수신받은 SQL 응답 메세지, 종료 요청 메세지
	if(a_ubMsgType == AUTH_REQ_MSG) // 1
	{
		cout << "CNetworkRelayCheckMsgService AUTH_REQ_MSG ERROR" << endl;
		CNetworkRelayAuthService(nIdx);
	}
	else if(a_ubMsgType == AUTH_RES_MSG) // 2
	{
		cout << "CNetworkRelayCheckMsgService AUTH_RES_MSG ERROR" << endl;
		CNetworkRelayAuthResService();
	}
	else if(a_ubMsgType == SQL_REQ_MSG) // 3
	{
		CNetworkRelaySqlService(nIdx);
	}
	else if(a_ubMsgType == SQL_RES_MSG) // 4
	{
		CNetworkRelaySqlResService();
	}
	else if(a_ubMsgType == CLOSE_REQ_MSG) // 5
	{
		CNetworkRelayCloseService(nIdx);
	}
	else if(a_ubMsgType == CLOSE_RES_MSG) // 6
	{
		CNetworkRelayCloseResService();
	}
	else
	{
		// a_ubMsgType 이 잘 못 온 경우 구현
	}
}
 
void CNetwork::CNetworkRelayAuthService(int a_nIdx)
{
	// 로그인 요청 패킷 서버에 전송
	send(m_nDBSock, &m_LoginReqMsg, sizeof(dgt_auth_req_msg), 0);
 
	// 로그인 요청 패킷 출력 소스 작성
	m_nCsocket = a_nIdx;
}
 
// 로그인 응답 메세지 클라이언트에 전송
void CNetwork::CNetworkRelayAuthResService()
{
	send(m_nCsocket, &m_LoginResMsg, sizeof(dgt_auth_res_msg), 0);
 
}
 
void CNetwork::CNetworkRelaySqlService(int a_nIdx)
{
	// SQL 요청 메세지 출력 소스 작성
 
	// SQL 요청 메세지 서버로 전송
	send(m_nDBSock, &m_SqlReqMsg, sizeof(dgt_sql_req_msg), 0);
	m_nCsocket = a_nIdx;
}
 
void CNetwork::CNetworkRelaySqlResService()
{
	// SQL 응답 메세지 출력 소스 작성
 
	// 클라이언트에게 전송
	send(m_nCsocket, &m_SqlResMsg, sizeof(dgt_sql_res_msg), 0);
}
 
void CNetwork::CNetworkRelayCloseService(int a_nIdx)
{
	// CLOSE 요청 메세지 출력 소스 작성
 
	// 서버에 클로즈 요청 메세지 전송
	send(m_nDBSock, &m_CloseReqMsg, sizeof(dgt_close_req_msg), 0);
	m_nCsocket = a_nIdx;
}
 
void CNetwork::CNetworkRelayCloseResService()
{
	// CLOSE 응답 메세지 출력 소스 작성
 
	// 클라이언트에 클로즈 응답 메세지 전송
	send(m_nCsocket, &m_CloseReqMsg, sizeof(dgt_close_req_msg), 0);
}
 
int CNetwork::CNetworkRelayConnectDBServer()
{
	m_nDBSock = socket(PF_INET, SOCK_STREAM, 0);
	if(m_nDBSock == -1)
	{
		cout << "Gateway_Connect_DBServer() Socket Error!!" << endl;
		return PROGRAM_EXIT;
	}
 
	bzero(&m_DbAddr, sizeof(m_DbAddr));
	m_DbAddr.sin_family = AF_INET;
	m_DbAddr.sin_addr.s_addr = inet_addr("192.168.1.204");
	m_DbAddr.sin_port = htons(8688);
 
	if(connect(m_nDBSock, (struct sockaddr *)&m_DbAddr, sizeof(m_DbAddr)) == -1)
	{
		perror("Gateway_Connect_DBServer Connect Error!!");
		return PROGRAM_EXIT;
	}
	else
		perror("welcome..");
 
	return SUCCESS;
}
 
int CNetwork::CNetworkRelaySqlTypeCheck(char * chBuf)
{
	cout << "chBuf : " << chBuf << endl;
	if(!strcmp(chBuf, "select"))
			return SELECT;
	else if(!strcmp(chBuf, "update"))
			return UPDATE;
	else if(!strcmp(chBuf, "delete"))
			return DELETE;
	else
			return 0;
}
 
// private 함수
// 0 이면 프로그램 종료
// BROKEN_PACKET 리턴되면 재입력
// 정상 수신이면 메세지 타입 리턴
int CNetwork::CNetworkRelayRecvPacket(char * m_pBuf, UB2 * a_msgType, int *a_nIdx)
{
 
	ssize_t recvCnt = 0;
	int msgBytePos = 0;
	int recvPacketCnt = 0;
 
	// m_pBuf 메모리 공간 0으로 초기화
	bzero(m_pBuf, 0);
 
	cout << "CNetworkRelayRecvPacket Error" << endl;
	while(true)
	{
		cout << "CNetworkRelayRecvPacket Before Recv Error" << endl;
		// 2바이트만 받는다
		recvCnt = recv(*a_nIdx, m_pBuf + msgBytePos, BUFSIZE, MSG_WAITALL);
		// 2바이트 이상 받으면 루프 탈출
		if(recvCnt >= 2)
		{
			msgBytePos = recvCnt;
			break;
		}
 
		msgBytePos += recvCnt;
 
		// EOF 프로그램 종료
		if(recvCnt == 0)
			return 0;
 
		// 실패 시 다시 수신한다
		if(recvCnt == -1)
		{
			cout <<"CNetworkRecvPacket Recv Error" << endl;
			msgBytePos = recvCnt = 0;
			continue;
		}
		cout << "CNetworkRelayRecvPacket After Recv Error" << endl;
	}
 
	// 메세지 타입 식별 위해 2바이트 복사
	memcpy(a_msgType, m_pBuf, sizeof(UB2));
 
	if(*a_msgType == AUTH_RES_MSG)
		recvPacketCnt = sizeof(dgt_auth_res_msg) - msgBytePos;
	else if(*a_msgType == SQL_RES_MSG)
		recvPacketCnt = sizeof(dgt_sql_res_msg) - msgBytePos;
	else if(*a_msgType == CLOSE_RES_MSG)
		recvPacketCnt = sizeof(dgt_close_res_msg) - msgBytePos;
	else
		return BROKEN_PACKET;
 
	// 남은 구조체 길이 만큼 수신한다
	while(msgBytePos < recvPacketCnt)
	{
		recvCnt = recv(*a_nIdx, m_pBuf + msgBytePos, BUFSIZE, MSG_WAITALL);
		if(recvCnt == -1)
			return 0;
		if(recvCnt == 0)
			return 0;
 
		msgBytePos += recvCnt;
	}
 
	// 타입에 맞는 구조체로 변환한다
	if(*a_msgType == AUTH_RES_MSG)
		m_LoginResMsg = *(dgt_auth_res_msg*)m_pBuf;
	else if(*a_msgType == AUTH_REQ_MSG)
		m_LoginReqMsg = *(dgt_auth_req_msg *)m_pBuf;
	else if(*a_msgType == SQL_RES_MSG)
		m_SqlResMsg = *(dgt_sql_res_msg *)m_pBuf;
	else if(*a_msgType == SQL_REQ_MSG)
		m_SqlReqMsg = *(dgt_sql_req_msg *)m_pBuf;
	else if(*a_msgType == CLOSE_RES_MSG)
		m_CloseResMsg = *(dgt_close_res_msg *)m_pBuf;
	else if(*a_msgType == CLOSE_REQ_MSG)
		m_CloseReqMsg = *(dgt_close_req_msg *)m_pBuf;
 
	return *a_msgType;
}