windows平台probuf协议socket通信例子

#include "common/op_socket.h"
#include "people.pb.h"
#pragma comment(lib, "libprotobuf.lib")
#pragma comment(lib, "libprotoc.lib")
using namespace std;
int main()
{
GOOGLE_PROTOBUF_VERIFY_VERSION;
OP_SOCKET server_sockfd;
OP_SOCKET new_server_sockfd;
OP_SOCKADDR_IN server_addr;
OP_SOCKADDR_IN client_addr;
OP_SOCKLEN_T sin_size;
char buffer[BUFFER_SIZE + 1];
int bytes;
string str;
string data;
CPFS::People p;
#ifdef WIN32
WSADATA  Ws;
//Init Windows Socket
if (WSAStartup(MAKEWORD(2,2), &Ws) != 0)
{
fprintf(stderr, "Init Windows Socket Failed::%s", GetLastError());
return EXIT_FAILURE;
}
#endif
server_sockfd = op_socket(AF_INET, SOCK_STREAM, 0);
op_set_sockaddr_in(server_addr, AF_INET, htons(INADDR_ANY), htons(OP_PORT));
op_bind(server_sockfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr));
op_listen(server_sockfd, LISTEN_QUEUE);

while(1)
{
sin_size = sizeof(struct sockaddr_in);
new_server_sockfd = op_accept(server_sockfd, (struct sockaddr *)&client_addr, &sin_size);

bytes = op_recv(new_server_sockfd, buffer, BUFFER_SIZE, 0);
buffer[bytes] = '/0';
str = buffer;
cout << "You got a message from " << inet_ntoa(client_addr.sin_addr) << endl;
cout << "client_addr Message: " << str << endl;
if(str == "get")
{
p.set_id(1);
p.set_name("monkey");
p.set_email("mokeydong@gmail.com");
p.SerializeToString(&data);
char dst[BUFFER_SIZE];
strcpy(dst, data.c_str());
op_send(new_server_sockfd, dst, sizeof(dst), 0);
}
else
{
op_send(new_server_sockfd, "Fucking client_addr!/n", 16, 0);
}
op_close(new_server_sockfd);
}
op_close(server_sockfd);
google::protobuf::ShutdownProtobufLibrary();
getchar();
#ifdef WIN32
WSACleanup();
#endif
return EXIT_SUCCESS;
}

#include "stdafx.h"
#include <stdio.h>
#include <winsock2.h>
#include "tag_message.h"
#include <windows.h>
#include "minilzo.h"
#include <iostream>
#include <sstream>
#pragma comment(lib,"ws2_32.lib")
/*#pragma comment(lib, "../lib/libprotobuf.lib")  */
using namespace std;
#pragma warning(disable:4996)
#include <iostream>

#include <time.h>
#ifdef WIN32
#   include <windows.h>
#pragma comment(lib, "winmm.lib ")
#else
#   include <sys/time.h>
#endif
#ifdef WIN32
int
gettimeofday(struct timeval *tp, void *tzp)
{
time_t clock;
struct tm tm;
SYSTEMTIME wtm;
GetLocalTime(&wtm);
tm.tm_year     = wtm.wYear - 1900;
tm.tm_mon     = wtm.wMonth - 1;
tm.tm_mday     = wtm.wDay;
tm.tm_hour     = wtm.wHour;
tm.tm_min     = wtm.wMinute;
tm.tm_sec     = wtm.wSecond;
tm.tm_isdst    = -1;
clock = mktime(&tm);
tp->tv_sec = clock;
tp->tv_usec = wtm.wMilliseconds * 1000;
return (0);
}
#endif

string tirm_number(int n)
{
stringstream _ss;
_ss.str("");
if (n < 10)
{
_ss << "0" << n;
}
else
{
_ss << n;
}
return _ss.str();
}

unsigned int g_increase_id = 1000;
string get_uuid(string server_name)
{
stringstream _ss;
_ss.str("");

if (g_increase_id++ > 2000)
{
g_increase_id = 1000;
}

struct tm *ptr;
time_t lt;

lt = time(NULL);
ptr = localtime(<);

_ss << server_name  << ptr->tm_year<<tirm_number(ptr->tm_mon) << tirm_number(ptr->tm_mday);
_ss << tirm_number(ptr->tm_hour) << tirm_number(ptr->tm_min) << tirm_number(ptr->tm_sec);
_ss << g_increase_id;

return _ss.str();
}
void make_pack(NET_C2L_proof &packet)
{
packet.dw_world_name_crc = 100010;
packet.dwCurVersionID    = 10001;
packet.dwType            = 1;
strncpy(packet.szUserName,"jxf002",6);
strncpy(packet.szPsd,"111111",6);
strncpy(packet.szGUID,"111111",6);
}

