linux学习之Socket
目录
编写socket-udp
第一步，编写套接字
第二步，绑定端口号
第三步，启动服务器，读取数据
第四步，接收消息并发回信息给对方
编写socket-Tcp
第一步，编写套接字
第二步，绑定端口号
第三步，将套接字设置为监听状态。
第四步，在服务器运行里获取新连接
第五步，进行读写通信
编写socket-udp
如何认识快速的Udp，我们先来编写一个udp服务器。
第一步，编写套接字
int socket
创建
socket
文件描述符
(TCP/UDP,
客户端
+
服务器
)
第一个参数domain即创建套接字的域，如下表：
看以看到有ipv4,ipv6,ipx等。
第二个参数为类型 当前socket的类型，如下图所示：
例如sock_stream为有序的可靠的字节流 ，sock_DGRAM为数据报类型等
第三个为参数protecal,指定域套接字一起使用的特定协议，通常在给定协议族中，只存在一个协议来支持特定的套接字类型。
创建成功会返回一个新的套接字，失败则会返回-1.
第二步，绑定端口号
接口bind
第一个参数为sockfd，套接字id，第二个为套接字类型，这里我们是网络接口，所以应该使用struct sockaddr_in类型的接口。但是我们一般也不会去创建，而是直接定义初始化内存直接用。这里用bzero来初始化内存为0：
之后初始化结构体的内容，设置结构体类型，端口号，ip地址。
之后进行由主机序列转到网络序列：
htons接口：
这些函数名很好记 ,h 表示 host,n 表示 network,l 表示 32 位长整数 ,s 表示 16 位短整数例如 htonl 表示将 32 位的长整数从主机字节序转换为网络字节序 , 例如将 IP 地址转换后准备发送。如果主机是小端字节序 , 这些函数将参数做相应的大小端转换然后返回 ;如果主机是大端字节序 , 这些 函数不做转换 , 将参数原封不动地返回。
除了端口号，一般在发送数据时，还需要连ip地址一起打包成封装发送出去，因此对于ip地址我们人需要转化成网络字节序列。分两步转化，现将字符串转化为四字节（uint32_t），再转化为网络字节序列。
当然系统也为我们提供了字符串转为网络字节序的接口 inet_addr:
之后开始绑定，注意结构体（套接字）类型一致，绑定成功返回0，失败返回-1.
第三步，启动服务器，读取数据
recvfrom接口 从套接字中获取消息：
参数一位网络文件描述符，参数二为获取的消息，参数三为长度，参数四为标志，当前我们就设置为0，参数五为接收方的套接字，参数六位套接字的大小，后面两个参数是输入型参数。成功返回获取信息的大小。
看可以看到收到消息，我们需要知道消息内容，发消息的源址。
第四步，接收消息并发回信息给对方
收到信息后，发回给对方，调用接口sendto：
参数一为网络文件描述符，参数二为字符缓冲区，参数三为长度，参数四为标志，参数五与参数六接口域recvfrom基本一致，不过这里最后两个参数为输入型参数。
之后我们可以用 netstat -nlup 来查看创建的服务器。
需要注意一点，云服务器不能直接绑定公网ip。我们一般推荐任务地址绑定。
对于端口的选择，我们【0，1023】都是系统端口，直接绑定需要root权限，一般需要有固定的应用协议层使用。绑定我们一般选大一点的端口号。
现在我们就编写一个客户端域服务端的demo版本，先来理解UDP通信：
Udpserver.hpp
#pragma once
#include<cstring>
#include<iostream>
#include<string.h>
#include<sys/types.h>
#include<sys/socket.h>
//包含下面两个头文件，此时struct sockeaddr_in 初始化有提示
#include<netinet/in.h>
#include<arpa/inet.h>
#include<unistd.h>
using namespace std;
const int Size=1024;
string defaultip="0.0.0.0";
uint16_t defaultport=8080;
enum{
SOCKET_ERR=1,
Bind_ERR
};
class UdpServer
{
public:
UdpServer(uint16_t &port=defaultport, const string &ip=defaultip):_sockfd(0),_port(port),_ip(ip),is_running(false)
{
}
//搭建udp网络服务器
void Init()
{
//1.创建套接字 协议为ipv4，类型为数据报
_sockfd=socket(AF_INET,SOCK_DGRAM,0); //这里除了AF_INIT 也可以写作PF_INIT
if(_sockfd<0)
{
cout<<"创建套接字失败,socket:"<<socket<<endl;
exit(SOCKET_ERR);
}else{
cout<<"创建套接字成功,socket:"<<socket<<endl;
}
//2.告诉服务器端口号，绑定端口号
struct sockaddr_in local;
//内容置空
bzero(&local,sizeof(local));
//初始化其中内容
local.sin_family=AF_INET;//ipv4的类型 该结构体前两个字节表示其类型
local.sin_port=htons(_port); //指明端口号，且由于端口好是发送到网络当中去，所以是网络字节序列
//由主机序列转到网络序列提供有接口，我们直接调用转化
local.sin_addr.s_addr=inet_addr(_ip.c_str()); //32位的地址,一般用户喜欢用点分十进制的字符串表示，
//其次对于ip地址，我们需要将字符串转化为uint32_t
//初始化对象完成，开始绑定套接字,设置到内核
if(bind(_sockfd,(const struct sockaddr*)&local,sizeof(local))<0)
{
printf("绑定失败,errno:%d,错误信息:%s",errno,strerror(errno));
exit(Bind_ERR);
}
cout<<"绑定成功！！！"<<endl;
}
void Run()
{
//服务器搭建成功
char buffer[Size];
is_running=true; //改变状态
while (is_running)
{
//读取数据
struct sockaddr_in client;
socklen_t len=sizeof(client);
ssize_t n=recvfrom(_sockfd,buffer,sizeof(buffer)-1,0,( struct sockaddr*)&client,&len);
if(n<0)
{
printf("接收失败,errno%d:,错误信息%s\n",errno,strerror(errno));
continue;
}
buffer[n]=0;
cout<<"接受消息:"<<buffer<<endl;
string info=buffer;
string string_echo="server echo#"+info;
//发回信息给对方
sendto(_sockfd,string_echo.c_str(),string_echo.size(),0,(const struct sockaddr*)&client,len);
}
}
~UdpServer()
{
if(_sockfd>0) close(_sockfd);
}
private:
int _sockfd; //网络文件描述符
uint16_t _port;//端口号
string _ip; //ip地址 一般绑定任意地址0.0.0.0 可以不需要给出ip。
bool is_running;//判断服务器是否再运行
};对应的.cc
#include"UdpServer.hpp"
#include<memory>
void Usage(string p)
{
cout<<"\n\rUsage: "<<p<<" prot[1024] bigger "<<endl;
}
int main(int argc,char *argv[])
{
if(argc!=2)
{
Usage(argv[0]);
exit(0);
}
//构建udp服务器
uint16_t port= stoi(argv[1]);
const string ip="0.0.0.0";
std::unique_ptr <UdpServer> svr(new UdpServer(port,ip));
svr->Init();
svr->Run();
return 0;
}
Udpclient.cc
#include<iostream>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<string.h>
using namespace std;
void Usage(string p)
{
cout<<"\n Usage:"<<p<<" ip_address port[1024+]"<<endl;
}
int main(int argc,char *argv[])
{
if(argc!=3)
{
Usage(argv[0]);
exit(0);
}
uint16_t port=stoi(argv[2]);
const string ip=argv[1];
//构建服务端的套接字
struct sockaddr_in server;
bzero(&server,sizeof(server));
server.sin_addr.s_addr=inet_addr(ip.c_str());
server.sin_family=AF_INET;
server.sin_port=htons(port);
socklen_t len=sizeof(server);
int sockfd=socket(AF_INET,SOCK_DGRAM,0);
if(sockfd<0)
{
cout<<"create socket error"<<endl;
return 1;
}
//需要绑定ip地址，端口号,不过不需要我们绑定，操作系统随机选择
//一个端口号只能被一个进程绑定，对于客服端也是如此
//客户端的端口号不重要，只要保持唯一性即可，因为服务端已经知道客户端是哪里的，在首次发送数据的时候就会绑定
string message;
char buffer[1024];
while(true)
{
cout<<"请输入你要发的消息@";
getline(cin,message);
//发数据报
sendto(sockfd,message.c_str(),message.size(),0,(const struct sockaddr*)&server,len);
cout<<".............."<<endl;
//该客户端可能还会读取其他服务器发消息
struct sockaddr_in temp;
socklen_t len=sizeof(temp);
ssize_t n=recvfrom(sockfd,buffer,1023,0,( struct sockaddr*)&temp,&len);
if(n>0)
{
buffer[n]=0;
cout<<"收到消息："<<buffer<<endl;;
}
// if(n<0)
// {
// printf("收到消息失败,errno %s,错误信息%s\n",errno,strerror(errno));
// }else
// {
// buffer[n]=0;
// printf("收到消息，消息：%s\n",buffer);
// }
}
close(sockfd);
return 0;
}既然有了服务端那么我们就可以在收到信息时，让他拿到ip地址，端口号和数据报文，同时创建同时在线的用户名单，一个发，所有可以看到。其次客户端显示信息也不太好，我们可以用多线程一个用来收，一个用来发。
改良版：
Udpserver.hpp
class UdpServer
{
public:
UdpServer(uint16_t &port=defaultport, const string &ip=defaultip):_sockfd(0),_port(port),_ip(ip),is_running(false)
{
}
//搭建udp网络服务器
//udp的套接字是全双工的
void Init()
{
//1.创建套接字 协议为ipv4，类型为数据报
_sockfd=socket(AF_INET,SOCK_DGRAM,0); //这里除了AF_INIT 也可以写作PF_INIT
if(_sockfd<0)
{
cout<<"创建套接字失败,socket:"<<socket<<endl;
exit(SOCKET_ERR);
}else{
cout<<"创建套接字成功,socket:"<<socket<<endl;
}
//2.告诉服务器端口号，绑定端口号
struct sockaddr_in local;
//内容置空
bzero(&local,sizeof(local));
//初始化其中内容
local.sin_family=AF_INET;//ipv4的类型 该结构体前两个字节表示其类型
local.sin_port=htons(_port); //指明端口号，且由于端口好是发送到网络当中去，所以是网络字节序列
//由主机序列转到网络序列提供有接口，我们直接调用转化
local.sin_addr.s_addr=inet_addr(_ip.c_str()); //32位的地址,一般用户喜欢用点分十进制的字符串表示，
//其次对于ip地址，我们需要将字符串转化为uint32_t
//初始化对象完成，开始绑定套接字,设置到内核
if(bind(_sockfd,(const struct sockaddr*)&local,sizeof(local))<0)
{
printf("绑定失败,errno:%d,错误信息:%s",errno,strerror(errno));
exit(Bind_ERR);
}
cout<<"绑定成功！！！"<<endl;
}
string Handler(const string info,const string clientip,const uint16_t clientport)
{
cout<<"["<<clientip<<": "<<to_string(clientport)<<"] @"<<info<<endl;
string res="server get a message :";
res+=("["+clientip+":"+to_string(clientport)+"] @");
res+=info;
return res;
}
void Broadcast(const string info,const string clientip,const uint16_t clientport) //收到消息发送给所有用户
{
for( auto &it :_users)
{
string messages=" get a message :";
messages+=("["+clientip+":"+to_string(clientport)+"] @");
messages+=info;
socklen_t len=sizeof(it.second);
sendto(_sockfd,messages.c_str(),messages.size(),0,(const struct sockaddr*)&(it.second),len);
}
}
bool Checkuser(const struct sockaddr_in user,const string clientip,const uint16_t clientport)//检查用户是否存在，不存在添加用户
{
auto it=_users.find(clientip);
if(it==_users.end())
{
//添加用户
_users.insert(make_pair(clientip,user));
cout<<"["<<clientip<<": "<<to_string(clientport)<<"] has added to online_users"<<endl;
}
}
void Run()
{
//服务器搭建成功
char buffer[Size];
is_running=true; //改变状态
while (is_running)
{
//读取数据
struct sockaddr_in client;
socklen_t len=sizeof(client);
ssize_t n=recvfrom(_sockfd,buffer,sizeof(buffer)-1,0,( struct sockaddr*)&client,&len);
if(n<0)
{
printf("接收失败,errno%d:,错误信息%s\n",errno,strerror(errno));
continue;
}
//获取用户的ip地址与端口号
uint16_t clientport=ntohs(client.sin_port);
std::string clientip=inet_ntoa(client.sin_addr);
//先检测用户是否存在过
Checkuser(client,clientip,clientport);
//广播给所有用户
std::string info = buffer;
Broadcast(info,clientip,clientport);
;
//发回信息给对方
string string_echo="echo#"+info;
sendto(_sockfd,string_echo.c_str(),string_echo.size(),0,(const struct sockaddr*)&client,len);
}
}
~UdpServer()
{
if(_sockfd>0) close(_sockfd);
}
private:
int _sockfd; //网络文件描述符
uint16_t _port;//端口号
string _ip; //ip地址 一般绑定任意地址0.0.0.0 可以不需要给出ip。
bool is_running;//判断服务器是否再运行
//保存客户端用户信息
std::unordered_map<string,struct sockaddr_in> _users;
};ucpclient.cc
#include<iostream>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<string.h>
#include<pthread.h>
using namespace std;
struct ThreadDate
{
int sockfd;
struct sockaddr_in server;
};
void Usage(string p)
{
cout<<"\n Usage:"<<p<<" ip_address port[1024+]"<<endl;
}
void *send_message(void *args)
{
ThreadDate *td=static_cast<ThreadDate*>(args);
std::string message;
socklen_t len=sizeof(td->server);
while(true)
{
cout<<"请输入你要发的消息@";
getline(cin,message);
//发数据报
sendto(td->sockfd,message.c_str(),message.size(),0,(const struct sockaddr*)&(td->server),len);
cout<<".............."<<endl;
}
}
void *recive_mesage(void *args)
{
ThreadDate *td=static_cast<ThreadDate*>(args);
char buffer[1024];
while(true)
{
struct sockaddr_in temp;
socklen_t len=sizeof(temp);
ssize_t n=recvfrom(td->sockfd,buffer,1023,0,( struct sockaddr*)&temp,&len);
if(n>0)
{
buffer[n]=0;
cout<<"收到消息："<<buffer<<endl;;
}
}
}
int main(int argc,char *argv[])
{
if(argc!=3)
{
Usage(argv[0]);
exit(0);
}
uint16_t port=stoi(argv[2]);
const string ip=argv[1];
struct ThreadDate td;
//初始化服务端的套接字
bzero(&td.server,sizeof(td.server));
td.server.sin_addr.s_addr=inet_addr(ip.c_str());
td.server.sin_family=AF_INET;
td.server.sin_port=htons(port);
socklen_t len=sizeof(td.server);
td.sockfd=socket(AF_INET,SOCK_DGRAM,0);
if(td.sockfd<0)
{
cout<<"create socket error"<<endl;
return 1;
}
//需要绑定ip地址，端口号,不过不需要我们绑定，操作系统随机选择
//一个端口号只能被一个进程绑定，对于客服端也是如此
//客户端的端口号不重要，只要保持唯一性即可，因为服务端已经知道客户端是哪里的，在首次发送数据的时候就会绑定
//创建两个线程 一个用来接受，一个用来发送
pthread_t reciver,sender;
pthread_create(&reciver,nullptr,recive_mesage,&td);
pthread_create(&sender,nullptr,send_message,&td);
pthread_join(reciver,nullptr);
pthread_join(sender,nullptr);
这里在编写的时候注意地址转化函数，,sockaddr_in中的成员struct in_addr sin_addr表示32位 的IP 地址 但是我们通常用点分十进制的字符串表示IP 地址,以下函数可以在字符串表示 和in_addr表示之间转换;
其中inet_pton和inet_ntop不仅可以转换IPv4的in_addr,还可以转换IPv6的in6_addr,因此函数接口是void*addrptr。
关于inet_ntoa：inet_ntoa这个函数返回了一个char*, 很显然是这个函数自己在内部为我们申请了一块内存来保存ip的结果. 那么是否需要调用者手动释放呢?
实际上内部放在了静态区中，但是多线程在竞争调用时，还是会出现线程安全，现在在centos7上好像做了改善，里面加了锁，但是应用的时候，如果我们不放心还是尽量使用inet_mtop这样的接口。
编写socket-Tcp
学了Udp套接字的编写，Tcp相对来说会好一点，因为Tcp与Udp本来就是有交集的。
首先刚开始的套路一样：
第一步，编写套接字
与udp一样，创建sockfd文件描述符。不过这里的参数二即类型我们设置为 SOCK_STREAM（数据流）类型。
第二步，绑定端口号
在绑定端口号前，需要创建sock_addrin结构体并初始化，在将字符串Ip地址转化为网络字节序，我们这里使用的接口为inet_aton().
参数一为char*类型ip，参数二为sin_addr.
第三步不一样。
第三步，将套接字设置为监听状态。
listen 将套接字设置为监听状态
成功返回0，错误返回-1.第二个参数代表列表长度。
第四步，在服务器运行里获取新连接
accept获取新连接
参数一文件描述符，后两个参数为输出型参数，为addrin及其长度，可以获知哪一个客户端的信息。返回值成功返回文件描述符，否则返回-1。
与Udp不同，udp的套接字从始至终都只有一个，而Tcp有两个，实际上最开始的套接字，并不是我们要去通信的套接字，Tcp通信的套接字，是要在accept之后的套接字。因此之前的套接字，我们也可以叫做监听套接字。
之后我们就可以测试了，即使我们没写客户端，但在系统下会有一个工具telnet,可以指定登录远程服务器。
这里注意一点，无论是Tcp还是Udp我们都无法绑定公网ip。
第五步，进行读写通信
与Udp不同，我们这里不使用recvfrom与sendto接收发送消息，而是用文件描述符进行通信。
用read与write。
之后就可以编写客户端进行通信了。
对于客户端通过connect发起连接。
后两个参数为输出型参数，用来保存信息。成功返回0，否则-1.
Tcpserver.hpp
#pragma once
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <strings.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <memory>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
using namespace std;
// 错误码
enum
{
SOCKERROR = 2,
BINDERROR,
LISTENERROR,
ACCEPTEEROR
};
const uint16_t defaultfd = -1;
const std::string defaultip = "127.0.0.1";
const uint16_t defaultport = 8080;
class TcpServer;
struct PthreadData
{
PthreadData( int sockfd,std::string clientip,uint16_t port,TcpServer*tcp):_newsockfd(sockfd),_clientip(clientip),_clientport(port),_server(tcp)
{
}
int _newsockfd;
std::string _clientip;
uint16_t _clientport;
TcpServer *_server;
};
class TcpServer
{
public:
TcpServer(const uint16_t port = defaultport, const int socket = defaultfd, const string ip = defaultip) : _port(port), _listensockfd(socket), _ip(ip)
{
}
void Init()
{
// 创建套接字
_listensockfd = socket(AF_INET, SOCK_STREAM, 0); // TCP我们使用流类型
if (_listensockfd == -1)
{
cout << "错误码：" << errno << ",错误信息: " << strerror(errno) << endl;
exit(SOCKERROR);
}
cout << "创建成功......" << endl;
// 创建sockaddr 并且绑定端口号
struct sockaddr_in local;
bzero(&local, sizeof(local));
local.sin_family = AF_INET;
// local.sin_addr.s_addr=inet_addr(c_str(_ip));
local.sin_port = htons(_port);
inet_aton(_ip.c_str(), &(local.sin_addr));
socklen_t len = sizeof(local);
// 绑定套接字
int n = bind(_listensockfd, (const struct sockaddr *)&local, len);
if (n < 0)
{
cout << "绑定失败,错误码:" << errno << "，错误信息:" << strerror(errno) << endl;
exit(BINDERROR);
}
cout << "绑定成功........." << endl;
// 将套接字设置为监听状态
// 因为Tcp是面向字节流的，且是被动的，服务器需要一直打开来接受客户端的请求
if (listen(_listensockfd, 5) == -1)
{
cout << "设置监听失败"
<< "错误码，" << errno << "错误信息" << strerror(errno) << endl;
exit(LISTENERROR);
}
cout << "listen has finished......" << endl;
}
void Service(int &sockfd, uint16_t &port, char *ip)
{
// 测试收到消息显示出来,
char buffer[1024];
// 读取消息
while (true)
{
ssize_t n = read(sockfd, buffer, sizeof(buffer));
fflush(stdin);
if (n > 0)
{
buffer[n] = 0;
cout << "收到来自 ip:" << ip << "端口号：" << port << "的消息:" << buffer << endl;
// 写回消息，发送消息
string inputbuffer = "server recive message";
inputbuffer += buffer;
write(sockfd, inputbuffer.c_str(), inputbuffer.size());
}
else
{
cerr << "信息读取错误，错误码" << errno << "，错误信息" << strerror(errno) << endl;
break;
}
}
}
static void *Running(void *args)
{
PthreadData*data=static_cast<PthreadData*> (args);
pthread_detach(pthread_self());
data->_server->Service(data->_newsockfd, data->_clientport, (char*)(data->_clientip).c_str());
//这里不能关闭描述符
delete data;
return nullptr;
}
void Start()
{
while (true)
{
cout << "server is running....." << endl;
sleep(1);
// 由于参数为输出型参数，需要给一个sockaddrin来保存客户端的信息
struct sockaddr_in client;
socklen_t len = sizeof(client);
// 获取新连接
int newsockfd = accept(_listensockfd, (struct sockaddr *)&client, &len); // 阻塞式等待
// 对于这两个套接字 ，—listensockfd，可以理解为拉拢客户端 newsockfd，理解为处理客户端
// 之前的监听套接字不是我们真正要去处理客户端的套接字 ，只有在accept之后获取的新套接字才是
if (newsockfd < 0) // 客户端会有很多，accept失败继续去accept
{
cout << "accept error" << endl;
continue;
}
uint16_t clientport = htons(client.sin_port);
char clientip[80];
// 转为char*
inet_ntop(AF_INET, &(client.sin_addr), clientip, sizeof(clientip));
// 根据新连接通信
cout << "get a new link.....,"
<< "端口号: " << clientport << "ip :" << clientip << endl;
// 通过newsockfd进行通信
// 提供服务
// Service(newsockfd, clientport, clientip);
// close(newsockfd);
// 修改为多进程版
// pid_t id = fork();
// if (id == 0)
// {
// close(_listensockfd);
// // 子进程
// if(fork()>0)
// {
// //当前进程直接退出
// exit(0);
// }
// //孙子进程来执行service
// //我直接退出，孙子进程交给系统领养就可以并发访问了。
// Service(newsockfd, clientport, clientip);
// close(newsockfd);
// exit(0);
// }
// close(newsockfd);//这里注意需要关闭 子进程已经拿去用了，如果不关，父进程的文件描述符越来越少
// //这里其实也并不会关闭，里面有引用计数
// // 父进程
// pid_t rid = waitpid(id, nullptr,0);//子进程是阻塞等待，但父进程我们要求继续运行，这里等待设置为
// (void)rid;
//但是创建进程消耗太大，还是不是很好，因此我们用线程来执行
pthread_t tid;
PthreadData *data=new PthreadData(newsockfd,clientip,clientport,this);
pthread_create(&tid, nullptr,Running,data);
//我们不想让它直接等待，而是自己去玩自己的，设置detach
}
}
private:
int _listensockfd;
uint16_t _port;
string _ip;
};main.cc
#include<iostream>
#include<memory>
#include <unistd.h>
#include"Tcpserver.hpp"
void Helper(char *str)
{
cout<<"please enter command in correct :"<<str<<" port[1024+]."<<endl;
}
int main(int argc,char*argv[])
{
if(argc!=2)
{
Helper(argv[0]);
exit(1);
}
uint16_t port=atoi(argv[1]);
std::unique_ptr <TcpServer> svr(new TcpServer(port));
svr->Init();
svr->Start();
}
Tcpclient.cc
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <strings.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
using namespace std;
void Helper(char *s)
{
cout<<"please enter in coorrct command"<<s<<" port[1024+],"<<" ip(0.0.0.0)"<<endl;
}
int main(int argc,char *argv[])
{
if(argc!=3)
{
Helper(argv[0]);
exit(1);
}
uint16_t serverport=stoi(argv[1]);
string serverip=string(argv[2]);
int sockfd=socket(AF_INET,SOCK_STREAM,0);
if(sockfd<0)
{
cerr<<"Error,创建套接字错误"<<endl;
return 1;
}
//不需要显示绑定，系统给绑定了,会在我们connect发起连接后，自动随机绑定
//发起连接
//通过命令行参数获取ip地址与端口号
struct sockaddr_in server;
bzero(&server, sizeof(server));
server.sin_family=AF_INET;
inet_pton(AF_INET,serverip.c_str(),&server.sin_addr);
server.sin_port=htons(serverport);
socklen_t len=sizeof(server);
int n=connect(sockfd,(const struct sockaddr*)&server,len);
if(n<0)
{
cerr<<"Error,连接失败,错误码"<<errno<<"错误信息"<<strerror(errno)<<endl;
return 2;
}
cout<<"连接成功......"<<endl;
//发消息
while(true)
{
string message;
cout<<"please enter#"<<endl;
getline(cin,message);
//将消息写入文件中
write(sockfd,message.c_str(),message.size());
//写完消息，再接受来自服务端的消息
char buf[1024];
int n=read(sockfd,buf,sizeof(buf));
if(n<0)
{
cerr<<"接收消息失败,错误码"<<errno<<"错误信息"<<strerror(errno)<<endl;
}else{
buf[n]=0;
cout<<"port :"<<serverport<<" ip:"<<serverip<<"recive:"<<buf<<endl;
}
}
close(sockfd);
return 0;
}这里的多线程也不是最好的，因为可能存在多线程，少资源的情况，这里最后直接把线程池拿过来，我需要几个线程就创造几个线程来用。从而效果达到更优。