鸿蒙源码解析（二）

刺骨的言语ヽ痛彻心扉 2022-08-31 15:15 170阅读 0赞

## auth\_conn\_manager.c代码分析 ##

###### 相关头文件定义和调用和变量初始化均已经在上一篇博客中解释，本篇主要分析auth\_conn\_manager.c文件中主要函数定义代码 ######

**（路径：模块一\\communication\_softbus\_lite- master\\trans\_service\\source\\libdistbus\\auth\_conn\_manager.c）**

我们可以注意到代码中静态函数的定义很多，静态函数在开发中有以下几种作用。  
**static定义静态函数：**  
1.静态函数只能在声明它的文件中可见，其他文件不能引用该函数。  
2.不同的文件可以使用相同名字的静态函数，互不影响。  
3.非静态函数可以在另一个文件中直接引用，甚至不必使用extern声明

## 代码标注部分 ##

###### 这一部分主要是一个函数保持g\_maxFd值为最大，和初始化listen的函数 ######

static void RefreshMaxFd(int fd)
    { 
        if (fd > g_maxFd) { 
            g_maxFd = fd;/*简单的最大值更新函数*/
        }
    }
    /*RefreshMaxFd函数用来刷新最大值，将g_maxFd的值不断更新为最大*/
    
    /*InitListenFd函数用来初始化listen配置，是网络编程中的重要环节*/
    static int InitListenFd(const char *ip, int port)/*参数传递为设备ip和设备接入端口*/
    { 
        if (ip == NULL || g_listenFd != -1) { 
            return -DBE_BAD_PARAM;
        }
    
        if (strncmp(ip, "0.0.0.0", strlen(ip)) == 0) { /*判断ip是否为0.0.0.0，如果是则返回-DBE_BAD_PARAM*/
        //strncmp用来比较两个字符串的指定长度内的内容，相同返回0，不相同返回非零。
        //返回整数值：当str1<str2时，返回值<0； 当str1=str2时，返回值=0； 当str1>str2时，返回值>0。
            return -DBE_BAD_PARAM;
        }
    
        int rc = OpenTcpServer(ip, port);
        // OpenTcpServer函数打开TCP服务器，参数传递为ip和端口号
        //如果打开成功，函数返回值为非零值
        if (rc < 0) { 
            SOFTBUS_PRINT("[TRANS] InitListenFd OpenTcpServer fail\n");
            return rc;
            //如果rc小于零输出打开TCP服务器失败的提示信息
        }
        g_listenFd = rc;
        RefreshMaxFd(g_listenFd);
    	//改变监听编号g_listenFd的值并刷新g_maxfd的值
        rc = listen(rc, DEFAULT_BACKLOG);
        /*listen函数是基本TCP客户端/服务器程序的套接字函数*/
        if (rc != 0) { 
            SOFTBUS_PRINT("[TRANS] InitListenFd listen fail\n");
            /*如果listen函数执行失败。软总线输出失败信息*/
            StopListener();/*停止监听函数listen套接字函数的调用*/
            return -DBE_LISTEN_FAIL;/*返回失败值：300+41*/
        }
        return DBE_SUCCESS;
        /*初始化listen成功，返回成功值DBE_SUCCESS=0*/
    }

###### 这里面是一些和设备进程相关的函数，用来获取当前进程所有者的信息和等待进程。 ######

