网络编程学习

最新推荐文章于 2024-09-14 21:53:48 发布

苟盛儿

最新推荐文章于 2024-09-14 21:53:48 发布

阅读量378

点赞数 8

文章标签：学习

本文链接：https://blog.csdn.net/H_oUmU/article/details/136463277

版权

思维导图

代码练习

多点通信

广播

广播的发送端

#include<myhead.h>

int main(int argc, const char *argv[])
{
    //1、创建套接字
    int sfd = socket(AF_INET, SOCK_DGRAM, 0);
    if(sfd == -1)
    {
        perror("socket error");
        return -1;
    }
    
    //2、设置当前套接字允许广播属性
    int broadcast = 1; 
    if(setsockopt(sfd, SOL_SOCKET, SO_BROADCAST, &broadcast, sizeof(broadcast))==-1)
    {
        perror("setsockopt error");
        return -1;
    }

    
    //3、绑定（可选）
    
    //4、填充接收端地址信息结构体
    struct sockaddr_in sin;
    sin.sin_family = AF_INET;
    sin.sin_port = htons(8888);
    sin.sin_addr.s_addr = inet_addr("192.168.125.255");
    
    //5、发送数据
    char sbuf[128] = "";
    while(1)
    {
        printf("请输入>>>");
        fgets(sbuf, sizeof(sbuf), stdin);
        sbuf[strlen(sbuf)-1] = 0;

        sendto(sfd, sbuf, strlen(sbuf), 0, (struct sockaddr*)&sin, sizeof(sin));

        printf("发送成功\n");
    }
    
    //6、关闭
    close(sfd);

    return 0;
}

广播的接收端

#include<myhead.h>

int main(int argc, const char *argv[])
{
    //1、创建套接字
    int rfd = socket(AF_INET, SOCK_DGRAM, 0);
    if(rfd == -1)
    {
        perror("socket error");
        return -1;
    }
    printf("rfd = %d\n", rfd);        //3

    //2、填充地址信息结构体
    struct sockaddr_in rin;
    rin.sin_family = AF_INET;     //地址族
    rin.sin_port = htons(8888);       //端口号
    rin.sin_addr.s_addr = inet_addr("192.168.125.255");  //广播地址

    //3、绑定
    if(bind(rfd, (struct sockaddr*)&rin, sizeof(rin)) == -1)
    {
        perror("bind error");
        return -1;
    }

    //4、接收广播消息
    char rbuf[128] = "";
    while(1)
    {
        //清空内容
        bzero(rbuf, sizeof(rbuf));

        //读取消息
        recv(rfd, rbuf, sizeof(rbuf), 0);

        printf("收到消息：%s\n", rbuf);
    }

    //5、关闭套接字
    close(rfd);

    return 0;
}

组播

组播的发送端

#include<myhead.h>

int main(int argc, const char *argv[])
{
    //1、创建套接字
    int rfd = socket(AF_INET, SOCK_DGRAM, 0);
    if(rfd == -1)
    {
        perror("socket error");
        return -1;
    }

    //2、绑定端口号和ip地址
    //填充地址信息结构体
    struct sockaddr_in rin;
    rin.sin_family = AF_INET;
    rin.sin_port = htons(9999);
    rin.sin_addr.s_addr = inet_addr("192.168.125.205");

    //绑定端口号和IP
    if(bind(rfd, (struct sockaddr*)&rin, sizeof(rin)) == -1)
    {
        perror("bind error");
        return -1;
    }

    //3、发送消息
    //填充接收端地址信息结构体
    struct sockaddr_in sin;
    sin.sin_family = AF_INET;
    sin.sin_port = htons(8888);
    sin.sin_addr.s_addr = inet_addr("224.1.2.3");

    char sbuf[128] = "";
    while(1)
    {
        printf("请输入>>>");
        fgets(sbuf, sizeof(sbuf), stdin);
        sbuf[strlen(sbuf)-1] = 0;

        //向组播地址中发送消息
        sendto(rfd, sbuf, strlen(sbuf), 0, (struct sockaddr*)&sin, sizeof(sin));
        printf("发送成功\n");
    }
    

    //4、关闭
    close(rfd);

    return 0;
}

组播的接收端

#include<myhead.h>

