一、网络套接字
一个文件描述符指向一个套接字(该套接字内部由内核借助两个缓冲区实现。)
在通信过程中，套接字一定是成对出现的
套接字通讯原理示意图：
二、预备知识
1. 网络字节序
内存中的多字节数据相对于内存地址有大端和小端之分
小端法：(PC本地存储)高位存高地址，低位存低地址
大端法：(网络存储)高位存低地址，低位存高地址
网络的数据流采用大端字节序，而本地的数据流采用小端字节序，因此要通过函数来完成网络字节序和主机字节序的转换
htonl：本地 -->网络 (IP协议) 本地字节序转网络字节序，转32位
htons：本地 --> 网络 (port端口)
ntohl：网络 --> 本地 (IP)
ntohs：网络 --> 本地 (port)
其中：h表示host，n表示network，l表示32位(4字节)长整数，s表示16位短整数
2. IP地址转换函数
int inet_pton(int af, const char *src, void *dst);
本地字节序(string IP)转换成网络字节序
参数
aft：AF_INET、AF_INET6
src：传入，IP地址(点分十进制)
dst：传出，转换后的网络字节序的IP地址。
返回值
成功：1
异常：0，说明src指向的不是一个有效的ip地址。失败：-1
const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
网络字节序转换成本地字节序(string IP)
参数
aft：AF_INET、AF_INET6
src：网络字节序IP地址
dst：本地字节序(string IP)size：dst的大小
返回值
成功：dst失败：NULL
3. sockaddr地址结构
struct sockaddr_in addr ;
addr.sin_family = AF_INET/AF_INET6 man 7 ip
addr.sin_port = htons(9527);
int dst ;
inet _pton(AF_INET，"192.157.22.45"，(void *)&dst) ;addr.sin_addr.s_addr = dst;
addr.sin_addr. s_addr = htonl(INADDR_ANY); 取出系统中有效的任意IP地址。二进制类型。
bind(fd,(struct sockaddr*)&addr，size);
- sin_family：表示你要使用的地址结构类型，AF_INET是IPV4，AF_INET6是IPV6；
- sin_port：网络字节序的端口号，因此要使用htons转换一下；
- struct in_addr sin_addr：一个结构体，里面有一个s_addr，要传入网络字节序的ip地址，因此要使用inet_pton函数；也可以使用第二种方法使用宏：addr.sin_addr. s_addr = htonl(INADDR_ANY);
三、网络套接字函数
1. socket模型创建流程分析
当服务器端调用socket函数时会产生一个套接字，而accept函数会阻塞监听客户端连接，当有客户端过来连接的时候，该函数会返回一个新的套接字去和客户端连接，因此一个socket建立会有两个套接字，另外一个套接字用于监听。即：整个流程一共用到3个套接字，一对用于通信，一个用于监听
2. socket函数
头文件：
#include <sys/types.h>
#include <sys/socket.h>
int socket(int domain, int type,int protocol) ; 创建一个套接字参数：
domain：AF_INET、AF_INET6、AF_UNIX
type：数据传输协议，SOCK_STREAM或SOCK_DGRAM
protocol：默认传0，根据type来选择，SOCK_STREAM的代表协议是TCP，SOCK_DGRAM的是UDP返回值：
成功：新套接字所对应文件描述符
失败:：-1 errno
3. bind函数
头文件：
#include <arpa/inet.h>
int bind(int sockfd,const struct sockaddr *addr，socklen_t addrlen) ;
给socket绑定一个地址结构(IP+port)参数：
sockfd：socket函数的返回值
struct sockaddr_in addr;addr.sin_family= AF_INET;
addr.sin_port = htons(8888);
addr.sin_addr. s_addr = htonl (INADDR_ANY);网络地址为INADDR_ANY，这个宏表示本地的任意IP地址，因为服务器可能有多个网卡，每个网卡也可能绑定多个IP地址，这样设置可以在所有的IP地址上监听，直到与某个客户端建立了连接时才确定下来到底用哪个IP地址
addr：传入参数(struct sockaddr *)&addr
addrlen：sizeof(addr)地址结构的大小。
返回值：
成功：0
失败：-1 errno
4. listen函数
int listen(int sockfd, int backlog);
设置同时与服务器建立连接的上限数(同时进行3次握手的客户端数量)
参数：
sockfd：socket的返回值
backlog：上限数值
返回值：
成功：0
失败：-1 error
5. accept函数
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
阻塞等待客户端建立连接，成功的话 返回一个与客户端成功连接的socket文件描述符。
参数：
sockfd：socket的返回值
addr：传出参数，成功与服务器建立连接的那个客户端的地址结构(IP+port)
addrlen： 传入传出参数，&clit_addr_len
入：addr的大小
出：客户端addr的实际大小
socklen_t clit_addr_len = sizeof(addr);
返回值：
成功：能与服务器进行数据通信的 socket 对应的文件描述符
失败：-1 error
6. connect函数
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
使用客户端现有的socket与服务器进行连接。
参数：
sockfd：socket的返回值
struct sockaddr_in serv_addr; //服务器地址结构
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(SERV_PORT);//和服务器bind时设定的port一致
inet_pton(AF_INET,"服务器的IP地址",&serv_addr.sin_addr.s_addr);addr：传入参数，服务器的地址结构
inet_pton()
addrlen：服务器地址结构的大小
返回值：
成功：0
失败：-1 error
如果不使用bind绑定客户端地址结构，采用"隐式绑定"
四、CS模型的TCP通信流程分析
server：
1. socket() 创建socket
2. bind() 绑定服务器地址结构
3. listen() 设置监听上限
4. accep() 阻塞监听客户端连接
5. read(fd) 读socket获取客户端数据
6.小写转换大写 toupper()
7. write(fd)
8. close();
client：
1. socket() 创建socket
2. connect(); 与服务器建立连接3. write() 写数据到socket
4. read() 读转换后的数据
5. 显示读取结果
6. close()
server的实现，server.c的作用是从客户端读字符，然后将每个字符转换为大写并回送给客户端
#include<stdio.h>
#include<stdlib.h>
#include<arpa/inet.h>
#include<ctype.h>
#include<sys/socket.h>
#include<unistd.h>
#include<string.h>
#include<errno.h>
#include<pthread.h>
#define SERV_PORT 9527
void sys_err(const char *str)
{
perror(str);
exit(1);
}
int main(int argc,char *argv[])
{
int lfd = 0,cfd = 0;
int ret;
char buf[BUFSIZ];//4096
struct sockaddr_in serv_addr,clit_addr;
socklen_t clit_addr_len;
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(SERV_PORT);
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
lfd = socket(AF_INET,SOCK_STREAM,0);
if (lfd == -1)
{
sys_err("socket errno");
}
ret = bind(lfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr));
if (ret == -1)
{
sys_err("bind error");
}
ret = listen(lfd,128);
if (ret == -1)
{
sys_err("listen error");
}
clit_addr_len = sizeof(clit_addr);
cfd = accept(lfd,(struct sockaddr *)&clit_addr,&clit_addr_len);
if (cfd == -1)
{
sys_err("accept error");
}
while(1)
{
ret = read(cfd,buf,sizeof(buf));
write(STDOUT_FILENO,buf,ret);
for (int i = 0;i<ret;i++)
{
buf[i] = toupper(buf[i]);
}
write(cfd,buf,ret);
}
close(lfd);
close(cfd);
return 0;
}
可以通过命令nc+ip地址+端口号进行连接，测试服务器，可以看到能够正常的小写转大写，输出如下所示：
client的实现，client.c的作用是从命令行参数中获得一个字符串发给服务器，然后接收服务器返回的字符串并打印
#include<stdio.h>
#include<stdlib.h>
#include<arpa/inet.h>
#include<ctype.h>
#include<sys/socket.h>
#include<unistd.h>
#include<string.h>
#include<errno.h>
#include<pthread.h>
#define SERV_PORT 9527
void sys_err(const char *str)
{
perror(str);
exit(1);
}
int main(int argc,char *argv[])
{
int cfd;
int counter = 10;
char buf[BUFSIZ];
struct sockaddr_in serv_addr;//服务器地址结构
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(SERV_PORT);
inet_pton(AF_INET,"192.168.88.129",&serv_addr.sin_addr.s_addr);
cfd = socket(AF_INET,SOCK_STREAM,0);
if (cfd == -1)
{
sys_err("socket error");
}
int ret = connect(cfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr));
if (ret == -1)
{
sys_err("connect error");
}
while(--counter)
{
write(cfd,"hello\n",6);
ret = read(cfd,buf,sizeof(buf));
write(STDOUT_FILENO,buf,ret);
sleep(1);
}
close(cfd);
return 0;
}
在server.c中加入以下代码打印ip及端口号：
printf("client ip is:%s port:%d\n",inet_ntop(AF_INET,&clit_addr.sin_addr.s_addr,client_IP,sizeof(client_IP)),ntohs(clit_addr.sin_port));两个终端分别执行服务端和客户端，输出如下所示：
五、错误函数封装
上面的例子不仅功能简单，而且简单到几乎没有什么错误处理，我们知道，系统调用不能保证每次都成功，必须进行出错处理，这样一方面可以保证程序逻辑正常，另一方面可以迅速得到故障信息。
为使错误处理的代码不影响主程序的可读性，我们把与socket相关的一些系统函数加上错误处理代码包装成新的函数，做成一个模块wrap.c：
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <sys/socket.h>
void perr_exit(const char *s)
{
perror(s);
exit(-1);
}
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr)
{
int n;
again:
if ((n = accept(fd, sa, salenptr)) < 0) {
if ((errno == ECONNABORTED) || (errno == EINTR))
goto again;
else
perr_exit("accept error");
}
return n;
}
int Bind(int fd, const struct sockaddr *sa, socklen_t salen)
{
int n;
if ((n = bind(fd, sa, salen)) < 0)
perr_exit("bind error");
return n;
}
int Connect(int fd, const struct sockaddr *sa, socklen_t salen)
{
int n;
if ((n = connect(fd, sa, salen)) < 0)
perr_exit("connect error");
return n;
}
int Listen(int fd, int backlog)
{
int n;
if ((n = listen(fd, backlog)) < 0)
perr_exit("listen error");
return n;
}
int Socket(int family, int type, int protocol)
{
int n;
if ((n = socket(family, type, protocol)) < 0)
perr_exit("socket error");
return n;
}
ssize_t Read(int fd, void *ptr, size_t nbytes)
{
ssize_t n;
again:
if ( (n = read(fd, ptr, nbytes)) == -1) {
if (errno == EINTR)
goto again;
else
return -1;
}
return n;
}
ssize_t Write(int fd, const void *ptr, size_t nbytes)
{
ssize_t n;
again:
if ( (n = write(fd, ptr, nbytes)) == -1) {
if (errno == EINTR)
goto again;
else
return -1;
}
return n;
}
int Close(int fd)
{
int n;
if ((n = close(fd)) == -1)
perr_exit("close error");
return n;
}
/*参三: 应该读取的字节数*/
ssize_t Readn(int fd, void *vptr, size_t n)
{
size_t nleft; //usigned int 剩余未读取的字节数
ssize_t nread; //int 实际读到的字节数
char *ptr;
ptr = vptr;
nleft = n;
while (nleft > 0) {
if ((nread = read(fd, ptr, nleft)) < 0) {
if (errno == EINTR)
nread = 0;
else
return -1;
} else if (nread == 0)
break;
nleft -= nread;
ptr += nread;
}
return n - nleft;
}
ssize_t Writen(int fd, const void *vptr, size_t n)
{
size_t nleft;
ssize_t nwritten;
const char *ptr;
ptr = vptr;
nleft = n;
while (nleft > 0) {
if ( (nwritten = write(fd, ptr, nleft)) <= 0) {
if (nwritten < 0 && errno == EINTR)
nwritten = 0;
else
return -1;
}
nleft -= nwritten;
ptr += nwritten;
}
return n;
}
static ssize_t my_read(int fd, char *ptr)
{
static int read_cnt;
static char *read_ptr;
static char read_buf[100];
if (read_cnt <= 0) {
again:
if ( (read_cnt = read(fd, read_buf, sizeof(read_buf))) < 0) {
if (errno == EINTR)
goto again;
return -1;
} else if (read_cnt == 0)
return 0;
read_ptr = read_buf;
}
read_cnt--;
*ptr = *read_ptr++;
return 1;
}
ssize_t Readline(int fd, void *vptr, size_t maxlen)
{
ssize_t n, rc;
char c, *ptr;
ptr = vptr;
for (n = 1; n < maxlen; n++) {
if ( (rc = my_read(fd, &c)) == 1) {
*ptr++ = c;
if (c == '\n')
break;
} else if (rc == 0) {
*ptr = 0;
return n - 1;
} else
return -1;
}
*ptr = 0;
return n;
}
wrap.h
#ifndef __WRAP_H_
#define __WRAP_H_
void perr_exit(const char *s);
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr);
int Bind(int fd, const struct sockaddr *sa, socklen_t salen);
int Connect(int fd, const struct sockaddr *sa, socklen_t salen);
int Listen(int fd, int backlog);
int Socket(int family, int type, int protocol);
ssize_t Read(int fd, void *ptr, size_t nbytes);
ssize_t Write(int fd, const void *ptr, size_t nbytes);
int Close(int fd);
ssize_t Readn(int fd, void *vptr, size_t n);
ssize_t Writen(int fd, const void *vptr, size_t n);
ssize_t my_read(int fd, char *ptr);
ssize_t Readline(int fd, void *vptr, size_t maxlen);
#endif
错误函数封装在多线程并发服务器实现中使用