int sock_connect(SOCKET &soc, SOCKADDR_IN &serveraddr)
{
if((soc = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) <= 0)
{
printf("Create socket fail!\n");
return -1;
}

serveraddr.sin_family = AF_INET;
serveraddr.sin_port = htons(4303);
serveraddr.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");

bool is_connected = true;
printf("Try to connect...\n");
if(connect(soc, (SOCKADDR *)&serveraddr, sizeof(serveraddr)) != 0)
{
printf("Connect fail!\n");
is_connected = false;
return 0;
}
else
{
printf("Connected\n");
}
return 1;

}

int get_input()
{
char buf[1024];
int ret = 0;
while(true)
{
cout << "please enter command: [close] [retry]" << endl;
cin.getline(buf, 50);
if(strstr(buf,"close"))
{
break;
}
else if(strstr(buf,"retry"))
{
ret = 1;
break;
}
else
{
cout << "Invalid command:" << buf << endl;
}
}
return ret;
}

void socket_receive(SOCKET &m_socket)
{
unsigned int tempsz = 0;
unsigned int msgsz = 0;
int nresult = 0;
char* tempptr = NULL;
tempsz = sizeof(unsigned int);
tempptr = (char*)&msgsz;
while(tempsz > 0)
{

nresult = ::recv(m_socket, tempptr, tempsz, 0);
if(0 == nresult)
{
return;
}
if(SOCKET_ERROR == nresult)
{
return;
}
else
{
tempsz -= nresult;
if (tempsz<0)
break;
tempptr += nresult;
}
}

if(SOCKET_ERROR != nresult)
{
char* bufin = new char[msgsz + msgsz/64 + 64];
tempsz = sizeof(unsigned int) + msgsz;
tempptr = bufin;
while(tempsz > 0)
{
timeval blocktime;
blocktime.tv_sec = 0;
blocktime.tv_usec = 150*1000;
fd_set fdread;
FD_ZERO(&fdread);
FD_SET(m_socket, &fdread);
int n = ::select(m_socket+1, &fdread, NULL, NULL, &blocktime);
if(n == 1)
{
nresult = ::recv(m_socket, tempptr, tempsz, 0);
if(0 == nresult)
{
return;
}
if(nresult == SOCKET_ERROR)
{
return;
}
else
{
tempsz -= nresult;

if (tempsz<0)
break;
tempptr += nresult;
}
}

}

unsigned int osz = *(unsigned int*)bufin;
unsigned char* buflzo = new unsigned char[osz];
lzo_uint sz = osz;

lzo1x_decompress((unsigned char*)(bufin + sizeof(unsigned int)), msgsz, buflzo, &sz,NULL);
try
{
NET_L2C_proof_result *packet = (NET_L2C_proof_result*)(buflzo);
cout << packet->dw_error_code << endl;
}
catch(...)
{
cout << "Packet error" << endl;
}
}

}

bool socket_send(int connect_result, SOCKET m_socket)
{
NET_C2L_proof packet;
make_pack(packet);
char buf[1024];

bool need_re_connect = false;
while(!need_re_connect && connect_result)
{

int nreturn = 0;
unsigned int headsz = sizeof(unsigned int);
char* header = (char*)&packet.dw_size;
while(headsz > 0)
{
nreturn = send(m_socket, header, headsz, 0);
if(SOCKET_ERROR == nreturn)
{
int err_no = WSAGetLastError();
printf("[HEAD]send error,(%d,%d)\n",nreturn,err_no);
Sleep(2000);
WSACleanup();
need_re_connect = true;
break;
}
else
{
header += nreturn;
headsz -= nreturn;
}
cout <<"[HEAD] " << nreturn <<","<< headsz << endl;
}
unsigned int sz = packet.dw_size;
unsigned char* data(NULL);
data = (unsigned char*)&packet;
while(sz > 0)
{
if(!data)
break;
nreturn = ::send(m_socket, (char*)data, sz, 0);
if(SOCKET_ERROR == nreturn)
{
int err_no = WSAGetLastError();
printf("[BODY]send error,(%d,%d)\n",nreturn,err_no);
Sleep(2000);
WSACleanup();
need_re_connect = true;
break;
}
else
{
data += nreturn;
sz -= nreturn;
}
cout <<"[BODY] " << nreturn <<","<< sz << endl;
}
if(need_re_connect)
{
break;
}
socket_receive(m_socket);
Sleep(1000);
}
Sleep(2000);
return need_re_connect;
}

int main()
{
SOCKET soc;
SOCKADDR_IN serveraddr;
SOCKADDR_IN clientaddr;

RE_CONNECT:
WSADATA wsa;
WSAStartup(MAKEWORD(1,1),&wsa);

int connect_result = sock_connect(soc, serveraddr);
bool socket_error = socket_send(connect_result, soc);

WSACleanup();

if (socket_error)
{
goto RE_CONNECT;
}

if(get_input() == 1)
{
goto RE_CONNECT;
}
return 0;
}