int main(int argc, const char *argv[])
{
    //1、创建套接字
    int rfd = socket(AF_INET, SOCK_DGRAM, 0);
    if(rfd == -1)
    {
        perror("socket error");
        return -1;
    }
    printf("rfd = %d\n", rfd);        //3

    //设置加入多播族
    struct ip_mreqn imr;
    imr.imr_multiaddr.s_addr = inet_addr("224.1.2.3");  //组播ip
    imr.imr_address.s_addr = inet_addr("192.168.125.205"); //本地ip
    imr.imr_ifindex = 2;        //网卡编号

    if(setsockopt(rfd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &imr, sizeof(imr)) == -1)
    {
        perror("setsockopt error");
        return -1;
    }




    //2、填充地址信息结构体
    struct sockaddr_in rin;
    rin.sin_family = AF_INET;     //地址族
    rin.sin_port = htons(8888);       //端口号
    rin.sin_addr.s_addr = inet_addr("224.1.2.3");  //组播地址

    //3、绑定
    if(bind(rfd, (struct sockaddr*)&rin, sizeof(rin)) == -1)
    {
        perror("bind error");
        return -1;
    }

    //4、接收组播消息
    char rbuf[128] = "";
    while(1)
    {
        //清空内容
        bzero(rbuf, sizeof(rbuf));

        //读取消息
        recv(rfd, rbuf, sizeof(rbuf), 0);

        printf("收到消息：%s\n", rbuf);
    }

    //5、关闭套接字
    close(rfd);


    return 0;
}

域套接字

流式域套接字

服务器端实现

#include <myhead.h>
int main(int argc, const char *argv[])
{
	//１、创建套接字
	int sfd = socket(AF_UNIX,SOCK_STREAM,0);
	if(sfd == -1)
	{
		perror("socket error");
		return -1;
	}
	//
	//判断套接字文件是否存在，如果存在则需要删除
	if(access("./musocket",F_OK)==0)
	{
		//说明存在，将该文件删除
		if(unlink("./mysocket")==-1)
		{
			perror("unlink error");
			return -1;
		}
	}
	//
	//２、绑定套接字文件
	//２.１填充地址信息结构体
	struct sockaddr_un sun;
	sun.sun_family=AF_UNIX;
	strcpy(sun.sun_path,"./mysocket");

	//２，２绑定
	if(bind(sfd,(struct sockaddr*)&sun,sizeof(sun))==-1)
	{
		perror("bind error");
		return -1;


	}
	printf("bind succrss\n");
	//３、监听
	if(listen(sfd,128)==-1)
	{
		perror("listen error");
		return -1;
	}
	printf("listen succrss\n");
	//４、阻塞等待客户端连接请求
	struct sockaddr_un cun;
	socklen_t socklen = sizeof(cun);

	int newfd = -1;
	if((newfd = accept(afd,(struct sockaddr*)&cun,&socklen))==-1)
	{
		perror("accept error");
		return -1;
	}
	printf("有新客户发来连接请求\n");
	//５、数据收发
	char rbuf[128]="";
	while(1)
	{
		//清空
		bzero(rbuf,sizeof(rbuf));
		//收取数据
		recv(newfd,rbuf,sizeof(rbuf),0);
		printf("[%s]:%s\n",cun.sun_path,rbuf);
		//连接一个表情回复
		strcat(rbuf,"O_o");
		//发送回去
		send(newfd,rbuf,strlen(rbuf),0);
		printf("发送成功\n");


	}
	//６、关闭套接字
	close(sfd);
	close(newfd);
	
	return 0;
}

客户端实现

#include <myhead.h>
//#define SER_IP "192.168.152.135"
//#define SER_PORT 8910
int main(int argc, const char *argv[])
{
	//１创建用于监听的套接字
	int sfd = -1;
	sfd =socket(AF_INET,SOCK_STREAM,0);
	if(sfd==-1)
	{
		perror("socket error");
		return -1;
	}
	printf("sfd = %d\n",sfd);
	//将端口号快速重用
	int reuse =1;
	if(setsockopt(sfd,SOL_SOCKET,SO_REUSEADDR,&reuse,sizeof(reuse))==-1)
	{
		perror("setsockopt error");
		return -1;
	}
	printf("端口号快速重用成功\n");

	//２绑定ip地址和端口号
	struct sockaddr_in sin;
	sin.sin_family = AF_INET;
	sin.sin_port = htons(SER_PORT);
	sin.sin_addr.s_addr = inet_addr(SER_IP);


	if(bind(sfd,(struct sockaddr*)&sin,sizeof(sin))==-1)
	{
		perror("bind error");
		return -1;
	}
	printf("bind success\n");
	//３启动监听允许客户端连接
	
	if(listen(sfd,128)==-1)
	{
		perror("listen error");
		return -1;

	}
	printf("listen success\n");

	//４当有客户端发来连接请求后创建新的用于通信的套接字
	struct sockaddr_in cin;
	socklen_t socklen = sizeof(cin);
	int newfd = accept(sfd,(struct sockaddr*)&cin,&socklen);
	if(newfd==-1)
	{
		perror("accept error");
		return -1;
	}
	printf("newfd = %d 您有一个新的客户已经上线\n",newfd);
	printf("客户端IP:%s,端口号为:%d\n",inet_ntoa(cin.sin_addr),ntohs(cin.sin_port));
	//５通信套接字与客户端进行数据收发
	char rbuf[128]="";
	while(1)
	{
		bzero(rbuf,sizeof(rbuf));
		int res =read(newfd,rbuf,sizeof(rbuf));
		if(res==0)
		{
			printf("客户端已经下线\n");
			break;
		}
		printf("[%s:%d]:%s\n",inet_ntoa(cin.sin_addr),ntohs(cin.sin_port),rbuf);
		strcat(rbuf," O_o");
		write(newfd,rbuf,strlen(rbuf));

	}
	//６关闭套接字
	close(newfd);
	close(sfd);
	return 0;
}

