服务器模型 setsockopt 网络超时检测 广播组播和unix域套接字 5.23

最新推荐文章于 2023-09-08 19:26:35 发布
最新推荐文章于 2023-09-08 19:26:35 发布
阅读量520 收藏
点赞数
分类专栏： 网络编程 文章标签： 服务器 网络 unix tcp/ip
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45241469/article/details/130835950
版权

四.服务器模型

1.循环服务器

TCP服务器
TCP服务器端运行后等待客户端的连接请求。
TCP服务器接受一个客户端的连接后开始处理，完成了客户的所有请求后断开连接。 
TCP循环服务器一次只能处理一个客户端的请求。
只有在当前客户的所有请求都完成后，服务器才能处理下一个客户的连接/服务请求。
缺点：
    如果某个客户端一直占用服务器资源，那么其它的客户端都不能被处理。TCP服务器一般很少采用循环服务器模型。 

流程如下:
	socket(...); 
	bind(...); 
	listen(...); 
	while(1) 
    { 
        connfd = accept(...); 
        while(1) 
        { 
            recv(...); 
            process(...); 
            send(...); 
        } 
      	close(connfd); 
    }

2.并发服务器

为了弥补TCP循环服务器的缺陷，人们又设计了并发服务器的模型。
并发服务器的设计思想是服务器接受客户端的连接请求后创建子进程来为客户端服务 
TCP并发服务器可以避免TCP循环服务器中客户端独占服务器的情况。
为了响应客户机的请求,服务器要创建子进程来处理。 如果有多个客户端的话，服务器端需要创建多个子进程。过多的子进程会影响服务器端的运行效率

流程如下:
1. 多线程:
	void *accept_client(void *arg)
    {
        //int connfd = *((int*)arg);
        int connfd = (int)arg;
        while(1)   //和客户端通信部分
        { 
            recv(...); 
            process(...); 
            send(...); 
        }
        close(connfd);
        pthread_exit(NULL);
    }

	sockfd = socket(...); 
	bind(...); 
	listen(...); 
	while(1) 
    { 
        int connfd = accept(...); 
        //pthread_create(&thread, NULL, accept_client, (void*)&connfd);
        pthread_create(&thread, NULL, accept_client, (void*)connfd);
        pthread_detach(thread);
    }
	close(sockfd);

2. 多进程：
    void handler(int sig)
	{
    	while (waitpid(-1, NULL, WNOHANG)>0);
	}
    
    sockfd = socket();
	bind();
	listen();
	signal(SIGCHLD, handler);

	while (1)
    {
        connfd = accept();
        pid = fork();
        if (0 == pid)  //子进程
        {
            close(sockfd);
            while (1)  
            {
                //与客户端通信
            }
            close(connfd);
            exit(0);
        }
        close(connfd); 
    }
	close(sockfd);



/
多进程服务器
  /*===============================================
 *   文件名称：server.c
 *   创 建 者：memories 
 *   创建日期：2023年05月18日
 *   描    述：
 ================================================*/
    
    
这里重点提一下SIGCHLD信号（17号信号），对于父进程而言，一般要对它的子进程进行等待，以防止子进程变为僵尸进程，而导致内存泄漏问题，但是对于父进程的等待方式存在两种：阻塞式等待和非阻塞式等待，可以通过wait和waitpid这两个系统调用来实现，对于父进程而言，阻塞式等待让父进程停下自己手头上的事情，专心的等待子进程退出，这严重影响了父进程的工作；而对于非阻塞式等待，父进程每隔一段时间都要轮循一下，看看子进程有没有退出，这也让我们的程序变的复杂，所以我们就想能不能让父进程对于子进程的等待变成子进程退出了就通知父进程进行回收，也就是让对子进程的等待变成异步等待，不干扰父进程的正常工作呢？

这里就得了解一下父进程是如何知道子进程已经退出的，也就是我们的SIGCHLD这个信号的作用，当子进程退出时，会向父进程发送SIGCHLD信号，而父进程就是根据是否收到这个信号来判断子进程是否退出的



while(waitpid(-1,NULL,WNOHANG)>0)；

一次结束可以回收多个尸体

（假如有五个客户端同时停止，waitpid(-1,NULL,WNOHANG)一次只会回收一个尸体，因为SIGCHLD只会执行一次，在第二次回收第二剧尸体时发现SIGCHLD已经被调用，就不会在第二次调用。。在这里采用while循环重复调用，waitpid的返回值若>0则资源还没有回收完，=0子进程资源已经回收完）    
    

