网站弹出公告代码,WordPress ngrok,手机端制作游戏的app,怎样用ps做网站首页图片网络的基本概念 TCP/IP协议概述 OSI和TCP/IP模型 socket#xff08;套接字#xff09; 创建socket 字节序 字节序转换函数 通用地址结构 因特网地址结构 IPV4地址族和字符地址间的转换(点分十进制-网络字节序) 填写IPV4地址族结构案例 掌握TCP协议网络基础编程 相关函数 …网络的基本概念 TCP/IP协议概述 OSI和TCP/IP模型 socket套接字 创建socket 字节序 字节序转换函数 通用地址结构 因特网地址结构 IPV4地址族和字符地址间的转换(点分十进制-网络字节序) 填写IPV4地址族结构案例 掌握TCP协议网络基础编程 相关函数 特殊bind地址 案例1:time 先启动一个服务端客户链接上来之后服务端返回一个系统时间 time_tcp_server.c
#include stdio.h
#includestdlib.h
#includenetdb.h
#includesys/socket.h
#includeunistd.h
#includestring.h
#includememory.h
#includesignal.h
#includetime.hint sockfd;void sig_handler(int signo)
{if(signoSIGINT){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(argc2){printf(usage :%s #port\n,argv[0]);exit(0);}// 绑定一个信号ctrlc 终止服务端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(fd0){perror(accept error);continue;}/**步骤5调用IO函数和客户端进行双向的通信*/out_addr(clientaddr);do_service(fd);/*步骤5* 关闭 socket* */
- time_tcp_client.cc
#includestdio.h
#includestdlib.h
#includenetdb.h
#includesys/socket.h
#includeunistd.h
#includestring.h
#includememory.h
#includesignal.h
#includetime.hint main(int argc,char *argv[])
{// 参数服务器端绑定的端口if(argc2){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(sockfd0){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((sizeread(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__
#includesys/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
#includeunistd.h
#includestring.h
#includememory.h
#includesys/types.h
#includemsg.h// 计算校验码
static unsigned char msg_check(Msg *message)
{unsigned char s 0;for(int i0;isizeof(message-head);i){smessage-head[i];}for(int i0;isizeof(message-buff);i){smessage-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((sizeread(sockfd,message,sizeof(message)))0){return -1;}else if(size0){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((lenread(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
#includestdio.h
#includestdlib.h
#includenetdb.h
#includesys/socket.h
#includeunistd.h
#includestring.h
#includememory.h
#includesignal.h
#includetime.h
#includeerrno.h
#includemsg.h
int sockfd;void sig_handler(int signo)
{if(signoSIGINT){printf(server close\n);/*步骤6* 关闭socket* */close(sockfd);exit(1);}if(signoSIGCHLD){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((sizeread_msg(fd,buff,sizeof(buff)))0){perror(protocal error);break;}else if(size0){break; // 写端突然挂了}else{printf(%s\n,buff);if(write_msg(fd,buff,sizeof(buff))0){if(errnoEPIPE)// 读端突然关闭时类似于管道通信{break;}perror(protocal error);}}}
}
int main(int argc,char *argv[])
{// 参数服务器端绑定的端口if(argc2){printf(usage :%s #port\n,argv[0]);exit(0);}// 绑定一个信号ctrlc 终止服务端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(sockfd0){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(fd0){perror(accept error);continue;}/**步骤5启动子进程调用IO函数 */pid_t pid fork();if(pid0){continue;}else if(pid0){out_addr(clientaddr);do_service(fd);/*步骤6:* 关闭 socket* */close(fd); /// 子进程会复制父进程的fd}else{close(fd); }}return 0;
}
echo_tcp_client.c #includestdio.h
#includestdlib.h
#includenetdb.h
#includesys/socket.h
#includeunistd.h
#includestring.h
#includememory.h
#includesignal.h
#includetime.h
#includeerrno.h
#includemsg.hint main(int argc,char *argv[])
{// 参数服务器端绑定的端口if(argc2){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(sockfd0){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(size0) {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
#includestdio.h
#includestdlib.h
#includenetdb.h
#includesys/socket.h
#includeunistd.h
#includestring.h
#includememory.h
#includesignal.h
#includetime.h
#includeerrno.h
#includesys/types.h
#includesys/wait.h
#includepthread.h
#includemsg.hint sockfd;void sig_handler(int signo)
{if(signoSIGINT){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((sizeread_msg(fd,buff,sizeof(buff)))0){perror(protocal error);break;}else if(size0){break; // 写端突然挂了}else{printf(%s\n,buff);if(write_msg(fd,buff,sizeof(buff))0){if(errnoEPIPE)// 读端突然关闭时类似于管道通信{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(argc2){printf(usage :%s #port\n,argv[0]);exit(0);}// 绑定一个信号ctrlc 终止服务端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(sockfd0){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(fd0){perror(accept error);continue;}/**步骤5启动子线程调用IO函数 */pthread_t th;int err;// 以分离状态启动子线程if((errpthread_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
#includesys/socket.h
#includeunistd.h
#includestring.h
#includestdlib.h
#includesignal.h
#includetime.h
#includenetdb.hint sockfd;void sig_handler(int signo)
{if(signoSIGINT){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(argc0){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(sockfd0){perror(sockfd error);exit(1);}int res;int opt 1;// 设置套接字选项:让刚才实现的端口立即启动if((ressetsockopt(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
#includestdlib.h
#includestring.h
#includenetdb.h
#includesys/socket.h
#includememory.h
#includeunistd.hint main(int argc,char *argv[])
{if(argc3){printf(usgae : %s ip port \n,argv[0]);exit(1);}/*步骤1创建socket* */int sockfd socket(AF_INET,SOCK_DGRAM,0);if(sockfd0){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
#includenetdb.h
#includestdlib.h
#includememory.hvoid out_addr(struct hostent *h)
{printf(hostbyname: %s\n,h-h_name);printf(addrtype: %s\n,h-h_addrtypeAF_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(argc2){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
#includenetdb.h
#includestdlib.h
#includememory.hvoid out_addr(struct hostent *h)
{printf(hostbyname: %s\n,h-h_name);printf(addrtype: %s\n,h-h_addrtypeAF_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(argc2){printf(usage %s host \n,argv[0]);exit(1);}struct hostent *h;while((hgethostent()) ! 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
#includestdlib.h
#includestring.h
#includenetdb.h
#includesys/socket.h
#includememory.h
#includeunistd.hint 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(argc3){printf(usgae : %s ip port \n,argv[0]);exit(1);}/*步骤1创建socket* */int sockfd socket(AF_INET,SOCK_DGRAM,0);if(sockfd0){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
#includenetdb.h
#includesys/socket.h
#includestring.h
#includesignal.h
#includestdlib.hint sockfd;void sig_handler(int signo)
{if(signo SIGINT){printf(receiver will exited);close(sockfd);exit(1);}
}int main(int argc,char *argv[])
{if(argc2){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(sockfd0){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
#includestdlib.h
#includestring.h
#includenetdb.h
#includesys/socket.hint main(int argc,char * argv[])
{if(argc3){fprintf(stderr,usage: %s ip port\n,argv[0]);exit(1);}int sockfd socket(AF_INET,SOCK_DGRAM,0);if(sockfd0){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 #includestdio.h
#includestdlib.h
#includenetdb.h
#includesys/socket.h
#includeunistd.h
#includestring.h
#includememory.h
#includesignal.h
#includetime.h
#includeerrno.h
#includesys/types.h
#includesys/wait.h
#includepthread.h
#includefcntl.h
#includevector_fd.hVectorFD *vfd;
int sockfd;void sig_handler(int signo)
{if(signoSIGINT){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));// 以非阻塞方式读读不到数据就返回了直接服务于下一个客户端因此不需要判断size0的情况size_t sizeread(fd,buff,sizeof(buff));if(size0){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(errnoEPIPE)// 客户端关闭连接{perror(write error);remove_fd(vfd,fd);close(fd);}}}}
}void * th_fn(void *arg)
{int i;while(1){// 遍历动态数中的socket描述符for(int i 0;ivfd-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(argc2){printf(usage :%s #port\n,argv[0]);exit(0);}// 绑定一个信号ctrlc 终止服务端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(sockfd0){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((errpthread_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(fd0){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
#includestdio.h
#includestdlib.h
#includenetdb.h
#includesys/socket.h
#includeunistd.h
#includestring.h
#includememory.h
#includesignal.h
#includetime.h
#includeerrno.hint main(int argc,char *argv[])
{// 参数服务器端绑定的端口if(argc2){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(sockfd0){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(size0) {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
#includestdio.h
#includestdlib.h
#includenetdb.h
#includesys/socket.h
#includeunistd.h
#includestring.h
#includememory.h
#includesignal.h
#includetime.h
#includeerrno.h
#includesys/types.h
#includesys/wait.h
#includepthread.h
#includefcntl.h
#includevector_fd.hVectorFD *vfd;
int sockfd;void sig_handler(int signo)
{if(signoSIGINT){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));// 以非阻塞方式读读不到数据就返回了直接服务于下一个客户端因此不需要判断size0的情况size_t sizeread(fd,buff,sizeof(buff));if(size0){//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(errnoEPIPE)// 客户端关闭连接{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(fdmax_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((nselect(maxfd1,set,NULL,NULL,t))0){if(n0){/*检测那些描述符准备好并和这些准备好的描述符对应的客户端进行数据的双向通信* */for(int i0;ivfd-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(argc2){printf(usage :%s #port\n,argv[0]);exit(0);}// 绑定一个信号ctrlc 终止服务端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(sockfd0){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((errpthread_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(fd0){perror(accept error);continue;}out_addr(clientaddr);// 将返回新的socket描述符加入到动态数组中add_fd(vfd,fd);}return 0;
} 守护进程 编程步骤 出错处理 #includestdio.h
#includestdlib.h
#includenetdb.h
#includesys/socket.h
#includeunistd.h
#includestring.h
#includememory.h
#includesignal.h
#includetime.h
#includeerrno.h
#includesys/types.h
#includesys/wait.h
#includepthread.h
#includefcntl.h
#includesyslog.h
#includesys/stat.h
#includevector_fd.hVectorFD *vfd;
int sockfd;/**fd对应于某个连接的客户端和某个连接的客户端进行双向通信非阻塞方式* */
void do_service(int fd)
{// 和客户端进行读写操作(双向通信)char buff[512];while(1){memset(buff,0,sizeof(buff));// 以非阻塞方式读读不到数据就返回了直接服务于下一个客户端因此不需要判断size0的情况size_t sizeread(fd,buff,sizeof(buff));if(size0){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(errnoEPIPE)// 客户端关闭连接{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(fdmax_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((nselect(maxfd1,set,NULL,NULL,t))0){if(n0){/*检测那些描述符准备好并和这些准备好的描述符对应的客户端进行数据的双向通信* */for(int i0;ivfd-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(argc2){printf(usage :%s #port\n,argv[0]);exit(1);}// 守护进程编程的5个步骤// 步骤1创建屏蔽字为0umask(0);// 步骤2:调用fork函数创建子进程然后父进程退出pid_t pid fork();if(pid0) 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(sockfd0){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((errpthread_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(fd0){syslog(LOG_DEBUG,accept:%s\n,strerror(errno));continue;}out_addr(clientaddr);// 将返回新的socket描述符加入到动态数组中add_fd(vfd,fd);}return 0;
}