/*使用一个静态的布尔函数，返回值为True和False*/
    static bool ProcessAuthData(int listenFd, const fd_set *readSet)//fd_set是一组文件描述字(fd)的集合。
    /*该函数用来获取当前进程所有者的信息*/
    { 
        if (readSet == NULL || g_callback == NULL || g_callback->onConnectEvent == NULL ||
            g_callback->onDataEvent == NULL) { 
            return false;
            //回调g_callback和该链表所关联事件为空和所连接的数据文件为空或者文件描述符集合readset为空、返回False
        }
        if (FD_ISSET(listenFd, readSet)) { //套接字结合操作宏 
            struct sockaddr_in addrClient = { 0};
            socklen_t addrLen = sizeof(addrClient);
            g_dataFd = accept(listenFd, (struct sockaddr *)(&addrClient), &addrLen);//accept函数指定服务端去接受客户端的连接，接收后，返回了客户端套接字的标识，且获得了客户端套接字的“地方”
            //accept函数的第一个参数用来标识服务端套接字(也就是listen函数中设置为监听状态的套接字)
            //第二个参数是用来保存客户端套接字对应的“地方”（包括客户端IP和端口信息等）
            //第三个参数是“地方”的占地大小。返回值对应客户端套接字标识。
    
            //accept函数执行成功则返回非负整数，执行失败则返回一个负值
            if (g_dataFd < 0) { 
                CloseAuthSessionFd(listenFd);
                return false;
            }
            //如果accept函数执行失败，关闭listenFd描述符对应文件
            RefreshMaxFd(g_dataFd);
            //传入g_dataFd刷新g_maxFd的值，保持g_maxFd为最大
    
            if (g_callback->onConnectEvent(g_dataFd, inet_ntoa(addrClient.sin_addr)) != 0) { 
                CloseAuthSessionFd(g_dataFd);
                //如果g_callback->onConnectEvent中对应的描述符g_dataFd和ip不为零，则关闭g_dataFd对应的文件
            }
        }
    
        if (g_dataFd > 0 && FD_ISSET(g_dataFd, readSet)) { 
            g_callback->onDataEvent(g_dataFd);
        //如果g_dataFd为正值，并且FD_ISSET检查g_dataFd在readSet这个描述符集合里面，则将g_dataFd写入g_callback->onDataEvent
        }
    
        return true;
    }
    static void WaitProcess(void)/*静态函数，用来等待进程*/
    { 
        SOFTBUS_PRINT("[TRANS] WaitProcess begin\n");
        //开始创建进程输出
        fd_set readSet;
        fd_set exceptfds;
        //定义两个文件描述字(fd)的集合类型的变量
        while (1) { 
            FD_ZERO(&readSet); //将你的套节字集合readSet清空 
            FD_ZERO(&exceptfds);//将你的套节字集合exceptfds清空 
            FD_SET(g_listenFd, &readSet);//检查g_listenFd是否在readSet集合中
            if (g_dataFd >= 0) { 
                FD_SET(g_dataFd, &readSet);
                FD_SET(g_dataFd, &exceptfds);
            }
            int ret = select(g_maxFd + 1, &readSet, NULL, &exceptfds, NULL);//select函数用来监视文件描述符的变化
            //返回值：>0：就绪描述字的正数目 -1：出错 0 ：超时
            if (ret > 0) { //ret>0说明select监视成功
                if (!ProcessAuthData(g_listenFd, &readSet)) { /*该函数用来获取当前进程所有者的信息*/
                //如果获取失败，则进行友好输出信息并且停止listener
                    SOFTBUS_PRINT("[TRANS] WaitProcess ProcessAuthData fail\n");
                    StopListener();
                    break;
                }
            } else if (ret < 0) { //ret<0说明select监视失败
                if (errno == EINTR || (g_dataFd > 0 && FD_ISSET(g_dataFd, &exceptfds))) { 
                    SOFTBUS_PRINT("[TRANS] errno == EINTR or g_dataFd is in exceptfds set.\n");
                    CloseAuthSessionFd(g_dataFd);
                    //关闭AuthSession（用户会话），函数相关说明见下面函数定义
                    continue;
                }
                SOFTBUS_PRINT("[TRANS] WaitProcess select fail, stop listener\n");
                StopListener();
                //停止listener，关闭g_listenFd和g_maxFd对应的文件
                break;
            }
        }
    }

###### 这里面使用条件编译开始执行listen功能、开启用户会话、关闭用户会话以及相应文件和停止listen功能的函数。 ######