#include <stdio.h>
#include "ip.h"


void handler(int arg)
{
    while(waitpid(-1,NULL,WNOHANG)>0);
}

int main(int argc, char *argv[])
{ 
    //1.创建套接字
    int sockfd = socket(AF_INET,SOCK_STREAM,0);
    if(sockfd<0)
    {
        perror("socket");
        return -1;
    }
    printf("socket-----------------\n");
    //2.绑定本机地址和端口
    //用IPv4结构体
    struct sockaddr_in srvaddr;
    memset(&srvaddr,0,sizeof(srvaddr));
    srvaddr.sin_family = AF_INET;//指定地址族为IPv4的地址
    srvaddr.sin_port = htons(54320);//端口号
    srvaddr.sin_addr.s_addr = htonl(INADDR_ANY);//将点分式的字符串转化32位的网络字节序
    //设置重用本地地址和端口
    int on = 1;
    if(0 > setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on)))
    {
        perror("setsockopt");
        return -1;
    }
    if(0 > bind(sockfd,(struct sockaddr*)&srvaddr,sizeof(srvaddr)))
    {
        perror("bind");
        return -1;
    }
    printf("bind-----------------\n");
    //3.设置监听套接字
    if(0>listen(sockfd,5))//必须写大于1的整数
    {
        perror("listen");
        return -1;
    }
    printf("listen-----------------\n");
    signal(SIGCHLD,handler);//信号灯集，异步通信

    while(1)
    {
        //4.接受客户端的连接，并生成通信套接字
        int connfd = accept(sockfd,NULL,NULL);
        if(connfd < 0)
        {
            perror("accept");
            return -1;
        }
        printf("accept-----------------\n");
        pid_t pid=fork();
        if(pid<0)
        {
            perror("fork");
            return -1;
        }

        else if(pid == 0)
        {
            close(sockfd);
            //设置超时
            struct timeval tv={1};
            if(0 > setsockopt(connfd,SOL_SOCKET,SO_RCVTIMEO,&tv,sizeof(tv)))
            {
                perror("setsockopt");
                return -1;
            }
            //5.与客户端通信
            int ret;
            char buf[1024];
            while(1)
            {
                memset(buf,0,sizeof(buf));
                ret = read(connfd,buf,sizeof(buf));
                if(ret < 0)
                {
                    perror("read");
                    continue;
                }
                else if(ret == 0)
                {
                    printf("write close\n");
                    break;
                }
                printf("recv:%s\n",buf);

                if(0 > write(connfd,buf,ret))
                {
                    perror("write");
                    return -1;
                }
            }
        }
        else
            close(connfd);

    }
    return 0;
}

//
多线程
    
/*===============================================
 *   文件名称：server.c
 *   创 建 者：memories 
 *   创建日期：2023年05月18日
 *   描    述：
 ================================================*/
#include <stdio.h>
#include "ip.h"
int *process1(void *arg);
void handler(int arg);

int main(int argc, char *argv[])
{ 
    //1.创建套接字
    int sockfd = socket(AF_INET,SOCK_STREAM,0);
    if(sockfd<0)
    {
        perror("socket");
        return -1;
    }
    printf("socket-----------------\n");
    //2.绑定本机地址和端口
    //用IPv4结构体
    struct sockaddr_in srvaddr;
    memset(&srvaddr,0,sizeof(srvaddr));
    srvaddr.sin_family = AF_INET;//指定地址族为IPv4的地址
    srvaddr.sin_port = htons(5420);//端口号
    srvaddr.sin_addr.s_addr = htonl(INADDR_ANY);//将点分式的字符串转化32位的网络字节序
    int on = 1;
    if(0 > setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on)))
    {
        perror("setsockopt");
        return -1;
    }
    if(0 > bind(sockfd,(struct sockaddr*)&srvaddr,sizeof(srvaddr)))
    {
        perror("bind");
        return -1;
    }
    printf("bind-----------------\n");
    //3.设置监听套接字
    if(0>listen(sockfd,5))//必须写大于1的整数
    {
        perror("listen");
        return -1;
    }
    printf("listen-----------------\n");
    /
    SAI cliaddr;
    socklen_t addrlen = sizeof(cliaddr);
    while(1)
    {
        //4.接受客户端的连接，并生成通信套接字
        int connfd = accept(sockfd,(SA *)&cliaddr,&addrlen);
        if(connfd < 0)
        {
            perror("accept");
            return -1;
        }
        printf("accept success:%s %hu\n",inet_ntoa(cliaddr.sin_addr),ntohs(cliaddr.sin_port));

        pthread_t tid,tid2;
        if(0 != pthread_create(&tid,NULL,(void *)process1,(void *)&connfd))
        {
            printf("pthread creat failed\n");
            return -1;
        }
        //线程分离
        if(0 != pthread_detach(tid))
            break;
        /*
           if(0 > pthread_create(&tid2,NULL,process2,(void *)&connfd))
           {
           printf("pthread2 creat failed\n");
           return -1;
           }
           */

    }
    //6.关闭套接字
    close(sockfd);
    return 0;
} 

