网络240521-CSDN博客

本文链接：https://blog.csdn.net/a45557923/article/details/139102970

流式域套接字 TCP 服务端

#include <my_head.h>
int main(int argc, const char *argv[])
{
    //1、为通信创建一个端点
    int sfd = socket(AF_UNIX, SOCK_STREAM, 0);
    //参数1：说明使用的是 非跨主机通信
	//参数2：说明使用的是 TCP 面向连接的通信方式
    //参数3：由于参数2中已经指定通信方式，填0即可
    if(sfd == -1)
    {
        perror("socket error");
        return -1;
    }
    printf("socket success sfd = %d\n", sfd);   //3


    //判断要绑定的套接字文件是否存在？
    if(access("./unix", F_OK) == 0)
    {
        //说明文件存在，要将其删除
        if(unlink("./unix") ==-1)
        {
            perror("unlink error");
            return -1;
        }
    }


    //2、结构体
    struct sockaddr_un sun;
    sun.sun_family = AF_UNIX;    //通信域
    strcpy(sun.sun_path , "./unix");         //套接字文件路径


    //2.2 绑定工作:必须绑定一个不存在的套接字文件
    if(bind(sfd, (struct sockaddr*)&sun, sizeof(sun)) ==-1)
    {
        perror("bind error");
        return -1;
    }
    printf("bind success\n");

    

    //3、将套接字设置成被动监听状态
    if(listen(sfd, 128)==-1)
    {
        perror("listen error");
        return -1;
    }
    printf("listen success\n");

    //4、阻塞等待客户端的连接
    //4.1 定义用于接受客户端信息的容器
    struct sockaddr_un cun;
    socklen_t addrlen = sizeof(cun);

    int newfd = accept(sfd, (struct sockaddr*)&cun, &addrlen);
    if(newfd == -1)
    {
        perror("accept error");
        return -1;
    }

    printf("[%s]:发来连接请求\n", cun.sun_path);

    //5、与客户端进行相互通信
    char rbuf[128] = "";            //读取消息内容的容器

    while(1)
    {
        //清空容器
        bzero(rbuf, sizeof(rbuf));

        //从套接字中读取数据
        //int res = read(newfd, rbuf, sizeof(rbuf));
        int res = recv(newfd, rbuf, sizeof(rbuf), 0);
        if(res == 0)
        {
            printf("客户端已经下线\n");
            break;
        }

        //将读取的消息展示出来
        printf("[%s]:%s\n", cun.sun_path, rbuf);

        //将收到的消息处理一下，回复给客户端
        strcat(rbuf, "*_*");

        //讲消息发送给客户端
        //write(newfd, rbuf, strlen(rbuf));
        send(newfd, rbuf, strlen(rbuf), 0);
        printf("发送成功\n");
    }

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

流式域套接字 TCP 客户端

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

    //判断要绑定的套接字文件是否存在？
    if(access("./linux", F_OK) == 0)
    {
        //说明文件存在，要将其删除
        if(unlink("./linux") ==-1)
        {
            perror("unlink error");
            return -1;
        }
    }


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

    //2.2 绑定
    if( bind(cfd, (struct sockaddr*)&cun, sizeof(cun)) ==-1)
    {
        perror("bind error");
        return -1;
    }
    printf("bind success\n");
    
    
    
    //3、连接服务器
    //3.1 准备对端地址信息结构体
    struct sockaddr_un sun;
    sun.sun_family = AF_UNIX;
    strcpy(sun.sun_path, "./unix");

    //3.2 连接服务器
    if(connect(cfd, (struct sockaddr*)&sun, sizeof(sun))==-1)
    {
        perror("connect error");
        return -1;
    }
    printf("connect success\n");
    
    //4、数据收发
    char wbuf[128] = "";
    char rbuf[128] = "";
    while(1)
    {
        //从终端上获取要发送的数据
        fgets(wbuf, sizeof(wbuf), stdin);
        wbuf[strlen(wbuf)-1] = '\0';           //将读取的换行改成'\0'

        //将数据发送给服务器
        send(cfd, wbuf, strlen(wbuf), 0);
        printf("发送成功\n");

        //接收服务器发来的消息
        bzero(rbuf, sizeof(rbuf));

        recv(cfd, rbuf, sizeof(rbuf), 0);
        printf("服务器发来的消息为：%s\n", rbuf);
    }
    
    //5、关闭套接字
    close(cfd);

	return 0;
}