/*这里使用条件编译，检查__LITEOS_M__和__LITEOS_RISCV__是否存在，如果存在则调用else之前的内容，否则调用else和endif之间的内容*/
    #if defined(__LITEOS_M__) || defined(__LITEOS_RISCV__)
    int StartListener(BaseListener *callback, const char *ip)
    { 
        if (callback == NULL || ip == NULL) { 
            return -DBE_BAD_PARAM;
        }
    
        g_callback = callback;
    //如果回调变量和ip有一个为空则返回-DBE_BAD_PARAM
        int rc = InitListenFd(ip, SESSIONPORT);
        if (rc != DBE_SUCCESS) { //这个if用来判断初始化函数是否执行成功
            return -DBE_BAD_PARAM;
        }
        
        osThreadAttr_t attr;
        attr.name = "trans_auth_task";
        attr.attr_bits = 0U;
        attr.cb_mem = NULL;
        attr.cb_size = 0U;
        attr.stack_mem = NULL;
        attr.stack_size = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
        attr.priority = osPriorityNormal5; // LOSCFG_BASE_CORE_TSK_DEFAULT_PRIO -> cmsis prio
    
        g_uwTskLoID = osThreadNew((osThreadFunc_t)WaitProcess, NULL, &attr);
        if (NULL == g_uwTskLoID) { 
            SOFTBUS_PRINT("[TRANS] StartListener task create fail\n");
            return -1;
        }
    
        SOFTBUS_PRINT("[TRANS] StartListener ok\n");
        return GetSockPort(g_listenFd);
        //GetSockPort将获得一个与socket相关的地址，服务器端可以通过它得到相关客户端地址，而客户端也可以得到当前已连接成功的socket的ip和端口。
        //最后返回是一个16位数由网络字节顺序转换为主机字节顺序
    }
    #else
    #define MIN_STACK_SIZE 0x8000
    static pthread_key_t g_localKey = 0; //定义一个线程变量g_localKey
    typedef void *(*Runnable)(void *argv);
    typedef struct ThreadAttr ThreadAttr;
    struct ThreadAttr { //定义一个结构体类型
        const char *name;   // name of the thread
        uint32_t stackSize;   // size of stack
        uint8_t priority;     // initial thread priority
        uint8_t reserved1;    // reserved1 (must be 0)
        uint16_t reserved2;   // reserved2 (must be 0)
    };
    typedef void *ThreadId;
    
    ThreadId AuthCreate(Runnable run, const ThreadAttr *attr)/*创建auth权限*/
    { 
        pthread_attr_t threadAttr;
        pthread_attr_init(&threadAttr);
        pthread_attr_setstacksize(&threadAttr, (attr->stackSize | MIN_STACK_SIZE));
        struct sched_param sched = { attr->priority};
        pthread_attr_setschedparam(&threadAttr, &sched);
        pthread_key_create(&g_localKey, NULL);
        pthread_t threadId = 0;
        int errCode = pthread_create(&threadId, &threadAttr, run, NULL);
        if (errCode != 0) { 
            return NULL;
        }
        return (ThreadId)threadId;
        //返回一个结构体变量threadId
    }
    
    int StartListener(BaseListener *callback, const char *ip)
    { 
        if (callback == NULL || ip == NULL) { 
            return -DBE_BAD_PARAM;
        }
        //如果回调变量和ip有一个为空则返回-DBE_BAD_PARAM
        g_callback = callback;
    
        int rc = InitListenFd(ip, SESSIONPORT);//调用函数，初始化监听listen
        if (rc != DBE_SUCCESS) { //这个if用来判断初始化函数是否执行成功
            return -DBE_BAD_PARAM;//初始化失败则返回-DBE_BAD_PARAM = -300+0
        }
    
        signal(SIGPIPE, SIG_IGN);//为指定的信号安装一个新的信号处理函数。
        ThreadAttr attr = { "auth", 0x800, 20, 0, 0};
        register ThreadId threadId = (ThreadId)AuthCreate((Runnable)WaitProcess, &attr);
        if (threadId == NULL) { //如果返回值为NULL，说明创建失败
            SOFTBUS_PRINT("[TRANS] StartListener AuthCreate fail\n");
            return -1;
            //返回值-1，并且输出相关信息
        }
        return GetSockPort(g_listenFd); 
        //GetSockPort将获得一个与socket相关的地址，服务器端可以通过它得到相关客户端地址，而客户端也可以得到当前已连接成功的socket的ip和端口。
        //最后返回是一个16位数由网络字节顺序转换为主机字节顺序
     
    }
    #endif
    
    // close auth Session must use this function.
    void CloseAuthSessionFd(int fd)
    { 
        if (fd == g_listenFd) { 
            CloseFd(g_listenFd);
            g_listenFd = -1;
        }
        //如果传入的参数等于监听套接字描述字g_listenfd,则关闭该参数对应的描述符对应的文件
        if (fd == g_dataFd) { 
            CloseFd(g_dataFd);
            g_dataFd = -1;
            g_maxFd = g_listenFd;
        }
         //如果传入的参数等于监听套接字描述字g_datafd,则关闭该参数对应的描述符对应的文件
    }
    /*关闭身份验证会话*/
    void StopListener(void)
    { 
        CloseAuthSessionFd(g_listenFd);
        CloseAuthSessionFd(g_dataFd);
    }
    //该函数用来关闭监听

###### 以上为 ######