void handler(int arg)
{
    printf("timeout\n");
}

int *process1(void *arg)
{
    int connfd = *((int *)arg);
       struct timeval tv={1};
       if(0 > setsockopt(connfd,SOL_SOCKET,SO_RCVTIMEO,&tv,sizeof(tv)))
       {
       perror("setsockopt");
       return NULL;
       }
       
    /*
    struct sigaction act;
    sigaction(SIGALRM,NULL,&act);
    act.sa_handler = handler;
    act.sa_flags &= ~SA_RESTART; 
    sigaction(SIGALRM,&act,NULL);
    */
    //5.与客户端通信
    int ret;
    char buf[1024];
    while(1)
    {
      //  alarm(1);
        memset(buf,0,sizeof(buf));
        ret = read(connfd,buf,sizeof(buf));
        if(ret < 0)
        {
            perror("read");
            continue;
        }
        else if(ret == 0)
        {
            printf("write close\n");
            break;
        }
        printf("recv:%s\n",buf);

        if(0 > write(connfd,buf,ret))
        {
            perror("write");
            return NULL;
        }
    }
    close(connfd);
    pthread_exit(NULL);

}

五.进阶篇

应用层知道底层的信息：网络信息检索函数

1.setsockopt()

#include <sys/types.h>          /* See NOTES */
       #include <sys/socket.h>

       int getsockopt(int sockfd, int level, int optname,void *optval, socklen_t *optlen);
       int setsockopt(int sockfd, int level, int optname,const void *optval, socklen_t optlen);

作用：获取/设置套接字属性
参数：
    sockfd --- 套接字文件描述符
    level --- 选项所在层
    			1）SOL_SOCKET:通用套接字选项
                2）IPPROTO_IP:IP选项
                3）IPPROTO_TCP:TCP选项
    optname --- 选项的名字
    optval --- 选项的值
    optlen --- 选项的长度
    
返回值：
     成功：0
     失败：-1，并设置error
                    
/*设置重用本地地址和端口*/
int on = 1;
if (0 > setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)))
{
    perror("setsockopt");
    return -1;
}

/*===============================================
*   文件名称：server.c
*   创 建 者：     
*   创建日期：2023年05月18日
*   描    述：
================================================*/
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{ 
    /*1. 创建套接字*/
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("socket");
        return -1;
    }
    printf("socket..............\n");

    /*设置重用本地地址和端口*/
    int on = 1;
    if (0 > setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)))
    {
        perror("setsockopt");
        return -1;
    }

    /*2. 绑定本机地址和端口*/
    struct sockaddr_in srvaddr;
	memset(&srvaddr, 0, sizeof(srvaddr));
	srvaddr.sin_family 	= AF_INET;  //地址族
	srvaddr.sin_port 	= htons(6666); //端口号
    srvaddr.sin_addr.s_addr = htonl(INADDR_ANY);  //IP地址

	if (0 > bind(sockfd, (struct sockaddr*)&srvaddr, sizeof(srvaddr))) 
    {
        perror("bind");
        return -1;
    }
    printf("bind................\n");

    /*3. 设置监听套接字*/
    if (0 > listen(sockfd, 5))
    {
        perror("listen");
        return -1;
    }
    printf("listen.................\n");

    /*4. 接受客户端的连接，并生成通信套接字*/
    int connfd = accept(sockfd, NULL, NULL);
    if (connfd < 0)
    {
        perror("accept");
        return -1;
    }
    printf("accept success!\n");

    /*接收超时*/
    struct timeval tv = {1};
    if (0 > setsockopt(connfd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)))
    {
        perror("setsockopt");
        return -1;
    }

    /*5. 与客户端通信*/
    int ret;
    char buf[1024];
    while (1)
    {
        memset(buf, 0, sizeof(buf));
        ret = read(connfd, buf, sizeof(buf));
        if (ret < 0)
        {
            perror("read");
            continue;
        }
        else if (0 == ret)
        {
            printf("write close!\n");
            break;
        }
        printf("recv: %s\n", buf);
/*
        if (0 > write(connfd, buf, ret))
        {
            perror("write");
            break;
        }
*/
    }

    /*6. 关闭套接字*/
    close(connfd);
    close(sockfd);

    return 0;
}