报式域套接字 UDP 服务端

#include <my_head.h>
int main(int argc, const char *argv[])
{
    int sfd = socket(AF_UNIX, SOCK_DGRAM, 0);
    if(sfd == -1)
    {
        perror("socket error");
        return -1;
    }
    printf("sfd = %d\n", sfd);            //3

    if(access("./unix", F_OK) == 0)
    {
        if(unlink("./unix") ==-1)
        {
            perror("unlink error");
            return -1;
        }
    }

    struct sockaddr_un sun;
    sun.sun_family = AF_UNIX;
    strcpy(sun.sun_path, "./unix");

    if(bind(sfd, (struct sockaddr*)&sun, sizeof(sun)) ==-1)
    {
        perror("bind error");
        return -1;
    }
    printf("bind success\n");
    
    char rbuf[128] = "";

    struct sockaddr_un cun;
    socklen_t addrlen = sizeof(cun);

    while(1)
    {
        bzero(rbuf,sizeof(rbuf));

        recvfrom(sfd, rbuf, sizeof(rbuf), 0, (struct sockaddr*)&cun, &addrlen);
        printf("[%s]：%s\n", cun.sun_path, rbuf);

        strcat(rbuf, "*_*");
        if(sendto(sfd, rbuf, strlen(rbuf), 0, (struct sockaddr*)&cun, sizeof(cun))==-1)
        {
            perror("write error");
            return -1;
        }
        printf("发送成功\n");

    }    
    close(sfd);

	return 0;
}

报式域套接字 UDP 客户端

#include <my_head.h>
int main(int argc, const char *argv[])
{
    int cfd = socket(AF_UNIX, SOCK_DGRAM, 0);
    if(cfd == -1)
    {
        perror("socket error");
        return -1;
    }
    printf("cfd = %d\n", cfd);            //3

    struct sockaddr_un cun;
    cun.sun_family = AF_UNIX;
    strcpy(cun.sun_path, "./linux");

    if(access("./linux", F_OK) == 0)
    {
        if(unlink("./linux") ==-1)
        {
            perror("unlink error");
            return -1;
        }
    }

    if(bind(cfd, (struct sockaddr*)&cun, sizeof(cun)) ==-1)
    {
        perror("bind error");
        return -1;
    }
    printf("bind success\n");
    
    char wbuf[128] = "";

    struct sockaddr_un sun;
    sun.sun_family = AF_UNIX;
    strcpy(sun.sun_path, "./unix");


    char rbuf[128] = "";

    while(1)
    {
        bzero(wbuf,sizeof(wbuf));
        bzero(rbuf, sizeof(rbuf));
        
        fgets(wbuf, sizeof(wbuf), stdin);
        wbuf[strlen(wbuf)-1] = 0;

        sendto(cfd, wbuf, strlen(wbuf), 0, (struct sockaddr*)&sun, sizeof(sun));
        printf("发送成功\n");

        recvfrom(cfd, rbuf, sizeof(rbuf), 0,NULL, NULL);
        printf("收到服务器消息为：%s\n", rbuf);

    }
    
    close(cfd);

	return 0;
}

面试题：

1.项目中如何实现TCP的并发？
2.TCP通信过程中的三次握手？
3.四次挥手的过程？
4.tcp\IP协议分几层？tcp\IP是哪一层?
5.UDP为什么丢包，怎样处理？丢包发生在哪一层？为什么？
6.TCP是同步还是异步？谈谈你对同步异步的理解？
7.什么是TCP的沾包现象，如何解决？
8.组播和广播的区别？
9.阻塞IO和非阻塞IO的区别？
10.并发和并行的区别？

未完成