Linux网络编程之套接字 --TCP
Posted 格式化、、
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Linux网络编程之套接字 --TCP相关的知识，希望对你有一定的参考价值。
目录
🌈前言
这篇文章给大家带来套接字的学习！！！
🌸1、TCP相关API
使用TCP网络通信所用到的接口比UDP多了几个，因为TCP是需要进行连接的（面向连接）
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
// 创建 socket 文件描述符 (TCP/UDP, 客户端 + 服务器)
int socket(int domain, int type, int protocol);
// 绑定端口号 (TCP/UDP, 服务器)
int bind(int socket, const struct sockaddr *address, socklen_t address_len);
// 将套接字设置为监听用户到来的连接请求状态，监听是否有客户到来
int listen(int sockfd, int backlog);
// 服务器启动后，获取新的客户端的连接，该函数返回新的服务套接字，用于服务客户的请求(流式IO服务)
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
// 客户端向指定服务器发送连接请求
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
// 指定填充确定IP地址, 转化字符串风格IP("xx.zz.yy.sss")，并且自动进行主机字节序转换网络字节序
in_addr_t inet_addr(const char *cp));
🍡1.1、socket函数
函数解析
-
作用：它是用来创建套接字文件的，创建成功返回一个文件描述符，失败返回-1，并且设置errno
-
domain：它需要我们填充协议家族（地址类型）来指定网络协议，IPv4指定为：AF_INET
-
type：它需要我们填充通信类型，UDP协议是面向数据报的，我们填充SOCK_DGRAM即可，如果是TCP协议，那么填充SOCK_STREAM（其他详细查看man手册）
-
protocol：套接口所用的协议，一般为0，不指定
void Test()
// SOCK_STREAM: 提供有序的、可靠的、双向的和基于连接的字节流，使用带外数据传送机制，网络地址族使用TCP协议
int fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd < 0)
std::cout << "socket error: " << strerror(errno) << std::endl;
exit(1);
🍢1.2、bind函数
函数解析
-
服务器程序所监听的网络地址和端口号通常是固定不变的，客户端程序得知服务器程序的地址和端口号后就可以向服务器发起连接，服务器需要调用bind绑定一个固定的网络地址和端口号
-
作用：绑定网络信息（地址类型、端口号和IP地址）到内核中，成功返回0，错误返回-1，并且设置errno
-
addr：传sockaddr_in/sockaddr_un的地址，并且需要强转为通用类型sockaddr*
-
addrlen：sockaddr_in/sockaddr_un结构体所占内存空间的大小
void Test(uint16_t port, const string &ip)
int fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd < 0)
cout << "socket error: " << strerror(errno) << endl;
exit(1);
// 2. 绑定主机基本信息到内核
struct sockaddr_in Server;
socklen_t len = sizeof(Server);
memset(&Server, 0, len);
Server.sin_family = AF_INET; // "地址类型/协议家族"
Server.sin_port = htons(port); // 端口号
Server.sin_addr.s_addr = ip.empty() ? htonl(INADDR_ANY) : inet_addr(ip.c_str()); // IP地址
if (bind(fd, (const struct sockaddr *)&Server, len) < 0)
std::cout << "bind error: " << strerror(errno) << std::endl;
exit(1);
🍧1.3、listen函数
函数解析
-
作用：将套接字fd设置为监听到来的“连接请求状态”，监听是“否有”客户到来(TCP -> 面向连接)
-
sockfd：套接字文件描述符，socket函数的返回值
-
backlog：套接字的挂起"连接队列"的最大长度(一般由2到4)，用SOMAXCONN则为系统给出的最大值（最多允许有backlog个客户端处于连接等待状态）
-
返回值：成功返回0，失败返回-1，并且设置全局errno错误码
void Test(uint16_t port, const string &ip)
int fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd < 0)
cout << "socket error: " << strerror(errno) << endl;
exit(1);
// 2. 绑定主机基本信息到内核
struct sockaddr_in Server;
socklen_t len = sizeof(Server);
memset(&Server, 0, len);
Server.sin_family = AF_INET; // "地址类型/协议家族"
Server.sin_port = htons(port); // 端口号
Server.sin_addr.s_addr = ip.empty() ? htonl(INADDR_ANY) : inet_addr(ip.c_str()); // IP地址
if (bind(fd, (const struct sockaddr *)&Server, len) < 0)
std::cout << "Server bind error: " << strerror(errno) << std::endl;
exit(BIND_ERR);
// 3. 将套接字设置为监听到来的连接请求状态，监听是否有客户到来(TCP -> 面向连接)
// 第二个参数：套接字的挂起"连接队列"的最大长度(一般由2到4), 用SOMAXCONN则为系统给出的最大值
if (listen(fd, SOMAXCONN) < 0)
std::cout << "listen error: " << strerror(errno) << std::endl;
exit(3);
🍨1.4、accept函数
函数解析
-
作用：三次握手完成后（后面网络基础再解析）, 服务器调用accept()接受连接
-
如果服务器调用accept()时还没有客户端的连接请求，就一直阻塞等待直到有客户端连接到来
-
sockfd：套接字文件描述符，socket函数的返回值
-
addr是一个输出型参数，它由accept函数内部自动填充，它用于获取客户端的IP地址和端口号
-
addrlen参数是一个输入输出参数，输入需要调用者提供缓冲区addr的长度，以避免缓冲区溢出问题，输出的是客户端地址结构体的实际长度
-
该函数返回新的“服务”套接字，用于服务客户端的请求和回应(流式IO服务)
void Test(uint16_t port, const string &ip)
int fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd < 0)
cout << "socket error: " << strerror(errno) << endl;
exit(1);
// 2. 绑定主机基本信息到内核
struct sockaddr_in Server;
socklen_t len = sizeof(Server);
memset(&Server, 0, len);
Server.sin_family = AF_INET; // "地址类型/协议家族"
Server.sin_port = htons(port); // 端口号
Server.sin_addr.s_addr = ip.empty() ? htonl(INADDR_ANY) : inet_addr(ip.c_str()); // IP地址
if (bind(fd, (const struct sockaddr *)&Server, len) < 0)
std::cout << "Server bind error: " << strerror(errno) << std::endl;
exit(2);
// 3. 将套接字设置为监听到来的连接请求状态，监听是否有客户到来(TCP -> 面向连接)
if (listen(fd, SOMAXCONN) < 0)
std::cout << "Server listen error: " << strerror(errno) << std::endl;
exit(3);
// 4. 获取客户端的连接请求 -- 这里没有写循环
struct sockaddr_in Client;
socklen_t len = sizeof(Client);
memset(&Client, 0, len);
int Serverfd = accept(fd, (sockaddr*)&Client, &len);
if (Serverfd < 0)
cout << "accept error: " << strerror(errno) << endl;
exit(4);
close(Serverfd );
🍰1.5、connect函数
函数解析
-
作用：客户端向指定服务器发送连接请求，默认自动绑定本主机的sockaddr_in信息
-
最好不要自己bind，因为我们绑定的固定端口号可能被其他客户端给占用了，由OS自动分配即可
-
connect和bind的参数一致，区别在于bind的参数是自己的地址，而connect的参数是对方的地址
-
返回值：connect()成功返回0，出错返回-1，并且设置全局errno
void Init(uint16_t port_, const string ip_)
// 1. 获取sockfd
int sockfd_ = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd_ < 0)
std::cout << "Server make socket error: " << strerror(errno) << std::endl;
exit(SOCKET_ERR);
// 填充指定Server的sockaddr_in信息
struct sockaddr_in Server;
socklen_t len = sizeof(Server);
memset(&Server, 0, len);
Server.sin_family = AF_INET;
Server.sin_port = htons(port_);
Server.sin_addr.s_addr = inet_addr(ip_.c_str());
// 2. 向指定服务器发送连接请求 -- connet默认会自动绑定本主机的sockaddr_in信息
// 最好不要自己bind，因为我们绑定的固定端口号可能被其他客户端给占用了，由OS自动分配即可
if (connect(sockfd_, (const struct sockaddr *)&Server, len) < 0)
std::cout << "Client connet Server error: " << strerror(errno) << std::endl;
exit(1);
🌺2、TCP网络编程
🍡2.1、简单TCP通信程序 – 多进程版本
实现大小写转换服务器 – 使用TCP协议
-
注意：TCP于UDP不同，UDP是不需要连接的，服务器请求到来时会立刻处理(recvfrom和sendto)，多用户发送请求时，是不会阻塞住的！！！
-
TCP是需要连接的，设置监听套接字后，在等待获取用户连接时是会阻塞的，如果只用一个死循环进行获取请求和服务，那么将会导致其他用户连接不了，因为要等第一个用户的请求工作完了才行
-
这里我们设置一个多进程，父进程进行获取请求，子进程用来进行服务
下面服务器提供服务的API使用多进程来实现的
util.h – 用于保存相同的头文件
#pragma once
#include <iostream>
#include <string>
#include <cstring>
#include <cstdlib>
#include <cerrno>
#include <cassert>
#include <sys/types.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <signal.h>
#define BUFFER 1024
#define SOCKET_ERR 1
#define BIND_ERR 2
#define LISTEN_ERR 3
#define FORM_ERR 4
#define CONNET_ERR 5
TcpServer.cc – 服务器源代码
#include "until.h"
class TcpServer
public:
TcpServer(uint16_t port, std::string ip = "")
: ListenSockfd_(-1), port_(port), ip_(ip)
~TcpServer()
if (ListenSockfd_ > 2)
close(ListenSockfd_);
public:
void Init()
// 1. 获取sockfd
// SOCK_STREAM: 提供有序的、可靠的、双向的和基于连接的字节流，使用带外数据传送机制，网络地址族使用TCP协议
ListenSockfd_ = socket(AF_INET, SOCK_STREAM, 0);
if (ListenSockfd_ < 0)
std::cout << "Server make socket error: " << strerror(errno) << std::endl;
exit(SOCKET_ERR);
// 2. 绑定主机基本信息到内核
struct sockaddr_in Server;
socklen_t len = sizeof(Server);
memset(&Server, 0, len);
Server.sin_family = AF_INET; // "地址类型/协议家族"
Server.sin_port = htons(port_); // 端口号
Server.sin_addr.s_addr = ip_.empty() ? htonl(INADDR_ANY) : inet_addr(ip_.c_str()); // IP地址
if (bind(ListenSockfd_, (const struct sockaddr *)&Server, len) < 0)
std::cout << "Server bind error: " << strerror(errno) << std::endl;
exit(BIND_ERR);
// 3. 将套接字设置为监听到来的连接请求状态，监听是否有客户到来(TCP -> 面向连接)
// 第二个参数：套接字的挂起"连接队列"的最大长度(一般由2到4), 用SOMAXCONN则为系统给出的最大值
if (listen(ListenSockfd_, SOMAXCONN) < 0)
std::cout << "Server listen error: " << strerror(errno) << std::endl;
exit(LISTEN_ERR);
void Start()
int ServerSockfd;
while (true)
//-------------------------------------------------------------------------------------
// 4. 服务器启动后，获取新的客户端的连接
// 该函数返回新的服务套接字，用于服务客户的请求(流式IO服务)
struct sockaddr_in Client;
socklen_t len = sizeof(Client);
ServerSockfd = accept(ListenSockfd_, (struct sockaddr *)&Client, &len);
if (ServerSockfd < 0)
std::cout << "Server get connection for error" << strerror(errno) << std::endl;
continue;
// 获取Client网络信息 -- port、ip address -- 网络序列 <-> 主机序列
std::string ClientPort = std::to_string(ntohs(Client.sin_port));
std::string ClientIp = inet_ntoa(Client.sin_addr);
//-------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------
// 实现多客户端连接 -- 如果不使用多进程，只能对单个进程提供服务
int id = fork();
signal(SIGCHLD, SIG_IGN); // 忽略子进程的退出状态, 子进程退出直接释放
if (id == 0)
// 给客户端提供服务 -- 子进程做
Proservice(ClientPort, ClientIp, ServerSockfd);
exit(0);
// 父进程不能使用waitpid阻塞等待，上面已经设置捕捉SIGCHLD信号且忽略它了！
//-------------------------------------------------------------------------------------
public:
void Proservice(const std::string &ClientPort, const std::string &ClientIp, int ServerSockfd)
char inbuffer[BUFFER];
std::string outbuffer;
while (true)
// 5. 读取Client发送的数据 -- TCP->流式socket->文件流IO
memset(inbuffer, 0, BUFFER);
ssize_t Read = read(ServerSockfd, inbuffer, BUFFER - 1);
if (Read > 0)
inbuffer[Read] = 0;
// 客户端TCP之套接字socket编程
一、socket套接字
“IP地址 + 端口号 ”就称为socket。在TCP协议里，建立连接的两个进程各自有一个socket标识，这两个socket pair就唯一标识一个连接，描述网络连接的一对一关系。
Linux的基本哲学就是“一切皆文件”，其实socket就是一种特殊的文件，是“open—write/read—close”模式的一种实现。
二、socket的基本操作
1.socket()函数
socket函数对应于普通文件的打开操作。普通文件的打开操作返回一个文件描述字，而socket()用于创建一个socket描述符，它唯一标识一个socket，把它作为参数，通过它来进行一些读写操作。
当我们调用socket创建一个socket时，返回的socket描述字它存在于协议族空间中，但没有一个具体的地址。如果想要给它赋值一个地址，就必须调用bind()函数，否则就当调用connect()、listen()时系统会自动随机分配一个端口。
int socket(int domain, int type, int protocol);
domain：即协议域（协议族）。常用的协议族有，AF_INET、AF_INET6等等。协议族决定了socket的地址类型，在通信中必须采用对应的地址，如AF_INET决定了要用ipv4地址（32位）与端口号（16位）的组合。
type：指定socket类型，这里使用SOCK_STREAM。
protocol：指定协议。当proyocol为0时，会自动选择type类型对应的默认协议。
2.bind()函数
bind()函数把一个地址族中的特定地址赋给socket，也就是将给描述字绑定一个名字。通常服务器在启动的时候都会绑定一个众所周知的地址（ip地址+端口号），用于提供服务，客户端就可以通过它来接连服务器；但是客户端就不用指定，由系统自动分配一个端口号和自身的ip地址组合。这就是为什么通常服务器端在listen之前会调用bind()，而客户端就不会调用，而是在connect()时由系统随机生成一个。
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
sockfd：即socket描述字，它是通过socket()函数创建了唯一标识一个socket。
addr：一个const struct sockaddr *指针，指向要绑定给sockfd的协议地址。
addrlen：地址的长度。
这个地址结构根据地址创建socket时的地址协议族的不同而不同。
ipv4对应的是：
struct sockaddr_in
{
sa_family_t sin_family; /* address family: AF_INET */
in_port_t sin_port; /* port in network byte order */
struct in_addr sin_addr; /* internet address */
};/* Internet address. */
struct in_addr
{
uint32_t s_addr; /* address in network byte order */
}; 注意：网络字节序。机器中数据的存储方式有大端（高位存在低地址，低位存在高地址）和小端（高位存在高地址，低位存在低地址）之分，同理，对于网络中传输的数据流同样有大小端之分，因此TCP/IP协议规定：网络数据流应采用大端字节序，即低地址高字节。
3.listen()、connect()函数
如果作为一个服务器，在调用socket()、bind()之后就会调用listen()来监听这个socket，如果客户端这时调用connect()发出连接请求，服务器端就会接收到这个请求（建立与TCP服务器的连接）。
socket()函数创建的socket默认是一个主动类型的，listen()函数将socket变为被动类型的，等待客户的连接请求。
int listen(int sockfd, int backlog);
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
listen()函数
sockfd：为要监听的socket描述字
backlog：为相应socket可以排队的最大连接个数
connect()函数
sockfd：为客户端的socket描述字
addr：为服务器的socket地址
addrlen：为socket地址的长度。
4.accept()函数
服务器端依次调用socket()、bind()、listen()之后，就会监听指定的socket地址了。客户端依次调用socket()、connect()之后就向服务器发送了一个连接请求。服务器监听到这个请求之后，就会调用accept()函数取接收请求，这样连接就建立好了。
如果accpet成功，那么其返回值是由内核自动生成的一个全新的描述字，代表与返回客户的TCP连接。
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
sockfd：为服务器的socket描述字
addr：为指向struct sockaddr *的指针，用于返回客户端的协议地址
addrlen：为协议地址的长度。
注意：accept的第一个参数为服务器的socket描述字，是服务器开始调用socket()函数生成的，称为监听socket描述字；而accept函数返回的是已连接的socket描述字。一个服务器通常通常仅仅只创建一个监听socket描述字，它在该服务器的生命周期内一直存在。内核为每个由服务器进程接受的客户连接创建了一个已连接socket描述字，当服务器完成了对某个客户的服务，相应的已连接socket描述字就被关闭。
三、编码实现
服务器端 server.c
#include <stdio.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#define _BACKLOG_ 5
static void usage(const char* proc)
{
printf("Usage:%s [ip] [port]\n",proc);
}
int main(int argc,char* argv[])
{
if(argc != 3)
{
usage(argv[0]);
return 1;
}
int size;
int len;
char* client_ip;
int client_port;
char* ip = argv[1];
int port =atoi(argv[2]);
int listenfd = socket(AF_INET, SOCK_STREAM, 0 );
if(listenfd < 0)
{
perror("socket");
return 2;
}
struct sockaddr_in local;
local.sin_family = AF_INET;
local.sin_port = htons(port);
local.sin_addr.s_addr =inet_addr(ip);
if(bind(listenfd, (struct sockaddr*)&local, sizeof(local)) < 0)
{
perror("bind");
return 3;
}
if(listen(listenfd, _BACKLOG_) < 0)
{
perror("listen");
return 4;
}
printf("bind and listen success,wait accept...\n");
while(1)
{
struct sockaddr_in client;
len = sizeof(client);
client_ip = inet_ntoa(client.sin_addr);
client_port = ntohs(client.sin_port);
int socket = accept(listenfd,(struct sockaddr*)&client, &len);
if(socket < 0)
{
perror("accept");
continue;
}
char buf[1024];
while(1)
{
memset(buf, ‘\0‘, sizeof(buf));
size = read(socket, buf, sizeof(buf)-1);
if(size == 0)
{
printf("client closed...");
return 6;
}
else if(size > 0)
{
printf("[client_ip:%s] [client port:%d]:# %s\n",client_ip,client_port,buf);
continue;
}
else
{
perror("read");
break;
}
}
}
return 0;
}客户端 client.c
#include <stdio.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
static void usage(char* proc)
{
printf("%s [ip] [port]\n", proc);
}
int main(int argc, char* argv[])
{
if(argc != 3)
{
usage(argv[0]);
return 1;
}
char* ip = argv[1];
int port = atoi(argv[2]);
int sock = socket(AF_INET, SOCK_STREAM, 0);
if(sock < 0)
{
perror("socket");
return 2;
}
struct sockaddr_in server;
server.sin_family = AF_INET;
server.sin_port = htons(port);
server.sin_addr.s_addr = inet_addr(ip);
if(connect(sock, (struct sockaddr*)&server, sizeof(server)) < 0)
{
perror("connect");
return 3;
}
char buf[1024];
while(1)
{
memset(buf, ‘\0‘, sizeof(buf));
gets(buf);
if(write(sock, buf, sizeof(buf)) < 0)
{
perror("write");
continue;
}
}
return 0;
}
结果：
本文出自 “GREEN” 博客，请务必保留此出处http://green906.blog.51cto.com/10697569/1783103
以上是关于Linux网络编程之套接字 --TCP的主要内容，如果未能解决你的问题，请参考以下文章