2.网络超时检测

网络超时
●
在网络通信中,很多操作会使得进程阻塞
●
TCP套接字中的recv/ accept/ connect
●
UDP套接字中的recvfrom
●

超时检测的必要性
避免进程在没有数据时无限制地阻塞（例如有两个客户端连接同一个服务器，当客户端1没有输入数据时，服务器就会阻塞等待1的输入，大大浪费了服务器的资源，所以采用网络超时检测，循环检测，当客户端2输入时也能检测出运行到）
当设定的时间到时，进程从原操作返回继续运行

1)setsockopt

/*接收超时*/
struct timeval tv = {1};
if (0 > setsockopt(connfd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)))
{
    perror("setsockopt");
    return -1;
}


 ret = read(connfd,buf,sizeof(buf));
                if(ret < 0)
                {
                    perror("read");
                    continue;
                }
                else if(ret == 0)
                {
                    printf("write close\n");
                    break;
                }
                printf("recv:%s\n",buf);

2)select/poll

struct timeval va ={1,1000000};
        //2.监测是否有文件描述符产生了事件
        int  retval = select(maxfd+1,&rfds,NULL,NULL,&va);
        if(retval < 0)
        {
            perror("select");
            break;
        }
        else if(0 == retval)
        {
            printf("timeout------\n");
            continue;
        }
若没数据输入则每隔2s打印timeout------

3)sigaction()

设置定时器(timer), 捕捉SIGALRM信号
参考代码如下
    void  handler(int signo)     {   return;  }
//一旦进程收到这个信号，执行完信号处理函数之后，下一个函数就会直接返回，不阻塞在那里
    struct sigaction act;
	sigaction(SIGALRM, NULL, &act);  //获取信号原有的act
	act.sa_handler = handler;
	act.sa_flags &= ~SA_RESTART;   //把原有的act改成需要的act
	sigaction(SIGALRM, &act, NULL); //设置信号新的act
	
    /*5. 与客户端通信*/
    int ret;
    char buf[1024];
    while (1)
    {
		alarm(1);  //闹钟函数，产生SIGALRM信号
        recv()
    }

|= ：添加某功能

&= ~：去除某功能

3.广播

在这里插入图片描述

前面介绍的数据包发送方式只有一个接受方，称为单播

如果同时发给局域网中的所有主机，称为广播

只有用户数据报(使用UDP协议)套接字才能广播

广播地址

​ 以192.168.1.0 (255.255.255.0) 网段为例，最大的主机地址192.168.1.255代表该网段的广播地址

​ 发到该地址的数据包被所有的主机接收

​ 255.255.255.255在所有网段中都代表广播地址

1. 发送方
    创建用户数据报套接字

    缺省创建的套接字不允许广播数据包，需要设置属性
    setsockopt可以设置套接字属性

	接收方地址指定为广播地址以及端口信息

	发送数据包
    
2. 接收方
    创建用户数据报套接字
    
    绑定IP地址(广播IP或0.0.0.0)和端口
	绑定的端口必须和发送方指定的端口相同

	等待接收数据
	
	
	
	
	
#include <stdio.h>
#include "net.h"
/
    接收方