报式域套接字

服务器端实现

#include<myhead.h>

int main(int argc, const char *argv[])
{
    //1、创建用于通信的套接字
    int sfd = socket(AF_UNIX, SOCK_DGRAM, 0);
    if(sfd == -1)
    {
        perror("socket error");
        return -1;
    }
    printf("sfd = %d\n", sfd);           //3

    //判断套接字文件是否存在，如果存在则需要删除
    if(access("./linux1", F_OK) == 0)
    {
        //说明存在，将该文件删除
        if(unlink("./linux1") == -1)
        {
            perror("unlink error");
            return -1;
        }
    }


    //2、绑定IP地址和端口号
    //2.1填充地址信息结构体
    struct sockaddr_un sun;
    sun.sun_family = AF_UNIX;          //地址族
    strcpy(sun.sun_path, "./linux1");

    //2,2绑定
    if(bind(sfd, (struct sockaddr*)&sun, sizeof(sun)) == -1)
    {
        perror("bind error");
        return -1;
    }
    printf("bind success\n");

    //3、收发数据
    char rbuf[128] = "";

    //定义容器接收对端地址信息结构体
    struct sockaddr_un cun;
    socklen_t socklen = sizeof(cun);

    while(1)
    {
        //清空数组
        bzero(rbuf, sizeof(rbuf));

        //接收数据
        recvfrom(sfd, rbuf, sizeof(rbuf), 0, (struct sockaddr*)&cun, &socklen);

        printf("收到消息为：%s\n", rbuf);

        //将消息加个笑脸回过去
        strcat(rbuf, "*_*");
        if(sendto(sfd, rbuf, strlen(rbuf), 0, (struct sockaddr*)&cun, socklen) == -1)
        {
            perror("sendto error");
            return -1;
        }
        
    }

    //4、关闭套接字
    close(sfd);

    return 0;
}

客户端实现

#include<myhead.h>
int main(int argc, const char *argv[])
{
    //1、创建用于通信的套接字
    int cfd = socket(AF_UNIX, SOCK_DGRAM, 0);
    if(cfd == -1)
    {
        perror("socket error");
        return -1;
    }
    printf("cfd = %d\n", cfd);           //3


    //判断套接字文件是否存在，如果存在则需要删除
    if(access("./linux2", F_OK) == 0)
    {
        //说明存在，将该文件删除
        if(unlink("./linux2") == -1)
        {
            perror("unlink error");
            return -1;
        }
    }

    //2、绑定IP地址和端口号(如果要接收服务器消息必须绑定)
    struct sockaddr_un cun;
    cun.sun_family = AF_UNIX;
    strcpy(cun.sun_path, "./linux2");

    if(bind(cfd, (struct sockaddr*)&cun, sizeof(cun))==-1)
    {
        perror("bind error");
        return -1;
    }


    //3、收发数据
    char wbuf[128] = "";

    //定义容器，记录服务器的地址信息结构体
    struct sockaddr_un sun;
    sun.sun_family = AF_UNIX;
    strcpy(sun.sun_path,"./linux1");

    while(1)
    {
        //清空数组
        bzero(wbuf, sizeof(wbuf));

        //从终端获取数据
        printf("请输入>>>");
        fgets(wbuf, sizeof(wbuf), stdin);
        wbuf[strlen(wbuf)-1] = 0;

        //将数据发送给服务器
        sendto(cfd, wbuf, sizeof(wbuf), 0, (struct sockaddr*)&sun, sizeof(sun));
        
        printf("发送成功\n");

        //接收服务器回复的消息
        bzero(wbuf, sizeof(wbuf));

        recvfrom(cfd, wbuf, sizeof(wbuf), 0, NULL, NULL);
        printf("收到消息为：%s\n", wbuf);
    }

    //4、关闭套接字
    close(cfd);

    return 0;
}