虚拟机linux 与 Windows socket连接

Windows 做服务器： server.cpp

#include <WinSock2.h> 
#include <string>
#include <stdlib.h>
#include <iostream> 
using namespace std;
#pragma comment(lib,"WS2_32.Lib") 
#define BUF_SIZE 64 // 缓冲区大小 

int main(int argc, char* argv[])
{
	//初始化WSA  
	WORD sockVersion = MAKEWORD(2, 2);
	WSADATA wsaData;
	if (WSAStartup(sockVersion, &wsaData) != 0)
	{
		return -1;
	}

	//创建套接字  
	SOCKET slisten = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (slisten == INVALID_SOCKET)
	{

		return -1;
	}

	//绑定IP和端口  
	sockaddr_in sin;
	sin.sin_family = AF_INET;
	sin.sin_port = htons(xxxx);
	sin.sin_addr.S_un.S_addr = INADDR_ANY;
	if (bind(slisten, (LPSOCKADDR)&sin, sizeof(sin)) == SOCKET_ERROR)
	{

	}

	//开始监听  
	if (listen(slisten, 5) == SOCKET_ERROR)
	{

		return -1;
	}

	//循环接收数据  
	SOCKET sClient;
	sockaddr_in remoteAddr;
	int nAddrlen = sizeof(remoteAddr);
	char revData[255];
	while (true)
	{

		sClient = accept(slisten, (SOCKADDR *)&remoteAddr, &nAddrlen);
		if (sClient == INVALID_SOCKET)
		{

			continue;
		}
       //发送数据  
		const char * sendData = "你好，TCP客户端！\n";
		send(sClient, sendData, strlen(sendData), 0);

		int ret;
		while (true) 
		{
			//接收数据  
		ret= recv(sClient, revData, 255, 0);
		if (ret > 0)
		{
			revData[ret] = 0x00;
			printf("%s\n",revData);
			send(sClient, revData, strlen(revData), 0);
		}
		else {
			Sleep(5);
			printf("断开\n");
			break;
		}
		}
		
		
	}

	closesocket(sClient);
	WSACleanup();
	return 0;                                            
}

linux 做客户端： client.c

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <netdb.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
int main(int argc,char *argv[])
{
    int sockfd,numbytes;
    char buf[BUFSIZ];
    struct sockaddr_in their_addr;
    while((sockfd = socket(AF_INET,SOCK_STREAM,0)) == -1);
    their_addr.sin_family = AF_INET;
    their_addr.sin_port = htons(xxxx);
    their_addr.sin_addr.s_addr=inet_addr("xxx.xxx.xxx.xxx");
    bzero(&(their_addr.sin_zero), 8); 
    
    while(connect(sockfd,(struct sockaddr*)&their_addr,sizeof(struct sockaddr)) == -1);
    printf("success!");
     
        numbytes = recv(sockfd, buf, BUFSIZ,0);//接收服务器端信息
        buf[numbytes]='\0';
        printf("received:%s\n",buf);

        while(1)
        {
            sleep(2);
            memset(buf, 0, sizeof(buf));
            char name[10];
            printf("给服务器发送:");
            scanf("%s",name);
            sprintf(buf,name,sizeof(name));
            numbytes = send(sockfd, buf, strlen(buf), 0);
            numbytes=recv(sockfd,buf,BUFSIZ,0);
            if(numbytes>0)
            {
            buf[numbytes]='\0';
            printf("received:%s\n",buf);
            }
            else
            {
                sleep(2);
                break;
            }
        }
        printf("连接已断开\n");
        close(sockfd);
    return 0;
}

===================================================================================
Windows 客户端：client.cpp

#include <WinSock2.h> 
#include <string>
#include <stdlib.h>
#include <iostream> 
using namespace std;
#pragma comment(lib,"WS2_32.Lib") 
#define BUF_SIZE 64 // 缓冲区大小 