int main()
{
	/*1. 创建用户数据报套接字*/
	int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
	if (sockfd < 0)
	{
		perror("socket");
		return -1;
	}
	
	/*允许重用本地地址和端口*/
	int on = 1;
	if (0 > setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)))
	{
		perror("setsockopt");
		return -1;
	}
	
	/*2. 绑定广播地址和端口*/
	SAI bcaddr = {
		.sin_family = AF_INET,
		.sin_port = htons(6666),
		.sin_addr.s_addr = inet_addr("192.168.2.255") //广播IP
	};
	if (0 > bind(sockfd, (SA*)&bcaddr, sizeof(bcaddr)))
	{
		perror("bind");
		return -1;
	}
	
	/*3. 接收数据*/
	SAI sndaddr;
	socklen_t addrlen = sizeof(sndaddr);
	int ret;
	char buf[SIZE];
	while (1)
	{
		ret = recvfrom(sockfd, buf, SIZE, 0, (SA*)&sndaddr, &addrlen);
		if (ret < 0)
		{
			perror("recvfrom");
			break;
		}
		printf("recv: %s\n", buf);
	}
	
	return 0;
}




/
发送方

#include <stdio.h>
#include "net.h"

int main()
{
	/*1. 创建用户数据报套接字*/
	int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
	if (sockfd < 0)
	{
		perror("socket");
		return -1;
	}

    /*2. 设置允许发送广播包*/
	int on = 1;
	if (0 > setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on)))
	{
		perror("setsockopt");
		return -1;
	}

	/*3. 接收方地址指定为广播地址以及端口信息*/
	SAI rcvaddr = {
		.sin_family = AF_INET,
		.sin_port = htons(6666),
		.sin_addr.s_addr = inet_addr("192.168.2.255") //广播IP
	};

	/*4. 发送数据包*/
	char buf[SIZE];
	while (1)
	{
		printf("send: ");
		fgets(buf, SIZE, stdin);
		if (0 > sendto(sockfd, buf, SIZE, 0, (SA*)&rcvaddr, sizeof(rcvaddr)))
		{
			perror("sendto");
			break;
		}
	}

	return 0;
}

4.组播

单播方式只能发给一个接收方。

广播方式发给所有的主机。过多的广播会大量占用网络带宽，造成广播风暴，影响正常的通信。

组播(又称为多播)是一种折中的方式。只有加入某个多播组的主机才能收到数据。

多播方式既可以发给多个主机，又能避免象广播那样带来过多的负载(每台主机要到传输层才能判断广播包是否要处理)
    
组播地址：
    224.0.0.1 – 239.255.255.255

1. 发送方
    创建用户数据报套接字

	接收方地址指定为组播地址以及端口信息

	发送数据包
    
2. 接收方
    a. 创建用户数据报套接字
    
    b. 加入多播组
		struct ip_mreq{
             struct  in_addr  imr_multiaddr; 
             struct  in_addr  imr_interface;
        };
        struct  ip_mreq  mreq;

        bzero(&mreq, sizeof(mreq));
        mreq.imr_multiaddr.s_addr = inet_addr(“224.10.10.1”); //组播IP
        mreq.imr_interface.s_addr = htonl(INADDR_ANY);  //本机IP
        setsockopt(sockfd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq,  sizeof(mreq));
    
    c. 绑定IP地址(组播IP或0.0.0.0)和端口
		绑定的端口必须和发送方指定的端口相同

	d. 等待接收数据
        
        
        
        
        

        接收数据
        #include <stdio.h>
#include "net.h"

int main()
{
	/*1. 创建用户数据报套接字*/
	int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
	if (sockfd < 0)
	{
		perror("socket");
		return -1;
	}
	
	/*2. 加入多播组*/
	struct ip_mreq{
		 struct  in_addr  imr_multiaddr; 
		 struct  in_addr  imr_interface;
	};
	struct  ip_mreq  mreq;

	bzero(&mreq, sizeof(mreq));
	mreq.imr_multiaddr.s_addr = inet_addr("224.0.0.1"); //组播IP
	mreq.imr_interface.s_addr = htonl(INADDR_ANY);  //本机IP
	if (0 > setsockopt(sockfd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq,  sizeof(mreq)))
	{
		perror("setsockopt");
		return -1;
	}
	
	/*允许重用本地地址和端口*/
	int on = 1;
	if (0 > setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)))
	{
		perror("setsockopt");
		return -1;
	}
	
	/*3. 绑定组播地址和端口*/
	SAI mcaddr = {
		.sin_family = AF_INET,
		.sin_port = htons(6666),
		.sin_addr.s_addr = inet_addr("224.0.0.1") //组播IP
	};
	if (0 > bind(sockfd, (SA*)&mcaddr, sizeof(mcaddr)))
	{
		perror("bind");
		return -1;
	}
	
	/*4. 接收数据*/
	SAI sndaddr;
	socklen_t addrlen = sizeof(sndaddr);
	int ret;
	char buf[SIZE];
	while (1)
	{
		ret = recvfrom(sockfd, buf, SIZE, 0, (SA*)&sndaddr, &addrlen);
		if (ret < 0)
		{
			perror("recvfrom");
			break;
		}
		printf("recv: %s, %hu, %s\n", inet_ntoa(sndaddr.sin_addr), \
			ntohs(sndaddr.sin_port), buf);
	}
	
	return 0;
}


