当前位置： 首页 > news >正文

8. 网络编程

news 2025/7/31 5:19:06

网络的基本概念

在这里插入图片描述

TCP/IP协议概述

在这里插入图片描述

OSI和TCP/IP模型

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

socket（套接字）

在这里插入图片描述

创建socket

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

字节序

在这里插入图片描述

字节序转换函数

在这里插入图片描述

通用地址结构

在这里插入图片描述

因特网地址结构

在这里插入图片描述

IPV4地址族和字符地址间的转换(点分十进制->网络字节序)

在这里插入图片描述

填写IPV4地址族结构案例

在这里插入图片描述

掌握TCP协议网络基础编程

在这里插入图片描述

在这里插入图片描述

相关函数

在这里插入图片描述
在这里插入图片描述

特殊bind地址

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

案例1:time

  • 先启动一个服务端，客户链接上来之后，服务端返回一个系统时间

  • time_tcp_server.c

#include <stdio.h>
#include<stdlib.h>
#include<netdb.h>
#include<sys/socket.h>
#include<unistd.h>
#include<string.h>
#include<memory.h>
#include<signal.h>
#include<time.h>int sockfd;void sig_handler(int signo)
{if(signo==SIGINT){printf("server close\n");/*步骤6：*  关闭socket* */close(sockfd);exit(1);}
}/*输出连接上来的客户端相关信息* */
void out_addr(struct sockaddr_in *clientaddr)
{// 将端口从网络字节序转换成主机字节序int port = ntohs(clientaddr->sin_port);char ip[16];memset(ip,0,sizeof(ip));// 网络字节序-> 点分十进制inet_ntop(AF_INET,&clientaddr->sin_addr.s_addr,ip,sizeof(ip));printf("client:%s(%d) connected \n",ip,port); 
}
void do_service(int fd)
{// 获得系统时间long t = time(0);char *s = ctime(&t);size_t size = strlen(s)*sizeof(char);// 将服务器端获得的系统时间写到客户端if(write(fd,s,size)!=size){perror("write  error");}
}
int main(int argc,char *argv[])
{// 参数：服务器端绑定的端口if(argc<2){printf("usage :%s #port\n",argv[0]);exit(0);}// 绑定一个信号，ctrl+c 终止服务端if(signal(SIGINT,sig_handler)==SIG_ERR){perror("signal sigint error");exit(1);}/* * 步骤1. 创建socket，套接字socket创建在内核,是一个结构体* AF_INET : IPV4* SOCK_STREAM:TCP协议*/sockfd = socket(AF_INET,SOCK_STREAM,0);/** 步骤2：调用bind函数将socket和地址（ip和port）进行绑定  * */// 专用地址，绑定的时候在强转为通用地址struct sockaddr_in serveraddr; memset(&serveraddr,0,sizeof(serveraddr));serveraddr.sin_family = AF_INET; // IPV4serveraddr.sin_port = htons(atoi(argv[1]));// 字符串-> 整型，主机字节序->网络字节序serveraddr.sin_addr.s_addr = INADDR_ANY;//响应所有请求if(bind(sockfd,(struct sockaddr*)&serveraddr,sizeof(serveraddr))<0){perror("bind error");exit(1);}/**步骤3：调用listen函数启动监听(指定port监听)通知系统去接受来自客户端的连接请求将接受到的客户端连接请求放置到对应的队列中第二个参数：10：队列的长度* */if(listen(sockfd,10)<0){perror("listen error");exit(1);}/**步骤4：调用accept函数，从队列中获得一个客户端的请求连接*  并返回一个新的socket描述符*注意:若没有客户端连接，调用此函数后会阻塞直到获得一个客户端的连接* */struct sockaddr_in clientaddr;socklen_t clientaddr_len = sizeof(clientaddr);while(1){// 第二个参数可以设置为NULL,如果不想知道客户端的信息的话int fd = accept(sockfd,(struct sockaddr*)&clientaddr,&clientaddr_len);if(fd<0){perror("accept error");continue;}/**步骤5：调用IO函数和客户端进行双向的通信*/out_addr(&clientaddr);do_service(fd);/*步骤5：*  关闭 socket* */ 
![在这里插入图片描述](https://i-blog.csdnimg.cn/direct/d5dcdb3be95a4bbdb7566cb9994daf40.png)
![在这里插入图片描述](https://i-blog.csdnimg.cn/direct/24b23c1c7771411493b1380af83b23af.png)
![在这里插入图片描述](https://i-blog.csdnimg.cn/direct/910db7d627b54bada7cd3b98047f0cf8.png)- time_tcp_client.c```c
#include<stdio.h>
#include<stdlib.h>
#include<netdb.h>
#include<sys/socket.h>
#include<unistd.h>
#include<string.h>
#include<memory.h>
#include<signal.h>
#include<time.h>int main(int argc,char *argv[])
{// 参数：服务器端绑定的端口if(argc<2){printf("usage :%s #port\n",argv[0]);exit(0);}/* * 步骤1. 创建socket，套接字socket创建在内核,是一个结构体* AF_INET : IPV4* SOCK_STREAM:TCP协议*/int  sockfd = socket(AF_INET,SOCK_STREAM,0);if(sockfd<0){perror("sockek error");exit(1);}/** 步骤2：创建socket* */struct sockaddr_in serveraddr; memset(&serveraddr,0,sizeof(serveraddr));serveraddr.sin_family = AF_INET; // IPV4serveraddr.sin_port = htons(atoi(argv[2]));// 字符串-> 整型，主机字节序->网络字节序inet_pton(AF_INET,argv[1],&serveraddr.sin_addr.s_addr);if(connect(sockfd,(struct sockaddr*)&serveraddr,sizeof(serveraddr))<0){perror("connect error");exit(1);}// 步骤3：调用IO函数，和服务器进行双向通讯char buffer[1024];memset(buffer,0,sizeof(buffer));size_t size;if((size=read(sockfd,buffer,sizeof(buffer)))<0){perror("read error");}if(write(STDOUT_FILENO,buffer,size)!=size){perror("write error");}// 步骤4：关闭socketclose(sockfd);return 0;
}

在这里插入图片描述

自定义协议

在这里插入图片描述

  • msg.h
#ifndef __MSG_H__
#define __MSG_H__
#include<sys/types.h>
typedef struct{// 协议头部char head[10];// 验证码char checknum;//协议体部char buff[512] ;//数据
}MSG;
/** 发送一个基于自定义协议的message，发送的数据存放在buff中* */
extern int write_msg(int sockfd,char *buff,size_t len);
/*读取一个基于自定义协议的message。读取的数据存放在buff中* */
extern int read_msg(int sockfd,char *buff,size_t len);#endif
  • msg.c
#include<unistd.h>
#include<string.h>
#include<memory.h>
#include<sys/types.h>
#include"msg.h"// 计算校验码
static unsigned  char msg_check(Msg *message)
{unsigned char s = 0;for(int i=0;i<sizeof(message->head);i++){s+=message->head[i];}for(int i=0;i<sizeof(message->buff);i++){s+=message->buff[i];}return s;
}/** 发送一个基于自定义协议的message，发送的数据存放在buff中* */int write_msg(int sockfd,char *buff,size_t len)
{Msg message;memset(&message,0,sizeof(message));strcpy(message.head,"iotek2025");memcpy(message.buff,buff,len);message.checknum = msg_check(&message);if(write(sockfd,&message,sizeof(message))!=sizeof(message)){return -1;}
}/*读取一个基于自定义协议的message。读取的数据存放在buff中* */
int read_msg(int sockfd,char *buff,size_t len)
{Msg message;memset(&message,0,sizeof(message));size_t size;if((size=read(sockfd,&message,sizeof(message)))<0){return -1;}else if(size==0){return 0;}// j进行校验码的验证unsigned char s =msg_check(&message);if((s==(unsigned char)message.checknum) && (!strcmp("iotek2025",message.head))){memcpy(buff,message.buff,len);return sizeof(message);}return -1;
}
  • 在服务端的do_service中增加
void do_service(int fd)
{
//----------------------------------------size_t len;char buff[20];if((len=read(fd,buff,20))<0) // 注意由于客户端没有给服务端写数据，所以会在此阻塞{perror("do_service server read error");}//----------------------------------------// 获得系统时间long t = time(0);char *s = ctime(&t);size_t size = strlen(s)*sizeof(char);// 将服务器端获得的系统时间写到客户端if(write(fd,s,size)!=size){perror("write  error");}
}

在这里插入图片描述
在这里插入图片描述

服务器并发性处理

多进程模型

  • echo_tcp_server
#include<stdio.h>
#include<stdlib.h>
#include<netdb.h>
#include<sys/socket.h>
#include<unistd.h>
#include<string.h>
#include<memory.h>
#include<signal.h>
#include<time.h>
#include<errno.h>
#include"msg.h"
int sockfd;void sig_handler(int signo)
{if(signo==SIGINT){printf("server close\n");/*步骤6：*  关闭socket* */close(sockfd);exit(1);}if(signo==SIGCHLD){printf("child process dead.....\n");wait(0);}
}/*输出连接上来的客户端相关信息* */
void out_addr(struct sockaddr_in *clientaddr)
{// 将端口从网络字节序转换成主机字节序int port = ntohs(clientaddr->sin_port);char ip[16];memset(ip,0,sizeof(ip));// 网络字节序-> 点分十进制inet_ntop(AF_INET,&clientaddr->sin_addr.s_addr,ip,sizeof(ip));printf("client:%s(%d) connected \n",ip,port); 
}
void do_service(int fd)
{// 和客户端进行读写操作(双向通信)char buff[512];while(1){memset(buff,0,sizeof(buff));printf("start read and write....\n");size_t size;if((size=read_msg(fd,buff,sizeof(buff)))<0){perror("protocal error");break;}else if(size==0){break; // 写端突然挂了}else{printf("%s\n",buff);if(write_msg(fd,buff,sizeof(buff))<0){if(errno==EPIPE)// 读端突然关闭时，类似于管道通信{break;}perror("protocal error");}}}
}
int main(int argc,char *argv[])
{// 参数：服务器端绑定的端口if(argc<2){printf("usage :%s #port\n",argv[0]);exit(0);}// 绑定一个信号，ctrl+c 终止服务端if(signal(SIGINT,sig_handler)==SIG_ERR){perror("signal sigint error");exit(1);}if(signal(SIGCHLD,sig_handler)==SIG_ERR)// 等子进程终止发送的信号{perror("signal sigchild error");exit(1);}/* * 步骤1. 创建socket，套接字socket创建在内核,是一个结构体* AF_INET : IPV4* SOCK_STREAM:TCP协议*/sockfd = socket(AF_INET,SOCK_STREAM,0);if(sockfd<0){perror("sockek error");exit(1);}/** 步骤2：调用bind函数将socket和地址（ip和port）进行绑定  * */// 专用地址，绑定的时候在强转为通用地址struct sockaddr_in serveraddr; memset(&serveraddr,0,sizeof(serveraddr));serveraddr.sin_family = AF_INET; // IPV4serveraddr.sin_port = htons(atoi(argv[1]));// 字符串-> 整型，主机字节序->网络字节序serveraddr.sin_addr.s_addr = INADDR_ANY;//响应所有请求if(bind(sockfd,(struct sockaddr*)&serveraddr,sizeof(serveraddr))<0){perror("bind error");exit(1);}/**步骤3：调用listen函数启动监听(指定port监听)通知系统去接受来自客户端的连接请求将接受到的客户端连接请求放置到对应的队列中第二个参数：10：队列的长度* */if(listen(sockfd,10)<0){perror("listen error");exit(1);}/**步骤4：调用accept函数，从队列中获得一个客户端的请求连接*  并返回一个新的socket描述符*注意:若没有客户端连接，调用此函数后会阻塞直到获得一个客户端的连接* */struct sockaddr_in clientaddr;socklen_t clientaddr_len = sizeof(clientaddr);while(1){// 第二个参数可以设置为NULL,如果不想知道客户端的信息的话int fd = accept(sockfd,(struct sockaddr*)&clientaddr,&clientaddr_len);if(fd<0){perror("accept error");continue;}/**步骤5：启动子进程调用IO函数   */pid_t pid = fork();if(pid<0){continue;}else if(pid==0){out_addr(&clientaddr);do_service(fd);/*步骤6:*  关闭 socket* */close(fd); /// 子进程会复制父进程的fd}else{close(fd); }}return 0;
}
  • echo_tcp_client.c

#include<stdio.h>
#include<stdlib.h>
#include<netdb.h>
#include<sys/socket.h>
#include<unistd.h>
#include<string.h>
#include<memory.h>
#include<signal.h>
#include<time.h>
#include<errno.h>
#include"msg.h"int main(int argc,char *argv[])
{// 参数：服务器端绑定的端口if(argc<2){printf("usage :%s #port\n",argv[0]);exit(0);}/* * 步骤1. 创建socket，套接字socket创建在内核,是一个结构体* AF_INET : IPV4* SOCK_STREAM:TCP协议*/int  sockfd = socket(AF_INET,SOCK_STREAM,0);if(sockfd<0){perror("sockek error");exit(1);}/** 步骤2：创建socket* */struct sockaddr_in serveraddr; memset(&serveraddr,0,sizeof(serveraddr));serveraddr.sin_family = AF_INET; // IPV4serveraddr.sin_port = htons(atoi(argv[2]));// 字符串-> 整型，主机字节序->网络字节序inet_pton(AF_INET,argv[1],&serveraddr.sin_addr.s_addr);if(connect(sockfd,(struct sockaddr*)&serveraddr,sizeof(serveraddr))<0){perror("connect error");exit(1);}// 步骤3：调用IO函数，和服务器进行双向通讯char buff[512];size_t size;char * prompt = ">" ;while(1){memset(buff,0,sizeof(buff));write(STDOUT_FILENO,prompt,1);size = read(STDIN_FILENO,buff,sizeof(buff));if(size<0) {continue;}buff[size-1] = '\0';if(write_msg(sockfd,buff,sizeof(buff))<0){perror("write msg error");continue;}else{if(read_msg(sockfd,buff,sizeof(buff))<0){perror("read msg error");continue;}else{printf("%s\n",buff);}}}// 步骤4：关闭socketclose(sockfd);return 0;
}

在这里插入图片描述

  • 下面这个没有出现
    在这里插入图片描述

多线程模型

  • ehco_tcp_server_th.c
#include<stdio.h>
#include<stdlib.h>
#include<netdb.h>
#include<sys/socket.h>
#include<unistd.h>
#include<string.h>
#include<memory.h>
#include<signal.h>
#include<time.h>
#include<errno.h>
#include<sys/types.h>
#include<sys/wait.h>
#include<pthread.h>
#include"msg.h"int sockfd;void sig_handler(int signo)
{if(signo==SIGINT){printf("server close\n");/*步骤6：*  关闭socket* */close(sockfd);exit(1);}
}void do_service(int fd)
{// 和客户端进行读写操作(双向通信)char buff[512];while(1){memset(buff,0,sizeof(buff));printf("start read and write....\n");size_t size;if((size=read_msg(fd,buff,sizeof(buff)))<0){perror("protocal error");break;}else if(size==0){break; // 写端突然挂了}else{printf("%s\n",buff);if(write_msg(fd,buff,sizeof(buff))<0){if(errno==EPIPE)// 读端突然关闭时，类似于管道通信{break;}perror("protocal error");}}}
}void out_fd(int fd)
{struct sockaddr_in addr;socklen_t len = sizeof(addr);// 从fd中获得连接的客户端的相关信息if(getpeername(fd,(struct sockaddr*)&addr,&len)<0){perror("getpeername error");return;}char ip[16];memset(ip,0,sizeof(ip));int port = ntohs(addr.sin_port);inet_ntop(AF_INET,&addr.sin_addr.s_addr,ip,sizeof(ip));printf("%16s(%5d) closed\n",ip,port);
}void * th_fn(void *arg)
{int fd = (int)arg;do_service(fd);out_fd(fd);// 输出客户端的信息close(fd);return (void*)0;
}int main(int argc,char *argv[])
{// 参数：服务器端绑定的端口if(argc<2){printf("usage :%s #port\n",argv[0]);exit(0);}// 绑定一个信号，ctrl+c 终止服务端if(signal(SIGINT,sig_handler)==SIG_ERR){perror("signal sigint error");exit(1);}/* * 步骤1. 创建socket，套接字socket创建在内核,是一个结构体* AF_INET : IPV4* SOCK_STREAM:TCP协议*/sockfd = socket(AF_INET,SOCK_STREAM,0);if(sockfd<0){perror("sockek error");exit(1);}/** 步骤2：调用bind函数将socket和地址（ip和port）进行绑定  * */// 专用地址，绑定的时候在强转为通用地址struct sockaddr_in serveraddr; memset(&serveraddr,0,sizeof(serveraddr));serveraddr.sin_family = AF_INET; // IPV4serveraddr.sin_port = htons(atoi(argv[1]));// 字符串-> 整型，主机字节序->网络字节序serveraddr.sin_addr.s_addr = INADDR_ANY;//响应所有请求if(bind(sockfd,(struct sockaddr*)&serveraddr,sizeof(serveraddr))<0){perror("bind error");exit(1);}/**步骤3：调用listen函数启动监听(指定port监听)通知系统去接受来自客户端的连接请求将接受到的客户端连接请求放置到对应的队列中第二个参数：10：队列的长度* */if(listen(sockfd,10)<0){perror("listen error");exit(1);}/**步骤4：调用accept函数，从队列中获得一个客户端的请求连接*  并返回一个新的socket描述符*注意:若没有客户端连接，调用此函数后会阻塞直到获得一个客户端的连接* */struct sockaddr_in clientaddr;socklen_t clientaddr_len = sizeof(clientaddr);// 设置线程的分离属性pthread_attr_t attr;pthread_attr_init(&attr);pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);while(1){// 第二个参数可以设置为NULL,如果不想知道客户端的信息的话// 主控线程负责调用accept去获得客户端的连接 int fd = accept(sockfd,NULL,NULL);if(fd<0){perror("accept error");continue;}/**步骤5：启动子线程调用IO函数   */pthread_t th;int err;// 以分离状态启动子线程if((err=pthread_create(&th,&attr,th_fn,(void*)fd))!=0){perror("pthread create error");}pthread_attr_destroy(&attr);}return 0;
}

在这里插入图片描述

I/O多路转换(select)

掌握UDP协议网络基础编程

在这里插入图片描述

发生数据

在这里插入图片描述

接收数据

在这里插入图片描述

  • time_udp_server
#include <stdio.h>
#include<sys/socket.h>
#include<unistd.h>
#include<string.h>
#include<stdlib.h>
#include<signal.h>
#include<time.h>
#include<netdb.h>int sockfd;void sig_handler(int signo)
{if(signo==SIGINT){printf("server close\n");close(sockfd);exit(1);}}// 输出客户端的信息
void out_addr(struct sockaddr_in *clientaddr)
{char ip[16];memset(ip,0,sizeof(ip));inet_ntop(AF_INET,&clientaddr->sin_addr.s_addr,ip,sizeof(ip));int port = ntohs(clientaddr->sin_port);printf("client : %s(%d)\n",ip,port);
}// 和客户端进行通信
void do_service()
{struct sockaddr_in clientaddr;socklen_t len = sizeof(clientaddr);char buffer[1024];memset(buffer,0,sizeof(buffer));// 接受客户端的数据报文if(recvfrom(sockfd,buffer,sizeof(buffer),0,(struct sockaddr*)&clientaddr,&len)<0){perror("recvfrom error");}else{out_addr(&clientaddr);printf("client send into : %s\n",buffer);//向客户端发送数据报文long int t = time(0);char * ptr = ctime(&t);size_t size = strlen(ptr)*sizeof(char);if(sendto(sockfd,ptr,size,0,(struct sockaddr*)&clientaddr,len)<0){perror("sendto error");}}}
int main(int argc,char *argv[])
{if(argc<0){printf("usage : %s port \n",argv[0]);exit(1);}if(signal(SIGINT,sig_handler)==SIG_ERR){perror("signal sigint error");exit(1);}/*步骤1：** */sockfd = socket(AF_INET,SOCK_DGRAM,0);if(sockfd<0){perror("sockfd error");exit(1);}int res;int opt = 1;// 设置套接字选项:让刚才实现的端口立即启动if((res=setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt)))<0){perror("setsockopt error");exit(1);}/*步骤2:调用bind函数对socket和地址进行绑定* */struct sockaddr_in serveraddr;memset(&serveraddr,0,sizeof(serveraddr));serveraddr.sin_family =  AF_INET; // IPV4serveraddr.sin_port = htons(atoi(argv[1])); // portserveraddr.sin_addr.s_addr = INADDR_ANY; //ipif(bind(sockfd,(struct sockaddr*)&serveraddr,sizeof(serveraddr))<0){perror("bind error");exit(1);}/*步骤3：和客户端进行双向的数据通信* */while(1){do_service();}return 0;
}
  • time_udp_client
   #include <stdio.h>
#include<stdlib.h>
#include<string.h>
#include<netdb.h>
#include<sys/socket.h>
#include<memory.h>
#include<unistd.h>int main(int argc,char *argv[])
{if(argc<3){printf("usgae : %s ip port \n",argv[0]);exit(1);}/*步骤1：创建socket* */int sockfd = socket(AF_INET,SOCK_DGRAM,0);if(sockfd<0){perror("socket error");exit(1);}/*步骤2：调用recvfrom和sendto等函数* 和服务器进行双向通信* */struct sockaddr_in serveraddr;memset(&serveraddr,0,sizeof(serveraddr));serveraddr.sin_family = AF_INET;serveraddr.sin_port = htons(atoi(argv[2]));inet_pton(AF_INET,argv[1],&serveraddr.sin_addr.s_addr); //ipchar buffer[1024] = "hello iotek";// 向服务器端发送数据报文if(sendto(sockfd,buffer,sizeof(buffer),0,(struct sockaddr*)&serveraddr,sizeof(serveraddr))<0){perror("sendto error");exit(1);}else{//接受服务器发送的报文memset(buffer,0,sizeof(buffer));if(recv(sockfd,buffer,sizeof(buffer),0)<0){perror("recv error");exit(1);}else{printf("%s",buffer);}close(sockfd);}return 0;
}

在这里插入图片描述

  • 在客户端可以使用connect进行连接
    在这里插入图片描述

这里的connect并没有和服务端进行三次握手，只是在内核中记录了服务端的地址信息和端口，所以可以直接使用send不用指出服务端的地址等信息了。而且调用connect可以保证只是接受来自服务端发送的数据，不接受其他的信息

  • 多次绑定同一个端口
    在这里插入图片描述

在这里插入图片描述在这里插入图片描述
第二个端口起作用
在这里插入图片描述

域名

在这里插入图片描述

  • gethostent获取所有
    在这里插入图片描述
  • gethostbuname获取某一个
    在这里插入图片描述
    在这里插入图片描述

在这里插入图片描述

  • 在Linux中的，位于/etc/hosts
    在这里插入图片描述
    在这里插入图片描述

  • gethost.c

#include <stdio.h>
#include<netdb.h>
#include<stdlib.h>
#include<memory.h>void out_addr(struct hostent *h)
{printf("hostbyname: %s\n",h->h_name);printf("addrtype: %s\n",h->h_addrtype==AF_INET ? "IPV4" : "IPV6");char ip[16];memset(ip,0,sizeof(ip));inet_ntop(h->h_addrtype,h->h_addr_list[0],ip,sizeof(ip));printf("ip addrress : %s\n",ip);int i = 0;while(h->h_aliases[i] != NULL){printf("alias : %s \n",h->h_aliases[i]);i++;}
}int main(int argc,char *argv[])
{if(argc<2){printf("usage  %s host \n",argv[0]);exit(1);}struct  hostent *h;h = gethostbyname(argv[1]);if(h!=NULL){out_addr(h);}else{printf("no %s exits\n",argv[1]);}return 0;endhostent();
}

在这里插入图片描述

注意gethostbyname应该避免在多线程下使用。

  • 使用gethostent

#include <stdio.h>
#include<netdb.h>
#include<stdlib.h>
#include<memory.h>void out_addr(struct hostent *h)
{printf("hostbyname: %s\n",h->h_name);printf("addrtype: %s\n",h->h_addrtype==AF_INET ? "IPV4" : "IPV6");char ip[16];memset(ip,0,sizeof(ip));inet_ntop(h->h_addrtype,h->h_addr_list[0],ip,sizeof(ip));printf("ip addrress : %s\n",ip);int i = 0;while(h->h_aliases[i] != NULL){printf("alias : %s \n",h->h_aliases[i]);i++;}
}int main(int argc,char *argv[])
{if(argc<2){printf("usage  %s host \n",argv[0]);exit(1);}struct  hostent *h;while((h=gethostent()) != NULL){if(!strcmp(argv[1],h->h_name)){out_addr(h);exit(0);}else{int i = 0;while(h->h_aliases[i] != NULL){if(!strcmp(argv[1],h->h_aliases[i])){out_addr(h);exit(0);}i++;}}}endhostent();return 0;
}
#include <stdio.h>
#include<stdlib.h>
#include<string.h>
#include<netdb.h>
#include<sys/socket.h>
#include<memory.h>
#include<unistd.h>int  is_host(struct hostent *host,char *name)
{if(!strcmp(host->h_name,name))return 1;int i =0;while(host->h_aliases[i] != NULL){if(!strcmp(host->h_aliases[i],name))return 1;i++;}       
}
unsigned int get_ip_by_name(char *name)
{unsigned int ip = 0;struct hostent *host;while((host = gethostent())!=NULL){if(is_host(host,name)){memcpy(&ip,host->h_addr_list[0],4);break;}}endhostent();return ip;
}int main(int argc,char *argv[])
{if(argc<3){printf("usgae : %s ip port \n",argv[0]);exit(1);}/*步骤1：创建socket* */int sockfd = socket(AF_INET,SOCK_DGRAM,0);if(sockfd<0){perror("socket error");exit(1);}/*步骤2：调用recvfrom和sendto等函数* 和服务器进行双向通信* */struct sockaddr_in serveraddr;memset(&serveraddr,0,sizeof(serveraddr));serveraddr.sin_family = AF_INET;serveraddr.sin_port = htons(atoi(argv[2]));unsigned int ip = get_ip_by_name(argv[1]);if(ip!=0){serveraddr.sin_addr.s_addr = ip;}else{inet_pton(AF_INET,argv[1],&serveraddr.sin_addr.s_addr);}//inet_pton(AF_INET,argv[1],&serveraddr.sin_addr.s_addr); //ipchar buffer[1024] = "hello iotek";// 向服务器端发送数据报文if(sendto(sockfd,buffer,sizeof(buffer),0,(struct sockaddr*)&serveraddr,sizeof(serveraddr))<0){perror("sendto error");exit(1);}else{//接受服务器发送的报文memset(buffer,0,sizeof(buffer));if(recv(sockfd,buffer,sizeof(buffer),0)<0){perror("recv error");exit(1);}else{printf("%s",buffer);}close(sockfd);}return 0;
}

在这里插入图片描述

网络高级编程

广播

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

套接字选项

在这里插入图片描述在这里插入图片描述

TCP不支持广播，只有UDP才能支持广播

缓存区

在这里插入图片描述

  • receiver.c
#include <stdio.h>
#include<netdb.h>
#include<sys/socket.h>
#include<string.h>
#include<signal.h>
#include<stdlib.h>int sockfd;void sig_handler(int signo)
{if(signo == SIGINT){printf("receiver will exited");close(sockfd);exit(1);}
}int main(int argc,char *argv[])
{if(argc<2){fprintf(stderr,"usage : %s port \n",argv[0]);exit(1);}if(signal(SIGINT,sig_handler)==SIG_ERR){perror("signal sigint errro");exit(1);}sockfd = socket(AF_INET,SOCK_DGRAM,0);if(sockfd<0){perror("socket error");exit(1);}struct sockaddr_in serveraddr;memset(&serveraddr,0,sizeof(serveraddr));serveraddr.sin_family = AF_INET;serveraddr.sin_port = htons(atoi(argv[1]));serveraddr.sin_addr.s_addr = INADDR_ANY;if(bind(sockfd,(struct sockadd*)&serveraddr,sizeof(serveraddr))<0){perror("bind error");exit(1);}char buffer[1024];struct sockaddr_in  clientaddr;socklen_t len  = sizeof(clientaddr);while(1){memset(buffer,0,sizeof(buffer));memset(&clientaddr,0,sizeof(clientaddr));if(recvfrom(sockfd,buffer,sizeof(buffer),0,(struct sockaddr*)&clientaddr,&len)<0){perror("recvfrom error");exit(1);}else{char ip[16];inet_ntop(AF_INET,&clientaddr.sin_addr.s_addr,ip,sizeof(ip));int port = ntohs(clientaddr.sin_port); printf("%s{%d}:%s\n",ip,port,buffer);}}return 0;
}
  • broadcast.c
#include <stdio.h>
#include<stdlib.h>
#include<string.h>
#include<netdb.h>
#include<sys/socket.h>int main(int argc,char * argv[])
{if(argc<3){fprintf(stderr,"usage: %s ip port\n",argv[0]);exit(1);}int sockfd = socket(AF_INET,SOCK_DGRAM,0);if(sockfd<0){perror("sockdt error");exit(1);}int opt = 1;// 采用广播地址发送setsockopt(sockfd,SOL_SOCKET,SO_BROADCAST,&opt,sizeof(opt));struct sockaddr_in serveraddr;memset(&serveraddr,0,sizeof(serveraddr));serveraddr.sin_family =  AF_INET;serveraddr.sin_port  = htons(atoi(argv[2]));inet_pton(AF_INET,argv[1],&serveraddr.sin_addr.s_addr);printf("I will broadcast....\n");char *info = "helo yangpipi...";size_t size = strlen(info)*sizeof(char);if(sendto(sockfd,info,size,0,(struct sockaddr*)&serveraddr,sizeof(serveraddr))<0){perror("sendto error");exit(1);}else{printf("boradcast success\n");}close(sockfd);return 0;

在这里插入图片描述

多路复用之fcntl

在这里插入图片描述
在这里插入图片描述

  • server.c

#include<stdio.h>
#include<stdlib.h>
#include<netdb.h>
#include<sys/socket.h>
#include<unistd.h>
#include<string.h>
#include<memory.h>
#include<signal.h>
#include<time.h>
#include<errno.h>
#include<sys/types.h>
#include<sys/wait.h>
#include<pthread.h>
#include<fcntl.h>
#include"vector_fd.h"VectorFD *vfd;
int sockfd;void sig_handler(int signo)
{if(signo==SIGINT){printf("server close----\n");/*步骤6：*  关闭socket* */close(sockfd);// 销毁动态数组destroy_vector_fd(vfd);exit(1);}
}/**fd对应于某个连接的客户端，和某个连接的客户端进行双向通信（非阻塞方式）* */
void do_service(int fd)
{// 和客户端进行读写操作(双向通信)char buff[512];while(1){memset(buff,0,sizeof(buff));// 以非阻塞方式读，读不到数据就返回了，直接服务于下一个客户端，因此不需要判断size<0的情况size_t size=read(fd,buff,sizeof(buff));if(size==0){char info[] = "client closed";write(STDOUT_FILENO,info,sizeof(info));// 从动态数组中删除对应的fdremove_fd(vfd,fd);// 关闭对应的客户端的socketclose(fd);}else if(size > 0){write(STDOUT_FILENO,buff,sizeof(buff));if(write(fd,buff,size)<size){if(errno==EPIPE)// 客户端关闭连接{perror("write error");remove_fd(vfd,fd);close(fd);}}}}
}void * th_fn(void *arg)
{int i;while(1){// 遍历动态数中的socket描述符for(int i = 0;i<vfd->counter;i++){do_service(get_fd(vfd,i));}}return (void*)0;
}void out_addr(struct sockaddr_in *clientaddr)
{char ip[16];memset(ip,0,sizeof(ip));int port = ntohs(clientaddr->sin_port);inet_ntop(AF_INET,&clientaddr->sin_addr.s_addr,ip,sizeof(ip));printf("%s(%d) connected!\n",ip,port);
}
int main(int argc,char *argv[])
{// 参数：服务器端绑定的端口if(argc<2){printf("usage :%s #port\n",argv[0]);exit(0);}// 绑定一个信号，ctrl+c 终止服务端if(signal(SIGINT,sig_handler)==SIG_ERR){perror("signal sigint error");exit(1);}/* * 步骤1. 创建socket，套接字socket创建在内核,是一个结构体* AF_INET : IPV4* SOCK_STREAM:TCP协议*/sockfd = socket(AF_INET,SOCK_STREAM,0);if(sockfd<0){perror("sockek error");exit(1);}/** 步骤2：调用bind函数将socket和地址（ip和port）进行绑定  * */// 专用地址，绑定的时候在强转为通用地址struct sockaddr_in serveraddr; memset(&serveraddr,0,sizeof(serveraddr));serveraddr.sin_family = AF_INET; // IPV4serveraddr.sin_port = htons(atoi(argv[1]));// 字符串-> 整型，主机字节序->网络字节序serveraddr.sin_addr.s_addr = INADDR_ANY;//响应所有请求if(bind(sockfd,(struct sockaddr*)&serveraddr,sizeof(serveraddr))<0){perror("bind error");exit(1);}/**步骤3：调用listen函数启动监听(指定port监听)通知系统去接受来自客户端的连接请求将接受到的客户端连接请求放置到对应的队列中第二个参数：10：队列的长度* */if(listen(sockfd,10)<0){perror("listen error");exit(1);}/**步骤4：调用accept函数，从队列中获得一个客户端的请求连接*  并返回一个新的socket描述符*注意:若没有客户端连接，调用此函数后会阻塞直到获得一个客户端的连接* */// 创建放置套接字描述符fd的动态数组vfd = create_vector_fd();// 设置线程的分离属性pthread_attr_t attr;pthread_attr_init(&attr);pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);int err;pthread_t th; if((err=pthread_create(&th,&attr,th_fn,(void*)0))!=0){perror("pthread create error");exit(1);}pthread_attr_destroy(&attr);/** 1) 主控线程获得客户端的连接，将新的socket描述符放置到动态数组中* 2) 启动的子线程负责遍历动态数组中socket描述符并和对应的客户端进行双向通信(采用非阻塞方式读写)** */struct sockaddr_in clientaddr;socklen_t clientaddr_len = sizeof(clientaddr);while(1){int fd = accept(sockfd,(struct sockaddr*)&clientaddr,&clientaddr_len);if(fd<0){perror("accept error");continue;}out_addr(&clientaddr);// 将读写方式修改为非阻塞方式int val;fcntl(fd,F_GETFL,&val);val |= O_NONBLOCK;fcntl(fd,F_SETFL,val);        // 将返回新的socket描述符加入到动态数组中add_fd(vfd,fd);}return 0;
  • client.c
#include<stdio.h>
#include<stdlib.h>
#include<netdb.h>
#include<sys/socket.h>
#include<unistd.h>
#include<string.h>
#include<memory.h>
#include<signal.h>
#include<time.h>
#include<errno.h>int main(int argc,char *argv[])
{// 参数：服务器端绑定的端口if(argc<2){printf("usage :%s #port\n",argv[0]);exit(0);}/* * 步骤1. 创建socket，套接字socket创建在内核,是一个结构体* AF_INET : IPV4* SOCK_STREAM:TCP协议*/int  sockfd = socket(AF_INET,SOCK_STREAM,0);if(sockfd<0){perror("sockek error");exit(1);}/** 步骤2：创建socket* */struct sockaddr_in serveraddr; memset(&serveraddr,0,sizeof(serveraddr));serveraddr.sin_family = AF_INET; // IPV4serveraddr.sin_port = htons(atoi(argv[2]));// 字符串-> 整型，主机字节序->网络字节序inet_pton(AF_INET,argv[1],&serveraddr.sin_addr.s_addr);if(connect(sockfd,(struct sockaddr*)&serveraddr,sizeof(serveraddr))<0){perror("connect error");exit(1);}// 步骤3：调用IO函数，和服务器进行双向通讯char buff[512];size_t size;char * prompt = ">" ;while(1){memset(buff,0,sizeof(buff));write(STDOUT_FILENO,prompt,1);size = read(STDIN_FILENO,buff,sizeof(buff));if(size<0) {continue;}buff[size-1] = '\0';if(write(sockfd,buff,sizeof(buff))<0){perror("write msg error");continue;}else{if(read(sockfd,buff,sizeof(buff))<0){perror("read msg error");continue;}else{printf("%s\n",buff);}}}// 步骤4：关闭socketclose(sockfd);return 0;
}

在这里插入图片描述

多路复用之select

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

  • echo_tcp_sever_select.c
#include<stdio.h>
#include<stdlib.h>
#include<netdb.h>
#include<sys/socket.h>
#include<unistd.h>
#include<string.h>
#include<memory.h>
#include<signal.h>
#include<time.h>
#include<errno.h>
#include<sys/types.h>
#include<sys/wait.h>
#include<pthread.h>
#include<fcntl.h>
#include"vector_fd.h"VectorFD *vfd;
int sockfd;void sig_handler(int signo)
{if(signo==SIGINT){printf("server close----\n");/*步骤6：*  关闭socket* */close(sockfd);// 销毁动态数组destroy_vector_fd(vfd);exit(1);}
}/**fd对应于某个连接的客户端，和某个连接的客户端进行双向通信（非阻塞方式）* */
void do_service(int fd)
{// 和客户端进行读写操作(双向通信)char buff[512];while(1){memset(buff,0,sizeof(buff));// 以非阻塞方式读，读不到数据就返回了，直接服务于下一个客户端，因此不需要判断size<0的情况size_t size=read(fd,buff,sizeof(buff));if(size==0){//char info[] = "client closed";//write(STDOUT_FILENO,info,sizeof(info));printf("client closed\n"); // 这里由于内核设置，所以可以使用带缓存的IO// 从动态数组中删除对应的fdremove_fd(vfd,fd);// 关闭对应的客户端的socketclose(fd);}else if(size > 0){//write(STDOUT_FILENO,buff,sizeof(buff));printf("%s\n",buff);if(write(fd,buff,size)<size){if(errno==EPIPE)// 客户端关闭连接{perror("write error");remove_fd(vfd,fd);close(fd);}}}}
}/*遍历出动态数组中所有的描述符并加入到描述符集set中* 同时此函数返回动态数组中最大的那个描述符* */
int add_set(fd_set *set)
{FD_ZERO(set); // 清空描述符int max_fd = vfd->fd[0];for(int i = 0;i < vfd->fd[0];i++){int fd = get_fd(vfd,i);if(fd>max_fd){max_fd = fd;}FD_SET(fd,set);//将fd加入到描述符集中}return max_fd;
}
void * th_fn(void *arg)
{struct timeval t;t.tv_sec = 2;t.tv_usec = 0;int n = 0;int maxfd;fd_set set; // 描述符集maxfd = add_set(&set);/*调用select函数会阻塞，委托内核去检查传入的描述符是否准备好，* 如有则返回准备好的描述符，* 超时则返回0* 第一个参数为描述符集中描述符的范围(最大描述符+1)* */while((n=select(maxfd+1,&set,NULL,NULL,&t))>=0){if(n>0){/*检测那些描述符准备好，并和这些准备好的描述符对应的客户端进行数据的双向通信* */for(int i=0;i<vfd->counter;i++){int fd = get_fd(vfd,i);if(FD_ISSET(fd,&set)){do_service(fd);}}}//超时// 重新设置时间和清空描述符集t.tv_sec = 2;t.tv_usec = 0;// 重新遍历动态数组中最新的描述符放置到描述符集中maxfd = add_set(&set);}
}void out_addr(struct sockaddr_in *clientaddr)
{char ip[16];memset(ip,0,sizeof(ip));int port = ntohs(clientaddr->sin_port);inet_ntop(AF_INET,&clientaddr->sin_addr.s_addr,ip,sizeof(ip));printf("%s(%d) connected!\n",ip,port);
}
int main(int argc,char *argv[])
{// 参数：服务器端绑定的端口if(argc<2){printf("usage :%s #port\n",argv[0]);exit(0);}// 绑定一个信号，ctrl+c 终止服务端if(signal(SIGINT,sig_handler)==SIG_ERR){perror("signal sigint error");exit(1);}/* * 步骤1. 创建socket，套接字socket创建在内核,是一个结构体* AF_INET : IPV4* SOCK_STREAM:TCP协议*/sockfd = socket(AF_INET,SOCK_STREAM,0);if(sockfd<0){perror("sockek error");exit(1);}/** 步骤2：调用bind函数将socket和地址（ip和port）进行绑定  * */// 专用地址，绑定的时候在强转为通用地址struct sockaddr_in serveraddr; memset(&serveraddr,0,sizeof(serveraddr));serveraddr.sin_family = AF_INET; // IPV4serveraddr.sin_port = htons(atoi(argv[1]));// 字符串-> 整型，主机字节序->网络字节序serveraddr.sin_addr.s_addr = INADDR_ANY;//响应所有请求if(bind(sockfd,(struct sockaddr*)&serveraddr,sizeof(serveraddr))<0){perror("bind error");exit(1);}/**步骤3：调用listen函数启动监听(指定port监听)通知系统去接受来自客户端的连接请求将接受到的客户端连接请求放置到对应的队列中第二个参数：10：队列的长度* */if(listen(sockfd,10)<0){perror("listen error");exit(1);}/**步骤4：调用accept函数，从队列中获得一个客户端的请求连接*  并返回一个新的socket描述符*注意:若没有客户端连接，调用此函数后会阻塞直到获得一个客户端的连接* */// 创建放置套接字描述符fd的动态数组vfd = create_vector_fd();// 设置线程的分离属性pthread_attr_t attr;pthread_attr_init(&attr);pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);int err;pthread_t th; if((err=pthread_create(&th,&attr,th_fn,(void*)0))!=0){perror("pthread create error");exit(1);}pthread_attr_destroy(&attr);/** 1) 主控线程获得客户端的连接，将新的socket描述符放置到动态数组中* 2) *      a) 启动的子线程调用select函数委托内核去检查传入到select中的描述符是否准备好*      b) 利用FD_ISSET来找出准备好的那些描述符并和对应的客户端进行双向通信(非阻塞)** */struct sockaddr_in clientaddr;socklen_t clientaddr_len = sizeof(clientaddr);while(1){int fd = accept(sockfd,(struct sockaddr*)&clientaddr,&clientaddr_len);if(fd<0){perror("accept error");continue;}out_addr(&clientaddr);// 将返回新的socket描述符加入到动态数组中add_fd(vfd,fd);}return 0;
}

在这里插入图片描述

守护进程

在这里插入图片描述

  • 编程步骤
    在这里插入图片描述
  • 出错处理
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

#include<stdio.h>
#include<stdlib.h>
#include<netdb.h>
#include<sys/socket.h>
#include<unistd.h>
#include<string.h>
#include<memory.h>
#include<signal.h>
#include<time.h>
#include<errno.h>
#include<sys/types.h>
#include<sys/wait.h>
#include<pthread.h>
#include<fcntl.h>
#include<syslog.h>
#include<sys/stat.h>
#include"vector_fd.h"VectorFD *vfd;
int sockfd;/**fd对应于某个连接的客户端，和某个连接的客户端进行双向通信（非阻塞方式）* */
void do_service(int fd)
{// 和客户端进行读写操作(双向通信)char buff[512];while(1){memset(buff,0,sizeof(buff));// 以非阻塞方式读，读不到数据就返回了，直接服务于下一个客户端，因此不需要判断size<0的情况size_t size=read(fd,buff,sizeof(buff));if(size==0){char info[] = "client closed\n";syslog(LOG_DEBUG,"client closed");//printf("client closed\n"); // 这里由于内核设置，所以可以使用带缓存的IO// 从动态数组中删除对应的fdremove_fd(vfd,fd);// 关闭对应的客户端的socketclose(fd);}else if(size > 0){//write(STDOUT_FILENO,buff,sizeof(buff));// printf("%s\n",buff);syslog(LOG_DEBUG,"%s\n",buff);if(write(fd,buff,size)<size){if(errno==EPIPE)// 客户端关闭连接{syslog(LOG_DEBUG,"write:%s\n",strerror(errno));remove_fd(vfd,fd);close(fd);}}}}
}/*遍历出动态数组中所有的描述符并加入到描述符集set中* 同时此函数返回动态数组中最大的那个描述符* */
int add_set(fd_set *set)
{FD_ZERO(set); // 清空描述符int max_fd = vfd->fd[0];for(int i = 0;i < vfd->fd[0];i++){int fd = get_fd(vfd,i);if(fd>max_fd){max_fd = fd;}FD_SET(fd,set);//将fd加入到描述符集中}return max_fd;
}
void * th_fn(void *arg)
{struct timeval t;t.tv_sec = 2;t.tv_usec = 0;int n = 0;int maxfd;fd_set set; // 描述符集maxfd = add_set(&set);/*调用select函数会阻塞，委托内核去检查传入的描述符是否准备好，* 如有则返回准备好的描述符，* 超时则返回0* 第一个参数为描述符集中描述符的范围(最大描述符+1)* */while((n=select(maxfd+1,&set,NULL,NULL,&t))>=0){if(n>0){/*检测那些描述符准备好，并和这些准备好的描述符对应的客户端进行数据的双向通信* */for(int i=0;i<vfd->counter;i++){int fd = get_fd(vfd,i);if(FD_ISSET(fd,&set)){do_service(fd);}}}//超时// 重新设置时间和清空描述符集t.tv_sec = 2;t.tv_usec = 0;// 重新遍历动态数组中最新的描述符放置到描述符集中maxfd = add_set(&set);}
}void out_addr(struct sockaddr_in *clientaddr)
{char ip[16];memset(ip,0,sizeof(ip));int port = ntohs(clientaddr->sin_port);inet_ntop(AF_INET,&clientaddr->sin_addr.s_addr,ip,sizeof(ip));syslog(LOG_DEBUG,"%s(%d) connected!\n",ip,port);
}
int main(int argc,char *argv[])
{// 参数：服务器端绑定的端口if(argc<2){printf("usage :%s #port\n",argv[0]);exit(1);}// 守护进程编程的5个步骤// 步骤1：创建屏蔽字为0umask(0);// 步骤2:调用fork函数创建子进程，然后父进程退出pid_t pid = fork();if(pid>0) exit(0);//步骤3:调用setsid函数创建一个新的会话setsid();//步骤4:将当前工作目录更改为根目录chdir("/");//步骤5:关闭不需要的文件描述符close(STDIN_FILENO);close(STDOUT_FILENO);close(STDERR_FILENO);//打开系统日志服务的一个连接openlog(argv[0],LOG_PID,LOG_SYSLOG);/* * 步骤1. 创建socket，套接字socket创建在内核,是一个结构体* AF_INET : IPV4* SOCK_STREAM:TCP协议*/sockfd = socket(AF_INET,SOCK_STREAM,0);if(sockfd<0){syslog(LOG_DEBUG,"socket:%s\n",strerror(errno));exit(1);}/** 步骤2：调用bind函数将socket和地址（ip和port）进行绑定  * */// 专用地址，绑定的时候在强转为通用地址struct sockaddr_in serveraddr; memset(&serveraddr,0,sizeof(serveraddr));serveraddr.sin_family = AF_INET; // IPV4serveraddr.sin_port = htons(atoi(argv[1]));// 字符串-> 整型，主机字节序->网络字节序serveraddr.sin_addr.s_addr = INADDR_ANY;//响应所有请求if(bind(sockfd,(struct sockaddr*)&serveraddr,sizeof(serveraddr))<0){// 将日志信息写入到系统日志文件中(/var/log/syslog)syslog(LOG_DEBUG,"bind:%s\n",strerror(errno));exit(1);}/**步骤3：调用listen函数启动监听(指定port监听)通知系统去接受来自客户端的连接请求将接受到的客户端连接请求放置到对应的队列中第二个参数：10：队列的长度* */if(listen(sockfd,10)<0){syslog(LOG_DEBUG,"listen:%s\n",strerror(errno));exit(1);}/**步骤4：调用accept函数，从队列中获得一个客户端的请求连接*  并返回一个新的socket描述符*注意:若没有客户端连接，调用此函数后会阻塞直到获得一个客户端的连接* */// 创建放置套接字描述符fd的动态数组vfd = create_vector_fd();// 设置线程的分离属性pthread_attr_t attr;pthread_attr_init(&attr);pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);int err;pthread_t th; if((err=pthread_create(&th,&attr,th_fn,(void*)0))!=0){syslog(LOG_DEBUG,"pthread:%s\n",strerror(errno));exit(1);}pthread_attr_destroy(&attr);/** 1) 主控线程获得客户端的连接，将新的socket描述符放置到动态数组中* 2) *      a) 启动的子线程调用select函数委托内核去检查传入到select中的描述符是否准备好*      b) 利用FD_ISSET来找出准备好的那些描述符并和对应的客户端进行双向通信(非阻塞)** */struct sockaddr_in clientaddr;socklen_t clientaddr_len = sizeof(clientaddr);while(1){int fd = accept(sockfd,(struct sockaddr*)&clientaddr,&clientaddr_len);if(fd<0){syslog(LOG_DEBUG,"accept:%s\n",strerror(errno));continue;}out_addr(&clientaddr);// 将返回新的socket描述符加入到动态数组中add_fd(vfd,fd);}return 0;
}
http://www.lryc.cn/news/528862.html

相关文章：

  • C++并发编程指南04
  • 常见的同态加密算法收集
  • 深入探讨数据库索引类型：B-tree、Hash、GIN与GiST的对比与应用
  • 记录 | Docker的windows版安装
  • AI智慧社区--生成验证码
  • 2501,20个窗口常用操作
  • 【gopher的java学习笔记】一文讲懂controller，service，mapper，entity是什么
  • 消息队列篇--通信协议篇--STOMP（STOMP特点、格式及示例，WebSocket上使用STOMP，消息队列上使用STOMP等）
  • 基于SpringBoot的租房管理系统（含论文）
  • 提升企业内部协作的在线知识库架构与实施策略
  • 【物联网】ARM核常用指令(详解)：数据传送、计算、位运算、比较、跳转、内存访问、CPSR/SPSR、流水线及伪指令
  • Jackson中@JsonTypeId的妙用与实例解析
  • Ubuntu 顶部状态栏 配置，gnu扩展程序
  • Java---入门基础篇(上)
  • Linux C++
  • gradio 合集
  • 996引擎 - NPC-动态创建NPC
  • 论文阅读(十三)：复杂表型关联的贝叶斯、基于系统的多层次分析：从解释到决策
  • 代码随想录算法训练营第三十九天-动态规划-198. 打家劫舍
  • CF1098F Ж-function
  • Python 函数魔法书：基础、范例、避坑、测验与项目实战
  • vim交换文件的作用
  • [NOI1995] 石子合并
  • 真正的智能与那只蝴蝶
  • C++小病毒-1.0勒索(更新次数:2)
  • Node.js 的底层原理
  • 基于Django的豆瓣影视剧推荐系统的设计与实现
  • P10638 BZOJ4355 Play with sequence Solution
  • MySQL误删数据怎么办？
  • 项目测试之MockMvc