linux设备驱动之API的实现

Linux 下API的实现

作者： 韩大卫@ 吉林师范大学

驱动工程师工作内容之一就是向上层应用端提供API，这个API完成并封装了全部的与硬件芯片的I/O操作。

本问简单的说明了一个实现API函数的全部过程。

总体上看分为：

1，用户API
2，用户中间层（与底层通信）
3，底层中间层（寻找对应的驱动函数）
4， 驱动函数
5,  CPU读写Ｉ/Ｏ端口。

我们主要的工作就是这个驱动部分

这个驱动函数功能是：将数据包装成kernel 中可操作的结构体， 按既有的通信方式发送给CPU，

这种通信方式就是通过总线了。可以是I2C等等。

最后，CPU返回执行结构，驱动函数再返回给用户层。

再将这些API 包装成库， 这样，用户层的程序就可以直接引用了。

下面的API功能是是： 统计交换芯片的接口速率。

Test/main.c 是一个测试程序， API 和API 的底层驱动的实现文件和头文件都在下面的代码中，

另外，用户层与底层之间的通信，使用的是socket ，这是相比与共享内存等最合适最高效的方式。

路径如下： 用户层ＡＰＩ--- 中间层（socket）----| -----驱动中间层（socket）---（驱动函数）

这不是完整的程序，只是程序中的骨干部分。

如果需要全部的程序，请联系作者handawei@jusontech.com

***** ********************
转载请务必表明出处。
********* ***************************
在test/main.c 中：


#include "inc/jas.h"
#include <jas_sw_cmd_api.h>
#include <jas_cmd_cli_api.h>
#include <jas_frm_cmd_api.h>




在  inc/cmd_api/jas_sw_cmd_api.h  中：


 int jas_sw_intf_cntr_rate_cal(int dev_id, int intf_id, jas_intf_eth_rate_t *cntr);   

//这就是用户层使用的ＡＰＩ

./libjascmd/jas_cmd_cli_api.h  中：

 int jas_cmd_cli_api_send_msg(struct jas_cmd_api_cmd_msg tmsg);
  int jas_cmd_cli_api_recv_msg(void *data, uint32_t size);
 


在Main.c 中的  jas_sw_intf_cntr_rate_cal（）定义在：

jas_api/switch/sw_cmd_api.c 中：



int jas_sw_intf_cntr_rate_cal(int dev_id, int intf_id, jas_intf_eth_rate_t *data){                                                   
    int ret = JAS_SUCCESS;
 
    if(data == NULL)
        return JAS_INV_ARG;
 
    ret = jas_cmd_sw_api_intf_cntr_rate_cal(dev_id, intf_id, data);
    if(ret < 0)
        return ret;
 
    return ret;
}
 

jas_cmd_sw_api_intf_cntr_rate_cal

这个函数是一个中间层，介于用户层和驱动层之间， 它的声明是在：

libjascmd/jas_cmd_sw_api.h  中：

int jas_cmd_sw_api_intf_cntr_rate_cal(uint8_t dev_id, uint8_t intf_id, jas_intf_eth_rate_t *jas_cntr_data);     



定义是在  ibjascmd/jas_cmd_sw_api.c  中：


int jas_cmd_sw_api_intf_cntr_rate_cal(uint8_t dev_id, uint8_t intf_id, jas_intf_eth_rate_t *jas_cntr_data){                          
    int ret = JAS_SUCCESS;
    struct jas_cmd_api_cmd_msg msg;
                   
    msg.dev_id = dev_id;
    msg.intf_id = intf_id;
    msg.cmd = SW_INTF_CNTR_RATE_CAL;
    msg.dev_type = JAS_CMD_SWITCH;
    
    ret = jas_cmd_cli_api_send_msg(msg);
    if (ret < 0) {
        return JAS_SET_ERROR;
    }              
    
    ret = jas_cmd_cli_api_recv_msg(jas_cntr_data, (uint32_t)sizeof(jas_intf_eth_rate_t));
    if(ret < 0) {
        return ret;
    }
                   
    return ret;    
}



通过使用socket  ，发送和接受msg . 实现与驱动层的通信。

那么，socket的接受端是在哪里？

可以通过  grep -rn  “SW_INTF_CNTR_RATE_CAL”  的方式，查找出相应的位置。

结果如下：