/
发送数据
    #include <stdio.h>
#include "net.h"

int main()
{
	/*1. 创建用户数据报套接字*/
	int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
	if (sockfd < 0)
	{
		perror("socket");
		return -1;
	}

	/*2. 接收方地址指定为组播地址以及端口信息*/
	SAI rcvaddr = {
		.sin_family = AF_INET,
		.sin_port = htons(6666),
		.sin_addr.s_addr = inet_addr("224.0.0.1") //组播IP
	};

	/*3. 发送数据包*/
	char buf[SIZE];
	while (1)
	{
		printf("send: ");
		fgets(buf, SIZE, stdin);
		if (0 > sendto(sockfd, buf, SIZE, 0, (SA*)&rcvaddr, sizeof(rcvaddr)))
		{
			perror("sendto");
			break;
		}
	}

	return 0;
}

5.unix域套接字

socket同样可以用于本地通信

创建套接字时使用本地协议PF_UNIX(或PF_LOCAL, AF_UNIX, AF_LOCAL)。

分为流式套接字和用户数据报套接字

和其他进程间通信方式相比使用方便、效率更高

常用于前后台进程通信

本地地址结构
       struct sockaddr_un        //  <sys/un.h>
        {
             sa_family_t  sun_family;
             char  sun_path[108];         // 套接字文件的路径
         };
填充地址结构
    struct sockaddr_un myaddr;
     bzero(&myaddr,  sizeof(myaddr));
     myaddr.sun_family = PF_UNIX; 
     strcpy(myaddr.sun_path,  “mysocket”);

流式：
    server:
    	socket(AF_UNIX, SOCK_STREAM, 0);
		bind(本地地址);
		listen();
		accept();
        recv/send();
		close();
    client:
    	socket(AF_UNIX, SOCK_STREAM, 0);
		connect(本地地址);
		send/recv();
		close();
数据报：
	server:
		socket(AF_UNIX, SOCK_DGRAM, 0);
		bind(本地地址);
		sendto/recvfrom();
		close();
	client:
		socket(AF_UNIX, SOCK_DGRAM, 0);
		recvfrom()/sendto();
		close();

/*===============================================
*   文件名称：client.c
*   创 建 者：     
*   创建日期：2023年05月19日
*   描    述：
================================================*/

发送端
    
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/un.h>

int main(int argc, char *argv[])
{ 
    /*1. 创建套接字*/
    int sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("socket");
        return -1;
    }
    printf("socket...........\n");

    /*2. 主动连接服务器*/
    struct sockaddr_un srvaddr;
	memset(&srvaddr, 0, sizeof(srvaddr));
	srvaddr.sun_family 	= AF_UNIX;  //地址族
    strcpy(srvaddr.sun_path, "mysocket");

	if (0 > connect(sockfd, (struct sockaddr*)&srvaddr, sizeof(srvaddr))) 
    {
        perror("connect");
        return -1;
    }
    printf("connect................\n");

    /*3. 与服务器通信*/
    int ret;
    char buf[1024];
    while (1)
    {
        printf("Send: ");
        fgets(buf, sizeof(buf), stdin);
        if (0 > write(sockfd, buf, sizeof(buf)))
        {
            perror("write");
            break;
        }
    }

    /*4. 关闭套接字*/
    close(sockfd);

    return 0;
} 




*===============================================
*   文件名称：server.c
*   创 建 者：     
*   创建日期：2023年05月18日
*   描    述：
================================================*/
    
    接收方    
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <sys/un.h>

