一.socket编程：
（一）TCP/UDP介绍：
- UDP:用户数据报协议。=>无连接，不可靠传输，面向数据报。面向数据报：无连接的不可靠的，无序的，有最大长度限制的数据传输服务。例如：（视频传输），实时性>安全性。
- TCP：传输控制协议。面向连接，可靠传输，面向字节流。面向字节流：连接的，可靠的，有序的，双向的字节流传输：以字节为单位，不限制上层传输大小的传输方式。例如：（文件传输）
（二）网络通信：
- 网络通信：网络两端口主机进程之间的通信。
- 两端：客户端与服务端。客户端发送请求，服务端别动接收请求的主机
- 网络通信五元组：目的IP地址，源IP地址，目的端口，源端口，通信协议。
二、socket中UDP与TCP编写：
（一）UDP网络通信程序编程：
1. 客户端与服务端的编写流程。
（1）客服端：
①创建套接字；②为套接字绑定信息；③发送数据；④接收数据；⑤关闭套接字。
（2）服务端：
①创建套接字，–在内核中创建socket结构体，向进程返回操作句柄，通过内核中的socket结构体与网卡建立联系；
②为套接字绑定信息，（IP地址与端口信息）–绑定地址信息是为了告诉操作系统，我使用了那个端口和那个IP地址接收信息，当某个数据的目的地址和我绑定的地址信息相同，就把信息传送给我；
③接收数据–在socket结构体中的缓冲区中取出数据，每个数据都包括源地址和目的地址，因此获取数据也就知道了对端是谁；
④发送数据–将数据拷贝到内核中的socket结构体发送缓冲区中，操作系统会在这个时候合适的时候在缓冲区取出数据，并层层封装，将数据发送出去；
⑤关闭套接字释放资源。
- 注意：操作系统对于接收到的数据，判断目的地址信息，去socket内核容器去查找目的地址：
①找到了，就将数据放入到socket接收缓冲区；
②没找到，就直接丢弃。
2. socket接口信息：
（1）创建套接字：
-
int socket (int domain，int type，int protocol); - domain ： 地址域，不同网络地址结构。例如：AF_INET --IPV4地址域； - type ： 套接字类型：数据报套接字（udp）、流式套接字(tcp)。udp : SOCK_DGRAM ; tcp : SOCK_STREAM。 - protocol ：使用的协议；0--不同套接字下的默认协议。IPPROTO_TCP ：TCP协议；IPPROTO_UDP：UDP协议。返回值：返回套接字的操作句柄—文件描述符。
（2）为套接字绑定地址信息： -
int bind(int sockfd , struct sockaddr* addr , socklen_t len); - sockfd ：创建套接字返回的句柄； - *addr ：要绑定的地址信息结构； - len ：地址信息长度。返回值：成功返回 0 ，失败反回 -1。
对于sockaddr ,用户西安定义sockaddr_in 的IPV4地址结构，强转之后传入bind中。
（3）发送数据 sendto: -
int sendto( int sockfd，char* data，int data_len，int flag，struct sockaddr* dest_addr，socklen_t * addr_len); - sockfd：操作句柄； - data：发送数据首地址； - data_len ：数据发送长度； - flag : 选项参数，默认为0，阻塞操作。MSG_DONTWAIT，设置为非阻塞。若发送的缓冲区满了，0默认堵塞，MSG_DONTWAIT则报错返回； - dest_addr：目的端地址信息结构，（数据发送的目的地址）； - addr_len：地址信息结构长度；
返回值：成功返回实际发送的数据字节数，错误返回 -1。
（4）接收数据recvfrom:
-
返回值：成功返回接收到的地址信息长度，失败返回-1；int recvfrom(int sockfd，char* buf，int len，int flag，struct sockaddr* dest_addr，socklen_t* addr_len); - sockfd：操作句柄； - buf：缓冲区的首地址，用于存放收到的数据； - len：读取数据的长度； - flag：0--默认堵塞操作； - dest_addr：接受源端的发送地址，便于回复； - addr_len：指定获取多长的地址信息，获取地址之后，返回实际的地址信息长度。
（5）关闭套接字： -
int close(int sockfd); - sockfd : 操作句柄。
注意： ①客户端中绑定地址信息一般不推荐用户自己进行绑定。而是让操作系统在发送数据的时候发现socket还没有绑定地址信息，然后自动选择一个合适的ip地址和端口信息进行绑定。避免用户自己绑定的端口已被占用而产生端口冲突。
②服务端必须绑定地址信息结构，客户端所知道的服务端的信息都是服务端自己所绑定的 ，一旦不绑定，则会造成OS随意选择合适的地址进行绑定，服务端则就会不知道自己到底绑定的是什莫，从而无法接收数据。
3. UDP套接字编程：
（1）UDP服务端程序：使用C语言编写：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <netinet/in.h> //sockaddr结构体/ IPPROTO_UDP
#include <arpa/inet.h> //包含一些字节序转换的接口
#include <sys/socket.h>//套接字接口头文件
int main(int argc, char *argv[])
{
//argc表示参数个数，通过argv向程序传递端口参数
if (argc != 3) {
printf("./udp_srv ip port em: ./udp_srv 192.168.132.3 5000\n");
return -1;
}
const char *ip_addr = argv[1];
uint16_t port_addr = atoi(argv[2]);
//socket(地址域, 套接字类型, 协议类型)
int sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (sockfd < 0) {
perror("socket error");
return -1;
}
//bind(套接字描述符, 地址结构, 地址长度);
//struct sockaddr_in ipv4地址结构
// struct in_addr{ uint32_t s_addr };
struct sockaddr_in addr;
addr.sin_family = AF_INET;
//htons-将两个字节的主机字节序整数转换为网络字节序的整数
addr.sin_port = htons(port_addr);//注意千万不要使用htonl
//inet_addr 将一个点分十进制的字符串IP地址转换为网络字节序的整数IP地址
addr.sin_addr.s_addr = inet_addr(ip_addr);
socklen_t len = sizeof(struct sockaddr_in);//获取IPv4地址结构长度
int ret = bind(sockfd, (struct sockaddr*)&addr, len);
if (ret < 0) {
perror("bind error");
return -1;
}
while(1) {
char buf[1024] = {0};
struct sockaddr_in cliaddr;
socklen_t len = sizeof(struct sockaddr_in);
//recvfrom(描述符，缓冲区，长度，参数，客户端地址信息， 地址信息长度)
//阻塞接收数据，将数据放入buf中，将发送端的地址放入cliaddr中
int ret = recvfrom(sockfd, buf, 1023, 0, (struct sockaddr*)&cliaddr,&len);
if (ret < 0) {
perror("recfrom error");
close(sockfd);//关闭套接字
return -1;
}
printf("client say: %s\n", buf);
printf("server say:");
fflush(stdout);//让用户输入数据，发送给客户端
memset(buf, 0x00, 1024); //清空buf中的数据
scanf("%s", buf);
//通过sockfd将buf中的数据发送到cliaddr客户端
ret =sendto(sockfd, buf, strlen(buf), 0, (struct sockaddr*)&cliaddr, len);
if (ret < 0) {
perror("sendto error");
close(sockfd);//关闭套接字
return -1;
}
}
close(sockfd);//关闭套接字
}
（2）客服端的实现（用c++封装客服端）：
#include <iostream>
#include <cstdio>//stdio.h
#include <string>//std::string
#include <unistd.h>//close接口
#include <stdlib.h>//atoi接口
#include <netinet/in.h>//地址结构定义
#include <arpa/inet.h>//字节序转换接口
#include <sys/socket.h>//套接字接口
class UdpSocket
{
public:
UdpSocket():_sockfd(-1){
}
//1. 创建套接字
bool Socket() {
//socket(地址域， 套接字类型，协议类型);
//AF_INET-标识这是IPv4的通信，并且提供的是数据报传输服务，使用的协议是UDP协议
_sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (_sockfd < 0) {
perror("socket error");
return false;
}
return true;
}
//2. 为套接字绑定地址信息
bool Bind(const std::string &ip, uint32_t port) {
//1. 定义IPv4地址结构
struct sockaddr_in addr;
addr.sin_family = AF_INET;//地址域，用于向bind接口表明这是一个ipv4地址结构
addr.sin_port = htons(port);//网络字节序的端口信息
addr.sin_addr.s_addr = inet_addr(ip.c_str());//网络字节序的IP地址信息
/*
struct sockaddr_in {
sa_family_t sin_family;
in_port_t sin_port;
struct in_addr{
in_addr_t s_addr;
}sin_addr;
}
*/
//2. 绑定地址
socklen_t len = sizeof(struct sockaddr_in);
//bind(描述符， 统一地址结构sockaddr*， 地址信息长度)
int ret = bind(_sockfd, (struct sockaddr*)&addr, len);
if (ret < 0) {
perror("bind error");
return false;
}
return true;
}
//3. 发送数据
bool Send(const std::string &data, const std::string &ip, uint16_t port) {
//sendto(描述符，数据，长度，选项， 对端地址，地址长度)
//1. 定义对端地址信息的ipv4地址结构
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr.s_addr = inet_addr(ip.c_str());
//2. 向这个地址发送数据
int ret;
socklen_t len = sizeof(struct sockaddr_in);
ret = sendto(_sockfd, data.c_str(), data.size(), 0, (struct sockaddr*)&addr, len);
if (ret < 0) {
perror("sendto error");
return false;
}
return true;
}
//输入型参数使用const 引用
//输出型参数使用指针
//输入输出型使用引用
//4. 接收数据
bool Recv(std::string *buf, std::string *ip = NULL, uint16_t *port = NULL) {
//recvfrom(描述符，缓冲区，数据长度，选项，对端地址，地址长度)
struct sockaddr_in addr;//用于获取发送端地址信息
socklen_t len = sizeof(struct sockaddr_in);//指定地址长度以及获取实际地址长度
int ret;
char tmp[4096] = {0};//临时用于存放数据的缓冲区
ret = recvfrom(_sockfd, tmp, 4096, 0, (struct sockaddr*)&addr, &len);
if (ret < 0) {
perror("recvfrom error");
return -1;
}
buf->assign(tmp, ret);//给buf申请ret大小的空间，从tmp中拷贝ret长度的数据进去
//为了接口灵活，用户若不想获取地址信息，则不再转换获取
//只有当用户想要获取地址的时候，这时候传入缓冲区，我们将数据写入进去
//类似于想吃苹果就给我篮子，我把苹果放进去，不给篮子就表示不想吃
if (ip != NULL) {
*ip = inet_ntoa(addr.sin_addr);//将网络字节序整数IP地址转换为字符串地址，返回
}
if (port != NULL) {
*port = ntohs(addr.sin_port);
}
return true;
}
//5. 关闭套接字
void Close() {
close(_sockfd);
_sockfd = -1;
return ;
}
private:
//贯穿全文的套接字描述符
int _sockfd;
};
#define CHECK_RET(q) if((q)==false){return -1;}
//客户端要给服务端发送数据，那么就需要知道服务端的地址信息
//因此通过程序运行参数传入服务端的地址信息
int main(int argc, char *argv[])
{
if (argc != 3) {
printf("em: ./udp_cli 192.168.122.132 9000\n");
return -1;
}
//argv[0] = ./udp_cli
//argv[1] = 192.168.122.132
//argv[2] = 9000
std::string ip_addr = argv[1];//服务端地址信息
uint16_t port_addr = atoi(argv[2]);
UdpSocket sock;
CHECK_RET(sock.Socket());//创建套接字
//CHECK_RET(sock.Bind());//绑定地址信息
while(1) {
//获取一个标准输入的数据，进行发送
std::cout << "client say: ";
fflush(stdout);
std::string buf;
std::cin >> buf;// 获取标准输入的数据
sock.Send(buf, ip_addr, port_addr);//向指定的主机进程发送buf数据
buf.clear();//清空buf缓冲区
sock.Recv(&buf);//因为本身客户端就知道服务端的地址，因此不需要再获取了
std::cout << "server say: " << buf << std::endl;
}
sock.Close();
return 0;
}
（二）TCP网络通信程序编程：
1. 客户端与服务端编写流程：
(1)客户端：
①创建套接字；②绑定地址信息（不推荐）；③向服务端发起请求；④收发收数据；⑤关闭套接字。
(2)服务端：
①创建套接字：在内核中创建socket结构体；
②绑定地址信息：通过socket描述源端地址信息；
③开始监听：告诉操作系统可以开始接受连接请求（tcp面向连接，通信前先建立连接）；服务端接收新客户端连接请求，会为客户端创建一个新的socket, 这个套接字中既具有源端信息，也具有对端信息；这个新创建的套接字用于与这个客户端进行通信。
最早的套接字：监听套接字—只用于接收新客户端连接请求；
新创建的套接字：通信套接字–用于后续与客户端进行数据通信。
④服务端程序中获取这个新建套接字的操作句柄描述符，因为后续与这个客户端的通信都是通过这个操作句柄完成的；最早的套接字描述符操作句柄只是用于建立连接，获取新连接的；
⑤收发数据:因为tcp的套 接字socket中既描述了源端，也描述了对端，因此收发数据不需要在获取/指定对端的地址信息了，并且连接建立以后，谁先发送数据都可以；
⑥关闭套接字：释放资源。
2. TCP中socket接口信息：
（1）创建套接字：
-
int socket(int domain ，int type ，int protocol);
（2）绑定地址信息：
-
int bind(int socket，struct sockaddr* addr,socklen_t len);
（3）服务端监听套接字：
-
int listen(int sockfd,int backlog);//告诉操作系统开始接收连接请求。 - backlog : 同一时间能够接受客户端连接请求的数量。
（4）获取新建套接字的操作句柄：从内核指定socket的pending queue中取出socket，返回操作句柄。
-
int accept(int sockfd，struct sockaddr* addr,socklen_t len); - sockfd : 监听套接字； - addr ：获取一个套接字，这个套接字与指定的客户端通信，通过addr获取客户端信息； - len 指定地址信息返回的实际长度；
（5）通过新获取的套接字句柄和呵护端进行连接：
①接收数据：
-
ssize_t recv(int sockfd，char* buf，int len ，int flag）;
②发送数据：
-
ssize_t send(int sockfd ，char* data，int len ，int flag)
(6)客户端向服务端发送连接请求：
-
int connect (int sockfd，int sockaddr* addr，socket_t len );
(7) 关闭套接字：
-
int close(int sockfd);
3. TCP套接字编程：
（1）TcpSocket类的封装：
//* 描 述：封装实现一个tcpsocket类，向外提供简单接口；
//* 使外部通过实例化一个tcpsocket对象就能完成tcp通信程序的建立
================================================================*/
#include <cstdio>
#include <string>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#define BACKLOG 10
#define CHECK_RET(q) if((q)==false){return -1;}
class TcpSocket
{
public:
TcpSocket():_sockfd(-1){
}
int GetFd() {
return _sockfd;
}
void SetFd(int fd) {
_sockfd = fd;
}
//创建套接字
bool Socket() {
//socket(地址域，套接字类型，协议类型)
_sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (_sockfd < 0) {
perror("socket error");
return false;
}
return true;
}
void Addr(struct sockaddr_in *addr, const std::string &ip, uint16_t port) {
addr->sin_family = AF_INET;
addr->sin_port = htons(port);
inet_pton(AF_INET, ip.c_str(), &(addr->sin_addr.s_addr));
}
//绑定地址信息
bool Bind(const std::string &ip, const uint16_t port) {
//1. 定义IPv4地址结构
struct sockaddr_in addr;
Addr(&addr, ip, port);
socklen_t len = sizeof(struct sockaddr_in);
int ret = bind(_sockfd, (struct sockaddr*)&addr, len);
if (ret < 0) {
perror("bind error");
return false;
}
return true;
}
//服务端开始监听
bool Listen(int backlog = BACKLOG) {
//listen(描述符， 同一时间的并发链接数);
int ret = listen(_sockfd, backlog);
if (ret < 0) {
perror("listen error");
return false;
}
return true;
}
//客户端发起连接请求
bool Connect(const std::string &ip, const uint16_t port) {
//1. 定义ipv4地址结构，赋予服务端地址信息
struct sockaddr_in addr;
Addr(&addr, ip, port);
//2. 向服务端发起请求
//3. connect(客户端描述符，服务端地址信息，地址长度)
socklen_t len = sizeof(struct sockaddr_in);
int ret = connect(_sockfd, (struct sockaddr*)&addr, len);
if (ret < 0) {
perror("connect error");
return false;
}
return true;
}
//服务端获取新建连接
bool Accept(TcpSocket *sock, std::string *ip = NULL, uint16_t *port = NULL) {
//accept(监听套接字， 对端地址信息，地址信息长度) 返回新的描述符
struct sockaddr_in addr;
socklen_t len = sizeof(struct sockaddr_in);
//获取新的套接字，以及这个套接字对应的对端地址信息
int clisockfd = accept(_sockfd, (struct sockaddr*)&addr, &len);
if (clisockfd < 0) {
perror("accept error");
return false;
}
//用户传入了一个Tcpsocket对象的指针
//为这个对象的描述符进行赋值---赋值为新建套接字的描述符
//后续与客户端的通信通过这个对象就可以完成
sock->_sockfd = clisockfd;
if (ip != NULL) {
*ip = inet_ntoa(addr.sin_addr);//网络字节序ip-》字符串IP
}
if (port != NULL) {
*port = ntohs(addr.sin_port);
}
return true;
}
//发送数据
bool Send(const std::string &data) {
//send(描述符，数据，数据长度，选项参数)
int ret = send(_sockfd, data.c_str(), data.size(), 0);
if ( ret < 0 ) {
perror("send error");
return false;
}
return true;
}
//接收数据
bool Recv(std::string *buf) {
//recv(描述符， 缓冲区，数据长度，选项参数)
char tmp[4096] = {0};
int ret = recv(_sockfd, tmp, 4096, 0);
if (ret < 0) {
perror("recv error");
return false;
}else if (ret == 0) {
printf("connection break\n");
return false;
}
buf->assign(tmp, ret);//从tmp中拷贝ret大小的数据到buf中
return true;
}
//关闭套接字
bool Close() {
close(_sockfd);
_sockfd = -1;
}
private:
int _sockfd;
};
（2）客户端套接字编程：
①创建套接字；
②绑定地址信息（不推荐）；
③向服务器发送连接请求；
④与服务端进行通信；
⑤关闭套接字.
#include <iostream>
#include <stdlib.h>
#include <signal.h>
#include "tcpsocket.hpp"
void sigcb(int signo)
{
printf("连接已经断开，继续发送数据触发异常SIGPIPE信号\n");
}
int main(int argc, char *argv[])
{
if (argc != 3) {
printf("em:./tcp_cli 192.168.122.132 9000--服务绑定的地址\n");
return -1;
}
signal(SIGPIPE, sigcb);
std::string ip = argv[1];
uint16_t port = atoi(argv[2]);
TcpSocket cli_sock;
//创建套接字
CHECK_RET(cli_sock.Socket());
//绑定地址信息（不推荐）
//向服务端发起请求
CHECK_RET(cli_sock.Connect(ip, port));
//循环收发数据
while(1) {
printf("client say:");
fflush(stdout);
std::string buf;
std::cin >> buf;
//因为客户端不存在多种套接字的文件，因此一旦当前套接字出错直接退出就行
//进程退出就会释放资源，关闭套接字
cli_sock.Send(buf);
buf.clear();
cli_sock.Recv(&buf);
printf("server say: %s\n", buf.c_str());
}
cli_sock.Close();
return 0;
}
（3）服务端的编写：
#include <iostream>
#include <stdlib.h>
#include "tcpsocket.hpp"
int main(int argc, char *argv[])
{
if (argc != 3) {
printf("em:./tcp_srv 192.168.122.132 9000\n");
return -1;
}
std::string ip = argv[1];
uint16_t port = atoi(argv[2]);
TcpSocket lst_sock;
CHECK_RET(lst_sock.Socket());//创建套接字
//#define CHECK_RET(q) if((q)==false){return -1;}
//if (lst_sock.Socket() == false) {return -1;}
CHECK_RET(lst_sock.Bind(ip, port));//绑定地址信息
CHECK_RET(lst_sock.Listen());//开始监听
while(1) {
TcpSocket cli_sock;
std::string cli_ip;
uint16_t cli_port;
//Accept类成员函数，使用的私有成员_sockfd就是lst_sock的私有成员
//cli_sock取地址传入，目的是为了获取accept接口返回的通信套接字描述符
bool ret = lst_sock.Accept(&cli_sock, &cli_ip, &cli_port);//获取新套接字
if (ret == false) {
//获取新连接失败，可以重新继续获取下一个
continue;
}
printf("new connect:[%s:%d]\n", cli_ip.c_str(), cli_port);
//通过新获取的通信套接字与客户端进行通信
std::string buf;
if (cli_sock.Recv(&buf) == false) {
cli_sock.Close();//通信套接字接收数据出错，关闭的是通信套接字
continue;
}
printf("client:[%s:%d] say:%s\n", &cli_ip[0], cli_port, &buf[0]);
std::cout << "server say:";
fflush(stdout);
buf.clear();
std::cin >> buf;
if (cli_sock.Send(buf) == false) {
cli_sock.Close();
continue;
}
}
lst_sock.Close();
return 0;
}
扫一扫
499
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