int main(int argc, char* argv[])
{
	WSADATA wsd; // 用于初始化Windows Socket 
	SOCKET sHost; // 与服务器进行通信的套接字 
	SOCKADDR_IN servAddr; // 服务器地址 
	char buf[BUF_SIZE]; // 用于接受数据缓冲区 
	int retVal;
	// 初始化Windows Socket
	if (WSAStartup(MAKEWORD(2, 2), &wsd) != 0)
	{
		printf("WSAStartup failed !\n");
		return 1;
	}
	// 创建套接字 
	sHost = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (INVALID_SOCKET == sHost)
	{
		printf("socket failed !\n");
		WSACleanup();
		return -1;
	}
	// 设置服务器地址 
	servAddr.sin_family = AF_INET;
	servAddr.sin_addr.S_un.S_addr = inet_addr("xxx.xxx.xxx.xxx"); // 用户需要根据实际情况修改
	servAddr.sin_port = htons(xxxx); // 在实际应用中，建议将服务器的IP地址和端口号保存在配置文件中
	int sServerAddlen = sizeof(servAddr);
	// 循环连接服务器
	while (true)
	{
		retVal = connect(sHost, (LPSOCKADDR)&servAddr, sizeof(servAddr));
		if (INVALID_SOCKET == sHost)
		{
			int err = WSAGetLastError();
			if (err == WSAEWOULDBLOCK) // 无法立即完成非阻塞套接字上的操作
			{
				Sleep(500);
				printf("continue !\n");
				continue;
			}
			else
			{
				printf("accept failed !\n");
				closesocket(sHost);
				WSACleanup();
				return -1;
			}
		}
		printf("accept OK！\n");
		Sleep(500);
		break;
	}
	// 循环向服务器发送字符串，并显示反馈信息。
	// 发送quit将使服务器程序退出，同时客户端程序自身也将退出
	while (true)
	{
		// 向服务器发送数据 
		printf("Please input a string to send: ");
		// 接收输入的数据
		std::string str;
		std::getline(std::cin, str);
		// 将用户输入的数据复制到buf中
		ZeroMemory(buf, BUF_SIZE);
		strcpy_s(buf, str.c_str());
		// 向服务器发送数据
		retVal = send(sHost, buf, strlen(buf), 0);
		//清空缓冲区
		memset(&buf, 0, sizeof(buf));
		if (SOCKET_ERROR == retVal)
		{
			printf("send failed !\n");
			closesocket(sHost);
			WSACleanup();
			return -1;
		}


		// 接收服务器回传的数据 
		retVal = recv(sHost, buf, sizeof(buf) + 1, 0);
		printf_s("Recv From Server: %s\n", buf);
	}
	// 释放资源 
	closesocket(sHost);
	WSACleanup();
	// 暂停，按任意键继续
	system("pause");
	return 0;
}

linux 服务器:server.c

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <netinet/in.h>
#include <signal.h>
#define PORT xxxx /*侦听端口地址*/
#define BACKLOG 2 /*侦听队列长度*/

void process_conn_server(int s)
{
ssize_t size = 0;
char buffer[1024]; /*数据的缓冲区*/

for(;;){ /*循环处理过程*/
size = recv(s, buffer, 1024,0);
/*从套接字中读取数据放到缓冲区buffer中*/
if(size == 0){ /*没有数据*/
return;
}
write(1,buffer,size); /*写到标准输出*/
printf("\n");
sprintf(buffer,"%s this is server return\n",buffer);
send(s, buffer, strlen(buffer)+1,0); /*发给客户端*/
memset(&buffer,0,sizeof(buffer)); /*清空缓冲区*/
}
}

int main(int argc, char*argv[])
{
int ss,sc; /*ss为服务器的socket描述符，sc为客户端的socket描述符*/
struct sockaddr_in server_addr; /*服务器地址结构*/
struct sockaddr_in client_addr; /*客户端地址结构*/
int err; /*错误值*/
pid_t pid; /*分叉的进行id*/


ss = socket(AF_INET, SOCK_STREAM, 0); /*建立一个流式套接字*/
if(ss < 0){ /*出错*/
printf("socket error\n");
return -1; 
}

/*设置服务器地址*/
bzero(&server_addr, sizeof(server_addr)); /*清零*/
server_addr.sin_family = AF_INET; /*协议族*/
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);/*本地地址*/
server_addr.sin_port = htons(PORT); /*服务器端口*/
/*绑定地址结构到套接字描述符*/
err = bind(ss, (struct sockaddr*)&server_addr, sizeof(server_addr));
if(err < 0){ /*绑定出错*/
printf("bind error\n");
return -1;
}
err = listen(ss, BACKLOG); /*设置侦听队列长度*/
if(err < 0){ /*出错*/
printf("listen error\n");
return -1;
}
/*主循环过程*/
for(;;) {
int addrlen = sizeof(struct sockaddr);
/*接收客户端连接*/
sc = accept(ss, (struct sockaddr*)&client_addr, &addrlen);
if(sc < 0){ /*客户端连接出错*/
continue; /*结束本次循环*/
}

/*建立一个新的进程处理到来的连接*/
pid = fork(); /*分叉进程*/
if( pid == 0 ){ /*子进程中*/
close(ss); /*在子进程中关闭服务器的侦听*/
process_conn_server(sc); /*处理连接*/
}else{
close(sc); /*在父进程中关闭客户端的连接*/
}
}
}