在libjascmd/jas_cmd_cli_api.c 中：

发现了  case SW_INTF_CNTR_RATE_CAL

进入这个文件中，  就可以找到这个socket 的接受端， 函数如下：


int jas_cmd_cli_serv_check_client(cmdStreamPTR streamP, char *buff, uint32_t length){
    socketStreamPTR stream = (socketStreamPTR)streamP;
        
    if(length == 0)
        return JAS_SUCCESS;
        
    if(strncmp(buff, "@@JAS_CMD_API", 12) == 0){
        write(stream->socket, "Connected!", 10);
        return JAS_SUCCESS;
    }   
        
    if((length != sizeof(struct jas_cmd_api_cmd_msg)) || (strncmp(buff, "########", 8) != 0)){
        sys_err("%s, %d, Get Error Buffer: %s, length: %d(%d)\n", __func__, __LINE__, buff, length, sizeof(struct                    jas_cmd_api_cmd_msg));
        return JAS_FAILURE;
    }                                                                                                                                
        
    jas_cmd_cli_serv_run_cmd(streamP, buff);
        
    return 0;
}       



进入jas_cmd_cli_serv_run_cmd

int jas_cmd_cli_serv_run_cmd(cmdStreamPTR streamP, char *buff){
    struct jas_cmd_api_cmd_msg cmsg;
    struct jas_cmd_cli_msg msg;
    socketStreamPTR stream = (socketStreamPTR)streamP;
 
    memcpy(&cmsg, buff, sizeof(cmsg));
 
    memset(&msg, 0, sizeof(struct jas_cmd_cli_msg));
    memcpy(msg.flag, "########", 8);
 
    msg.ret = JAS_SUCCESS;
    msg.len = sizeof(struct jas_cmd_cli_msg) - 8;
 
    switch(cmsg.dev_type){
    case JAS_CMD_FRAMER:
        __jas_cmd_api_run_frm_cmd(cmsg, &msg);                                                                                       
        break;
    case JAS_CMD_SWITCH:
        __jas_cmd_api_run_sw_cmd(cmsg, &msg);
        break;
    default:
        sys_err("%s, %d, Unknow Dev Type, buff: %s, cmsg.cmd: %d, cmsg.dev_id: %d.\n",
                    __func__, __LINE__, buff, cmsg.cmd, cmsg.dev_id);
        break;
    }      
           
    write(stream->socket, &msg, sizeof(struct jas_cmd_cli_msg));
    return 0;
}          



这样就清楚了，通过msg中的变量类型，进入
__jas_cmd_api_run_frm_cmd(cmsg, &msg);

或者
   __jas_cmd_api_run_sw_cmd(cmsg, &msg);

处理msg， 最后将处理后的msg通过 write(stream->socket, &msg, sizeof(struct jas_cmd_cli_msg)) 发送出去，  

这样就实现了用中间层的通信。


进入  static int __jas_cmd_api_run_sw_cmd（）看一下，