int main(int argc, char *argv[])
{ 
    /*1. 创建套接字*/
    int sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("socket");
        return -1;
    }
    printf("socket..............\n");

    /*2. 绑定本地地址*/
    struct sockaddr_un srvaddr;
	memset(&srvaddr, 0, sizeof(srvaddr));
	srvaddr.sun_family 	= AF_UNIX;  //地址族
    strcpy(srvaddr.sun_path, "mysocket");

	if (0 > bind(sockfd, (struct sockaddr*)&srvaddr, sizeof(srvaddr))) 
    {
        perror("bind");
        return -1;
    }
    printf("bind................\n");

    /*3. 设置监听套接字*/
    if (0 > listen(sockfd, 5))
    {
        perror("listen");
        return -1;
    }
    printf("listen.................\n");

    /*4. 接受客户端的连接，并生成通信套接字*/
    int connfd = accept(sockfd, NULL, NULL);
    if (connfd < 0)
    {
        perror("accept");
        return -1;
    }
    printf("accept success!\n");

    /*5. 与客户端通信*/
    int ret;
    char buf[1024];
    while (1)
    {
        memset(buf, 0, sizeof(buf));
        ret = read(connfd, buf, sizeof(buf));
        if (ret < 0)
        {
            perror("read");
            break;
        }
        else if (0 == ret)
        {
            printf("write close!\n");
            break;
        }
        printf("recv: %s\n", buf);
/*
        if (0 > write(connfd, buf, ret))
        {
            perror("write");
            break;
        }
*/
    }

    /*6. 关闭套接字*/
    close(connfd);
    close(sockfd);

    return 0;
}
孤独memories
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
vc udp通信 socket setsockopt 组播广播
06-23
文档中详细描述了VC环境下组播通信的实现方法，文档中包含程序代码，以编译通过。
【Linux网络编程】广播
C/C++软件工程师、嵌入式软件工程师、物联网研发工程师、C/C++讲师、物联网讲师、嵌入式讲师---欢迎大家一起交流(私信添加博主微信)
07-27 975
00. 目录 文章目录00. 目录01. 广播概述02. 广播地址分类03. 广播的特点04. setsockopt函数05. 程序示例06. 附录 01. 广播概述 在生活中广播无处不在，像平时在大街上卖物品的商人，在进行推广产品的时候往往都是使用一个喇叭来进行吆喝：“十块钱买不了吃亏，十块钱买不了上当，走过路过千万不要错过”，这就是广播。 那么在网络中的广播又是什么样子的呢？ 网络上的广播指：由一台主机向该主机所在子网内（同一个局域网）的所有主机发送数据的方式。如下图的 1 号主机广播给 2、3、4、
setsockopt()设置socket方法
11-29
在TCP/IP网络编程中，利用setsockopt()函数，设置套接字的属性，可以修改发送缓存，接受缓存的大小，发送等待时间...
域服务器广播消息,广播,组播和UNIX域套接字
weixin_35915828的博客
08-13 524
1.广播1.特点一对多仅能使用UDP2.概念发送方只有一个接收方则称单播如果同时发给局域网中的所有主机,成为广播只有用户数据包(使用UDP协议)套接字才能广播广播地址1.以192.168.1.0(255.255.255.0)网段为例,最大的主机地址192.168.1.255代表该网段的广播地址2.发送到该地址的数据包将被所有主机接收3.255.255.255.255在所有网段中都代表广播地址3.广...
setsockopt()用法
君君的博客
03-05 317
快速浏览4条 应用： 1.数据收发时限设置 struct timeva timeout; timeout.tv_sec=5; timeout.tv_usec=0; //接受时限 setsockopt(serversocket, SQL_SOCKET,SO_RCVTIMEO, (char*)&timeout,sizeof(timeout)); //发送时限 setsockopt(serversocket, SQL_SOCKET,SO_SNDTIMEO, (char*)&time
Linux-Unix.rar_ Windows_Unix_linux_linux can_linux 网络_套接字
09-19
Linux还支持UNIX域套接字，这是一种特殊类型的套接字，用于同一台机器上不同进程间的通信，速度较快，且无需经过网络协议栈。 在实际编程中，错误处理和套接字选项的设置也至关重要。例如，使用`setsockopt()`可以...
14-广播-组播-本地套接字.pdf
07-02
网络编程基础知识点总结 本资源摘要信息涵盖了网络编程的基础知识点，涉及到广播、组...本资源摘要信息涵盖了网络编程的基础知识点，涉及到套接字编程、epoll编程、广播编程、组播编程、网络协议基础和其他网络概念。
《Unix网络编程卷1：套接字联网API》第三版配套源码
最新发布
02-26
《Unix网络编程卷1：套接字联网API》是网络编程领域的经典之作，由W. Richard Stevens撰写。这本书深入浅出地介绍了Unix系统上的网络编程，特别是套接字（socket）编程接口。第三版配套的源码是学习该书的重要辅助...
Python 网络编程之TCP客户端/服务端功能示例【基于socket套接字】
09-18
- **设置选项**：`setsockopt()`方法用于设置套接字选项，`SO_REUSEADDR`选项允许服务器快速重启并重新绑定到同一端口，避免“端口已被占用”的问题。 - **绑定和监听**：服务端调用`bind()`方法将套接字绑定到...
windows下UDP组播（多播）发送和接收程序
09-19
组播与单播（一对一）和广播（一对所有）不同，它允许数据只发送一次，但可以被多个接收者同时接收。本篇文章将详细介绍如何使用C++实现UDP组播的发送和接收。 首先，我们需要了解UDP的基本概念。UDP是一种无连接的...
socket 编程（一） Linux UNIX域socket
wjmasd的博客
11-02 863
socket
linux 下getsockopt()和setsockopt()分析
OpenWrt/WLAN/驱动/Android/嵌入式开发总结
05-20 2334
1：在linux socket编译成中，我们经常使用如下类似的命令：        #include          /* See NOTES */        #include        int getsockopt(int sockfd, int level, int optname,void *optval, socklen_t *optlen);
MySql连接超时问题：execute error. SELECT 1 ，CommunicationsException
GetNewPerson的博客
09-08 2176
MySQL数据库一般默认的连接等待时间为28800s(即8小时)，超过8h，数据库会断开这个连接，但是应用不知道这个连接已经被数据库断开，所以链接池认为该连接是有效的，在下次请求时，连接池会把自己认为有效，但是数据库认为无效的连接分配出去，便会报错。2、延长数据库连接的超时时间，如果有较长的MySQL服务器的连接资源，线程堆积，从而导致服务器的性能下降。validationquery的作用是在连接池申请连接时进行验证，以保证连接池中的连接都是可用的。服务访问量过小，长时间不访问数据库，日志报错。
SpringCloud 微服务工作笔记：validationQuery: SELECT 1 FROM DUAL
jacky_zhuyuanlu的博客
12-22 1905
数据库validationQuery检查语句
setsockopt函数参数详解
q1449660223的博客
07-11 3684
函数原型 //函数原型 int setsockopt(SOCKET s, int level, int optname, const char* optval, int optlen); 函数参数解析: s(套接字): 指向一个打开的套接口描述字。 level:(级别)： 指定选项代码的类型。  SOL_SOCKET: 基本套接口  IPPROTO_IP: IPv4套接口  IPPROTO_IPV6: IPv6套接口  IPPROTO_TCP: TCP套接口 optname(选项名)： 选项名称。 opt
[转]setsockopt 设置socket
weixin_30919235的博客
12-28 760
转自：http://blog.csdn.net/qinmi/archive/2007/03/07/1523081.aspx 在bind前使用setsockopt的SO_REUSEADDR选项。 其实就是中文版MSDN 1.closesocket（一般不会立即关闭而经历TIME_WAIT的过程）后想继续重用该socket： BOOL bReuseaddr=TRUE; setsockop...
setsockopt设置超时需要注意
热门推荐
Wait for 的专栏
08-03 2万+
原文：http://blog.csdn.net/qinmi/article/details/1523081 1.closesocket（一般不会立即关闭而经历TIME_WAIT的过程）后想继续重用该socket： BOOL bReuseaddr=TRUE; setsockopt(s,SOL_SOCKET, SO_REUSEADDR, (const char*)&bReus
C语言socket设置超时／setsockopt函数
代码解释生活
02-21 1万+
／／======================= 在Windows下似乎操作比较简单，直接调用winsock2.h和ws2_32.lib编程 #include"stdafx.h" #include"stdio.h" #include "winsock2.h" #pragmacomment(lib, "ws2_32.lib")   设置接收超时为 nNetTimeout
UNIX网络编程卷1--591
08-08
- **获取及设置函数**：`getsockopt`和`setsockopt`用于获取和设置套接字选项，`fcntl`和`ioctl`则用于控制套接字描述符的行为。 - **套接字选项**：包括通用选项如SO_REUSEADDR允许快速重用套接字地址，TCP选项如...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

孤独memories

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值