static int __jas_cmd_api_run_sw_cmd(struct jas_cmd_api_cmd_msg cmsg, struct jas_cmd_cli_msg *msg){
 
    switch(cmsg.cmd){
    case SW_HW_REG_SET:
        {
            jas_reg_t *preg = (jas_reg_t *)cmsg.data;
            msg->ret = jas_sw_drv_hw_reg_set(cmsg.dev_id, preg->regaddr, preg->value);
        }
        break;

….....

    case SW_INTF_CNTR_RATE_CAL:                                                                                                      
        {              
            jas_intf_eth_cntr_t *cntr;
            cntr = (jas_intf_eth_cntr_t *)msg->data;

            msg->ret = jas_sw_drv_intf_cntr_rate_cal(cmsg.dev_id, cmsg.intf_id, cntr);

             // 这里使用了真正的驱动函数

        }              
        break;         


….. …
    return 0;
}


这个jas_sw_drv_intf_cntr_rate_cal（）就是驱动层的相应功能实现函数。

jas_sw_drv_intf_cntr_rate_cal（）  的定于是在： libsw/sw_drv_api.c

int jas_sw_drv_intf_cntr_rate_cal(uint8_t dev_id, uint8_t intf_id, jas_intf_eth_rate_t *jas_cntr_data){
     
    jas_intf_eth_cntr_t sw_status_info1;
    jas_intf_eth_cntr_t sw_status_info2;
    int32_t result;
    uint64_t *data;
    time_t lt,lt1,lt2;
    struct tm* ptr1;
    struct tm* ptr2;
     
    memset(&sw_status_info1, 0, sizeof(sw_status_info1));
    memset(&sw_status_info2, 0, sizeof(sw_status_info2));
     
    jas_sw_drv_intf_cntr_clear_on_read_set(dev_id, intf_id, JAS_FALSE);
    jas_sw_drv_intf_cntr_get(dev_id, intf_id, &sw_status_info1);
    lt1 = time(NULL);
     
    sleep(1);
     
    jas_sw_drv_intf_cntr_clear_on_read_set(dev_id,intf_id, JAS_FALSE);
    jas_sw_drv_intf_cntr_get(dev_id, intf_id, &sw_status_info2);
    lt2 = time(NULL);   
     
    lt = lt2 - lt1;
    ptr1 = localtime(&lt1);           
    ptr2 = localtime(&lt2);           
     
  result = device_port_rate_cal(sw_status_info2.good_pkts.rx * 8,
                                sw_status_info1.good_pkts.rx * 8,
                                &(jas_cntr_data->good_pkts.rx),
                                lt);
     
    result = device_port_rate_cal(sw_status_info2.good_pkts.tx * 8,
                                sw_status_info1.good_pkts.tx * 8,
                                &(jas_cntr_data->good_pkts.tx),
                                lt);
     
    result = device_port_rate_cal(sw_status_info2.good_bytes.rx * 8,    
                                sw_status_info1.good_bytes.rx * 8,
                                &(jas_cntr_data->good_bytes.rx),
                                lt);
    result = device_port_rate_cal(sw_status_info2.good_bytes.tx * 8,    
                                sw_status_info1.good_bytes.tx * 8,
                                &(jas_cntr_data->good_bytes.tx),
                                lt);
     
    return  0;
}    



现在有一个问题：

jas_sw_drv_intf_cntr_rate_cal（）只是在sw_drv_api.c 中有定义，没有在任何.h文件中有声明，


那么在libjascmd/jas_cmd_cli_api.c  中的


case SW_INTF_CNTR_RATE_CAL:              
        {                                    
            jas_intf_eth_cntr_t *cntr;       
            cntr = (jas_intf_eth_cntr_t *)msg->data;
            msg->ret = jas_sw_drv_intf_cntr_rate_cal(cmsg.dev_id, cmsg.intf_id, cntr);                                               
        }                                    
        break;                               

jas_sw_drv_intf_cntr_rate_cal（）的声明是在 在inc/cmd_api/jas_sw_cmd_api.h 中



#include <jas_sw_cmd_api.h>

进而使用了这个函数。


这样就完成了ＡＰＩ的实现


路径如下： 用户层ＡＰＩ--- 中间层（socket）----| -----驱动中间层（socket）---（驱动函数）


详细说明如下：

用户层ＡＰＩ ：             jas_sw_intf_cntr_rate_cal（）

API的声明（头文件）：      inc/cmd_api/jas_sw_cmd_api.h
    
int jas_sw_intf_cntr_rate_cal(int dev_id, int intf_id, jas_intf_eth_rate_t *cntr);       

API的定义（实现）：        jas_api/switch/sw_cmd_api.c

int jas_sw_intf_cntr_rate_cal(int dev_id, int intf_id, jas_intf_eth_rate_t *data){                                                   
    int ret = JAS_SUCCESS;
          
    if(data == NULL)
        return JAS_INV_ARG;
          
    ret = jas_cmd_sw_api_intf_cntr_rate_cal(dev_id, intf_id, data);
    if(ret < 0)
        return ret;
          
    return ret;
}         
          



用户中间层的函数：   jas_cmd_sw_api_intf_cntr_rate_cal（）

声明（头文件）：      libjascmd/jas_cmd_sw_api.h

定义：                 libjascmd/jas_cmd_sw_api.c

int jas_cmd_sw_api_intf_cntr_rate_cal(uint8_t dev_id, uint8_t intf_id, jas_intf_eth_rate_t *jas_cntr_data){                          
    int ret = JAS_SUCCESS;
    struct jas_cmd_api_cmd_msg msg;
 
    msg.dev_id = dev_id;
    msg.intf_id = intf_id;
    msg.cmd = SW_INTF_CNTR_RATE_CAL;
    msg.dev_type = JAS_CMD_SWITCH;
 
    ret = jas_cmd_cli_api_send_msg(msg);
    if (ret < 0) {
        return JAS_SET_ERROR;
    }    
 
    ret = jas_cmd_cli_api_recv_msg(jas_cntr_data, (uint32_t)sizeof(jas_intf_eth_rate_t));
    if(ret < 0) {
        return ret;
    }
 
    return ret;
}


驱动层中间函数 ： __jas_cmd_api_run_sw_cmd

位置： libjascmd/jas_cmd_cli_api.c



 case SW_INTF_CNTR_RATE_CAL:                                                                                                      
        {              
            jas_intf_eth_cntr_t *cntr;
            cntr = (jas_intf_eth_cntr_t *)msg->data;
            msg->ret = jas_sw_drv_intf_cntr_rate_cal(cmsg.dev_id, cmsg.intf_id, cntr);
        }              
        break;         




驱动函数： jas_sw_drv_intf_cntr_rate_cal（）

声明：     inc/drv/sw_drv_api.h


定义：      libsw/sw_drv_api.c

int jas_sw_drv_intf_cntr_rate_cal(uint8_t dev_id, uint8_t intf_id, jas_intf_eth_rate_t *jas_cntr_data){
 
    jas_intf_eth_cntr_t sw_status_info1;
    jas_intf_eth_cntr_t sw_status_info2;
    int32_t result;
    uint64_t *data;
    time_t lt,lt1,lt2;
    struct tm* ptr1;
    struct tm* ptr2;
    
    memset(&sw_status_info1, 0, sizeof(sw_status_info1));
    memset(&sw_status_info2, 0, sizeof(sw_status_info2));
 
    jas_sw_drv_intf_cntr_clear_on_read_set(dev_id, intf_id, JAS_FALSE);
    jas_sw_drv_intf_cntr_get(dev_id, intf_id, &sw_status_info1);
    lt1 = time(NULL);
    
….

}                             


*************** ******************************************************


2012.7.30    14:00

遇到一个错误：

jascmd/jas_cmd_cli_api.c
libjascmd/jas_cmd_cli_api.c: In function '__jas_cmd_api_run_i2c_cmd':
libjascmd/jas_cmd_cli_api.c:335: error: 'I2C_INTF_I2C_TMP_GET' undeclared (first use in this function)
libjascmd/jas_cmd_cli_api.c:335: error: (Each undeclared identifier is reported only once
libjascmd/jas_cmd_cli_api.c:335: error: for each function it appears in.)

在jascmd/jas_cmd_cli_api.c  中明明有：
 #include "jas_cmd_i2c_api.h"    


在jascmd/jas_cmd_i2c_api.h 也有
        
typedef enum {
    I2C_INTF_I2C_TMP_GET = 0,
    I2C_INTF_I2C_RTC_GET,
    I2C_INTF_I2C_EEPROM_GET,
    I2C_INTF_I2C_SW_XFP_GET,
    I2C_INTF_I2C_SW_SFP_GET,
}jas_cmd_i2c_api_cmd_type_t;
            
但为什么说没有定义呢？
结果是：#ifdef  __JAS_CMD_I2C_API_H    
应改为：#ifndef  __JAS_CMD_I2C_API_H    

下午17：00

..//libjascmd.so: undefined reference to `jas_i2c_drv_intf_i2c_tmp_get'
..//libjascmd.so: undefined reference to `jas_i2c_drv_intf_i2c_sw_xfp_get'
..//libjascmd.so: undefined reference to `jas_i2c_drv_intf_i2c_sw_sfp_get'
..//libjascmd.so: undefined reference to `jas_i2c_drv_intf_i2c_rtc_get'
..//libjascmd.so: undefined reference to `jas_i2c_drv_intf_i2c_eeprom_get'


在Makefile 也添加了libi2c 的信息，
为什么还是找不到？

    
原来是在test 中的Makefile 没有添加li2c


**** ************************************



int jas_cmd_frm_api_intf_status_get(int dev_id, int intf_id, jas_frm_intf_status_t *status){
    int ret = JAS_SUCCESS;
    struct jas_cmd_api_cmd_msg msg;  
                       
    JAS_NULL_PTR_CHECK(status);
                       
    msg.dev_id = dev_id;
    msg.intf_id = intf_id;
    msg.cmd = FRM_INTF_STATUS_GET;
    msg.dev_type = JAS_CMD_FRAMER;  
                       
    ret = jas_cmd_cli_api_send_msg(msg);                                                                                              
    if (ret < 0) {  
        return JAS_SET_ERROR;
    }                  
                       
    ret = jas_cmd_cli_api_recv_msg(status, (uint32_t)sizeof(jas_frm_intf_status_t));
    if(ret < 0) {    
        return JAS_SET_ERROR;
    }                  
                       
    return ret;        
}  

*********** ********
jas_cmd_cli_api_send_msg 定义如下：

int jas_cmd_cli_api_send_msg(struct jas_cmd_api_cmd_msg cmsg){
    jas_cmd_cli_api_handle_t *ctrl = (jas_cmd_cli_api_handle_t *)handle;                                                              
                 
    JAS_NULL_PTR_CHECK(handle);
                 
    memcpy(cmsg.flag, "########", 8);  
                 
    if(__sock_check(ghandle[ctrl->id]->sockfd)){
        sys_err("socket %d break off.\n", ghandle[ctrl->id]->sockfd);
        close(ghandle[ctrl->id]->sockfd);
        ghandle[ctrl->id]->sockfd = 0;
        if(__reconnect(ctrl->id) != 0){  
                sys_err("Failed to reconnect server.\n");
                return JAS_SOCK_ERROR;
        }        
    }            
                 
    return write(ctrl->sockfd, &cmsg, sizeof(struct jas_cmd_api_cmd_msg));
}                



strcut  jas_cmd_cli_api_handle_t  的定义是：

typedef struct jas_cmd_api_handle{
    int id;  
    int sockfd;
    char *ip_addr;
    uint32_t port;
}jas_cmd_cli_api_handle_t;                                                                                                            
 

__sock_check() 定义如下：

static int __sock_check(int sockfd){
    fd_set fds;
    int ret;
    struct timeval tv_sel;
      
    if(sockfd == 0){
        sys_err("%s, %d, error, %s.\n", __func__, __LINE__, "SOCK FD is 0");
        return JAS_FAILURE;
    }     
          
    tv_sel.tv_sec = 0;
    tv_sel.tv_usec = 0;
    ret = select(sockfd + 1, &fds, NULL, NULL, &tv_sel);  
    if(ret != 0){
        if(ret < 0)
            sys_err("%s, %d, error, %s.\n", __func__, __LINE__, strerror(errno));
    }  /*                  
        else {   
            if(FD_ISSET(sockfd, &fds)) {
                len = read(sockfd, buf, 100);
                if(len == 0) {
                        sys_err("sockfd %d break off.\n", sockfd);
                        return -1;
                }                                                                                                                     
                sys_info("__sock_check buff: %s\n", buf);
            }    
        }           
*/      
           
    return 0;
}          
ret = select(sockfd + 1, &fds, NULL, NULL, &tv_sel);  

sockfd +1 :是指集合中所有文件描述符的范围，即所有文件描述符的最大值加1.

fds是一个文件描述符的集合，监视这些文件描述符的读变化的

第一个NULL 表示 不关心任何文件的写变化

第二个NULL 表示 不用监视文件错误异常。


时间值为0秒0毫秒，即将select()函数设置成一个纯粹的非阻塞函 数，不管文件描述符是否有变化，

都立刻返回继续执行，文件无变化返回0，有变化返回一个正值；



***************** ****

 return write(ctrl->sockfd, &cmsg, sizeof(struct jas_cmd_api_cmd_msg));


向 ctr-> sockfd 发送 cmsg, 大小为sizeof(struct jas_cmd_api_cmd_msg);


************* **********


jas_cmd_cli_api_recv_msg() 函数定义是：


int jas_cmd_cli_api_recv_msg(void *data, uint32_t size){                                                                              
    jas_cmd_cli_api_handle_t *ctrl = (jas_cmd_cli_api_handle_t *)handle;
    struct jas_cmd_cli_msg *msg = NULL;
    int len = CMD_MAX_MSG;
    int i, read_len, mlen=0;
    struct timeval timeout;
 
    JAS_NULL_PTR_CHECK(handle);
 
    timeout.tv_sec = 900;
    timeout.tv_usec = 0;
    mlen = len;
 
    read_len = __sock_read_data(ctrl->sockfd, buf_rd, &timeout, &mlen);
    if(read_len < len){
        sys_err("%s, %d, Read buffer error: \"%s\", len %d(%ld).\n", __func__, __LINE__, buf_rd, read_len, len);
        return JAS_FAILURE;
    }
 
    /*get the right msg length*/
    sys_debug("%s, %d, read buffer: \"%s\", len %d(%ld).\n", __func__, __LINE__, buf_rd, read_len, len);
    for(i = 0; i < read_len; i++){
        if(buf_rd[i] == '#'){
            if(strncmp((char *)&buf_rd[i], "########", 8) == 0){
                msg = (struct jas_cmd_cli_msg *)&buf_rd[i];
                sys_debug("print msg:\n");
                sys_debug("valid len: %d, msg ret: %d.\n",  
                        msg->len, msg->ret);
                if(msg->ret != JAS_SUCCESS){
                    sys_err("Operation failed!\n");
                    return msg->ret;
                }
                if(msg->len != (len - 8)){
                    sys_err("Get Wrong Length: %d(%d).\n",  
                            (len - 8), msg->len);
                    return JAS_FAILURE;
                }
                break;
            }
        }
   if(data != NULL)
        memcpy(data, msg->data, size);
 
    return 0;
}
 


__sock_read_data(） 定义是：


/*return length of data*/
static int __sock_read_data(int sockfd, uint8_t *buf, struct timeval *timeout, int *len){
    fd_set fds;
    int ret, mlen=0;
    struct timeval tv1, tv2, tv_sel;  
 
    if(sockfd == 0){
        sys_err("%s, %d, error, %s.\n", __func__, __LINE__, "SOCK FD is 0");
        return JAS_INV_ARG;
    }
 
    gettimeofday(&tv1, NULL);                                                                                                         
    while(1){
        gettimeofday(&tv2, NULL);
        if(((tv2.tv_sec-tv1.tv_sec)*1000000 + (tv2.tv_usec-tv1.tv_usec)) >=  
                    (timeout->tv_sec*1000000 + timeout->tv_usec)){

            return 0;
        }
 
        FD_ZERO(&fds);
        FD_SET(sockfd, &fds);
        tv_sel.tv_sec = 0;
        tv_sel.tv_usec = 100000;
        ret = select(sockfd + 1, &fds, NULL, NULL, &tv_sel);   
        if(ret != 0){
            if(ret < 0){
                sys_err("%s, %d, error, %s.\n", __func__, __LINE__, strerror(errno));
                return JAS_FAILURE;
            }
            if(FD_ISSET(sockfd, &fds)){
                mlen += read(sockfd, &buf[mlen], MSG_RD_BUF_LEN);
                sys_debug("buff: %s, len: %d.\n", buf, mlen);
                if((len != NULL) && (mlen < *len)){
                    continue;
                }
                return mlen;
            }
 
            return -1;
        }
    }
 
    return 0;
}
 

   FD_ZERO(&fds);
        FD_SET(sockfd, &fds);

FD_ZERO(&fds) 清空集合fds
FD_SET(sockfd, &fds);    将一个给定的文件描述符socket加入集合fds之中

     ret = select(sockfd + 1, &fds, NULL, NULL, &tv_sel);   

集合最大文件描述符号范围 : sockfd +1

&fds ， 监视fds 文件描述符集合。

NULL： 不关心文件写变化
NULL ：不关心文件异常

&tv_sel :  0 ： 秒  100000: 微秒/

即select在100000 微妙内内阻塞，超时时间之内有事件到来就返回了，否则在超时后不管怎样一定返回。


FD_ISSET(sockfd, &fds)      fds中的文件描述符 sockfd 是否可以读。

 mlen += read(sockfd, &buf[mlen], MSG_RD_BUF_LEN);

可以读的话，  mlen 统计 read的字节数。

__sock_read_data(ctrl->sockfd, buf_rd, &timeout, &mlen);     

函数作用是：

读取ctrl->sockfd 上的内容，放入buf_rd[] 中，&mlen 是要读取的最小长度，返回读取的字节数。


以上是用户层的ＡＰＩ 发送和接收接口函数。

********* ******************************************