Exemple #1
0
static int crl_cert_request_2_file(struct cmp_db* cmdb,int fd){
    u8 *mbuf,*buf;
    int needlen = sizeof(time32) + 8 + sizeof(crl_series) +
        2*sizeof(cmh);
    if( (buf = (u8*)malloc(needlen)) == NULL){
        wave_error_printf("分配失败");
        return -1;
    }
    mbuf = buf;
    pthread_mutex_lock(&cmdb->lock);
    ptr_host_to_be(mbuf,cmdb->crl_request_issue_date);
    memcpy(mbuf,cmdb->crl_request_issuer.hashedid8,8);
    mbuf += 8;
    ptr_host_to_be(mbuf,cmdb->crl_request_crl_series);
    ptr_host_to_be(mbuf,cmdb->req_cert_cmh);
    ptr_host_to_be(mbuf,cmdb->req_cert_enc_cmh);
    pthread_mutex_unlock(&cmdb->lock);
    if( write(fd,buf,needlen) != needlen){
        wave_error_printf("写入失败");
        goto fail;
    }
    free(buf);
    return needlen;
fail:
    free(buf);
    return -1;
}
Exemple #2
0
static int file_2_lsis_array(struct cmp_db* cmdb,int fd){
    u32 len;
    int i;
    if(file_2_len(&len,fd) ){
        wave_error_printf("读取失败");
        return -1;
    }
    pthread_mutex_lock(&cmdb->lock);
    cmdb->req_cert_lsises.len = len;
    cmdb->req_cert_lsises.lsis = (pssme_lsis*)malloc(sizeof(pssme_lsis) * len);
    if(cmdb->req_cert_lsises.lsis == NULL){
        pthread_mutex_unlock(&cmdb->lock);
        wave_error_printf("分配空间失败");
        return -1;
    }
    for(i=0;i<len;i++){
        if(file_2_element(fd,cmdb->req_cert_lsises.lsis+i,sizeof( pssme_lsis))  ){
            wave_error_printf("读取文件失败");
            free(cmdb->req_cert_lsises.lsis);
            pthread_mutex_unlock(&cmdb->lock);
            return -1;
        }
    }
    pthread_mutex_unlock(&cmdb->lock);
    return 0;
}
Exemple #3
0
int dot2_init_netlink(struct nlmsghdr *nlh, struct msghdr *msg){
    int ret =0;
	struct confirm_content *confirm;
    struct wme_dot2_pid_request req;

    req.type = DOT2_PID;
    req.operat = SET_MIB;
    req.pid = getpid();

    int fd = create_netlink(msg, nlh);
    if(fd < 0){
        wave_error_printf("fd创建失败");
        return -1;
    }
    memcpy(NLMSG_DATA(nlh), &req, sizeof(struct wme_generic_service_request));
    ret = sendmsg(fd, msg, 0);
	perror(strerror(errno));
    if(ret < 0){
        wave_error_printf("netlink发送消息失败");
        return -1;
    }
	memset(nlh, 0, NLMSG_SPACE(MAX_PAYLOAD));
	ret = recvmsg(fd, msg, 0);
	if(ret < 0){
		wave_error_printf("netlink recvmsg error");
		return -1;
	}
	confirm = (struct confirm_content*)NLMSG_DATA(nlh);
	if(confirm->result != RES_ACCPTED){
		wave_error_printf("zhu ce fail!");
		return -1;
	}
	nlh->nlmsg_len = NLMSG_SPACE(MAX_PAYLOAD);
    return fd;
}
Exemple #4
0
static int file_2_ca_cert(struct cmp_db* cmdb,int fd){
    u8* buf = NULL;
    u32 len = 400;//预估cerficate有多大。
    u32 size;
    buf = (u8*)malloc(len);
    if(buf == NULL){
        wave_error_printf("内存分配失败");
        return -1;
    }
    pthread_mutex_lock(&cmdb->lock);
    if( file_2_element(fd,&cmdb->ca_cmh,sizeof(cmdb->ca_cmh))){
        pthread_mutex_unlock(&cmdb->lock);
        return -1;
    }

    if( (size = read(fd,buf,len)) < 0 ){
        wave_error_printf("读取失败");
        pthread_mutex_unlock(&cmdb->lock);
        return -1;
    }
    if(buf_2_certificate(&cmdb->ca_cert,buf,size)){
        certificate_free(&cmdb->ca_cert);
        wave_error_printf("cmpd证书读取失败");
        pthread_mutex_unlock(&cmdb->lock);
        return -1;
    }
    pthread_mutex_unlock(&cmdb->lock);
    return 0;
}
Exemple #5
0
/*************
 *这里的所有编码原则,都是固定长度,我们固定编码。
 *其他数组或者链表之类的我们就用4字节表示后面有多少字节。
 ************/
static int cert_2_file(struct cmp_db* cmdb,int fd){
    u8 *mbuf,*buf;
    int needlen,size = 0;
    buf = NULL;
    needlen = 500;//预估一下有多长.
    buf =(u8*)malloc(needlen);
    if(buf == NULL)
        goto fail;
    mbuf = buf;
    pthread_mutex_lock(&cmdb->lock);
    ptr_host_to_be(mbuf,cmdb->ca_cmh);
    size = certificate_2_buf(&cmdb->ca_cert,mbuf,needlen-size);
    if(size < 0){
        pthread_mutex_unlock(&cmdb->lock);
        wave_error_printf("证书编码的时候错误了");
        goto fail;
    }
    size += sizeof(cmdb->ca_cmh);
    pthread_mutex_unlock(&cmdb->lock);
    if(write(fd,buf,size) != size){
        wave_error_printf("写入文件发生错误");
        goto fail;
    }
    free(buf);
    return 0;
fail:
    if(buf != NULL)
        free(buf);
    return -1;
}
Exemple #6
0
/**
 * 所有的长度都用四字节编码
 */
static int crl_req_time_list_2_file(struct cmp_db* cmdb,int fd){
    struct list_head *head;
    struct crl_req_time* ptr;
    u32 size,temp;
    
    size = 0;
    pthread_mutex_lock(&cmdb->lock);
    head = &cmdb->crl_time.list;
    list_for_each_entry(ptr,head,list){
        if( (temp = crl_req_time_2_file(ptr,fd)) < 0){
            wave_printf_fl(MSG_ERROR,"crl_req_time_2_file 失败");
            pthread_mutex_unlock(&cmdb->lock);
            return -1;
        }
        size +=1;
    }
    pthread_mutex_unlock(&cmdb->lock);
    size = host_to_be32(size);
    if( file_insert(fd,0,&size,4) ){
        wave_error_printf("文件插入出错");
        return -1;
    }
    if ( lseek(fd,4,SEEK_CUR) == -1){
        wave_error_printf("文件移动偏移量出问题");
        return -1;
    }
    return 1;
}
Exemple #7
0
static int file_2_crl_req_time_list(struct cmp_db* cmdb,int fd){
    u32 len;
    struct crl_req_time *node;
    struct list_head* head = NULL;
    int i;
    if ( file_2_len(&len,fd)){
        wave_error_printf("长度读取失败");
        return -1;
    }
    pthread_mutex_lock(&cmdb->lock);
    head  = &cmdb->crl_time.list;
    for(i=0;i<len;i++){
        node = file_2_crl_req_time(fd);
        if(node == NULL){
            pthread_mutex_unlock(&cmdb->lock);
            goto fail;
        }
        list_add_tail(&node->list,head);
    }
    pthread_mutex_unlock(&cmdb->lock);
    return 0;
fail:
   if(head != NULL){
        while( !list_empty(head)){
            node = list_entry(head->next,struct crl_req_time,list);
            list_del(&node->list);
            free(node);
            node = NULL;
        }
   } 
   return -1;
}
Exemple #8
0
static int inline file_2_len(u32* len,int fd){
    if(read(fd,len,4) != 4){
        wave_error_printf("读取长度失败");
        return -1;
    }
    *len = be_to_host32(*len);
    return 0;
}
Exemple #9
0
int create_netlink(struct msghdr *msg, struct nlmsghdr *nlh)
{
    int fd;
    struct sockaddr_nl src_addr, *dest_addr;
    struct iovec *iov = NULL;
	iov = (struct iovec *)malloc(sizeof(*iov));
	dest_addr = (struct sockaddr_nl*)malloc(sizeof(struct sockaddr_nl));
	if(!dest_addr || !iov){
		wave_malloc_error();
		return -1;
	}
    //NETLINK_WAVE是需要和.3的模块统一的,需要在linux/netlink.h中添加一个新的协议类型 21
    fd = socket(PF_NETLINK, SOCK_RAW, NETLINK_WAVE);
    if(fd < 0){
        wave_error_printf("创建fd失败");
        return -1;
    }
    memset(&src_addr, 0, sizeof(struct sockaddr_nl));
    src_addr.nl_family = AF_NETLINK;
    src_addr.nl_pid = getpid(); /* self pid */
    src_addr.nl_groups = 0; /* not in mcast groups */
    if(bind(fd, (struct sockaddr*)&src_addr, sizeof(struct sockaddr_nl)) < 0){
        wave_error_printf("绑定失败");
        return -1;
    }
    memset(dest_addr, 0, sizeof(struct sockaddr_nl));
    dest_addr->nl_family = AF_NETLINK;
    dest_addr->nl_pid = 0; /* For Linux Kernel */
    dest_addr->nl_groups = 0; /* unicast */
    /* Fill the netlink message header */
    nlh->nlmsg_len = NLMSG_SPACE(MAX_PAYLOAD);
    nlh->nlmsg_pid = getpid(); /* self pid */
    nlh->nlmsg_flags = 0;
    /* Fill in the netlink message payload */
	memset(iov, 0, sizeof(*iov));
    iov->iov_base = (void *)nlh;
    iov->iov_len = nlh->nlmsg_len;
    msg->msg_name = (void *)dest_addr;
    msg->msg_namelen = sizeof(struct sockaddr_nl);
    msg->msg_iov = iov;
    msg->msg_iovlen = 1;
    return fd;
}
Exemple #10
0
static int file_2_crl_cert(struct cmp_db* cmdb,int fd){
    pthread_mutex_lock(&cmdb->lock);
    if( file_2_element(fd,&cmdb->crl_request_issue_date,sizeof(time32)) ){
        wave_error_printf("读取数据错误");
        goto fail;
    }
    if( read(fd,&cmdb->crl_request_issuer.hashedid8,8) != 8){
        wave_error_printf("读取数据错误");
        goto fail;
    }
    if( file_2_element(fd,&cmdb->crl_request_crl_series,sizeof(crl_series)) ||
            file_2_element(fd,&cmdb->req_cert_cmh,sizeof(cmh)) ||
            file_2_element(fd,&cmdb->req_cert_enc_cmh ,sizeof(cmh)) ){
        wave_error_printf("读取数据失败");
        goto fail;
    }
    pthread_mutex_unlock(&cmdb->lock);
    return 0;
fail:
    pthread_mutex_unlock(&cmdb->lock);
    return -1;
}
Exemple #11
0
/**
 * 这个是固定长度,我们编码成固定长度
 */
static int crl_req_time_2_file(struct crl_req_time* ptr,int fd){
    int needlen ;
    u8 *buf,*obuf;
    needlen = sizeof(time32) + 8 +sizeof(crl_series) + sizeof(time32);
    if( (buf = (u8*)malloc(needlen)) == NULL) {
        wave_error_printf("空间分配失败");
        return -1;
    }
    obuf = buf;
    ptr_host_to_be(buf,ptr->time);
    memcpy(buf,&ptr->issuer.hashedid8,8);
    buf +=8;
    ptr_host_to_be(buf,ptr->crl_series);
    ptr_host_to_be(buf,ptr->issue_date);
    if( write(fd,obuf,needlen) != needlen){
        free(obuf);
        wave_error_printf("写入失败");
        return -1;
    }
    free(obuf);
    return 1;
}
Exemple #12
0
static struct crl_req_time* file_2_crl_req_time(int fd){
    struct crl_req_time* crt =NULL;
    time32 time;
    u8 issuer[8];
    crl_series crl_series;
    time32 issue_date;
    crt = (struct crl_req_time*)malloc(sizeof(struct crl_req_time));
    if(crt == NULL){
        wave_error_printf("内存分配失败");
        return NULL;
    }
    if(file_2_element(fd,&crt->time,sizeof(time32)) ||
            read(fd,crt->issuer.hashedid8,8) != 8||
            file_2_element(fd,&crt->crl_series,sizeof(crl_series))  ||
            file_2_element(fd,&crt->issue_date,sizeof(issue_date)) ){
        wave_error_printf("文件读取失败");
        goto fail;
    }
    return crt;
fail:
    if(crt != NULL)
        free(crt);
    return NULL;
}
Exemple #13
0
static int file_2_cmp_db(struct cmp_db* cmdb,const char* name){
    int fd;
    if( (fd = open(name,O_RDONLY)) <0){
        wave_error_printf("文件 %s 打开失败\n",name);
        close(fd);
        return -2;
    }
    if( file_2_crl_req_time_list(cmdb,fd) ||
            file_2_crl_cert(cmdb,fd) ||
            file_2_lsis_array(cmdb,fd) ||
            file_2_others(cmdb,fd) ||
            file_2_ca_cert(cmdb,fd)){
        close(fd);
        return -1;
    }
    close(fd);
    return 0;
}
Exemple #14
0
int wave_start(){
    struct sec_db* sdb;
    int res;
    sdb = init_sec_db();
    if(sdb == NULL){
        return -1;
    }
    if(atexit(wave_exit_fun)){
        wave_error_printf("注册退出程序失败");
        return -1;
    }
    if(wme_serv_start(sdb))
        return -1;
    if(wave_cmp_start(sdb))
        return -1;
    if( app_start(sdb))
        return -1;
    return 0;
}
Exemple #15
0
static int inline file_2_element(int fd,void* ele,int size){
    if(read(fd,ele,size) != size){
        wave_error_printf("读取长度失败");
        return -1;
    }
     switch(size){
        case 1:
            *(u8*)ele = *(u8*)ele;
            break;
        case 2:
            *(u16*)ele = be_to_host16( *(u16*)ele );
            break;
        case 4:
            *(u32*)ele = be_to_host32( *(u32*)ele );
            break;
        case 8:
            *(u64*)ele = be_to_host64( *(u64*)ele );
            break;
    }
    return 0;
}
Exemple #16
0
static void* wme_loop(void* sdb){
    //启动netlink,
    int i = 0;
    int recv_data_len = 0;//接收到的整个数据报文的长度
    char sbuf[MAX_PAYLOAD];//发送报文缓冲区
    char rbuf[MAX_PAYLOAD];//接收报文缓冲区
    struct nlmsghdr nlh;
    struct msghdr msg;
    result ret;
    /*
     * 签名请求需要用到的参数
     * */
    struct wme_tobe_signed_wsa s_head;//接收到的需要签名报文头部
    struct dot3_signed_wsa s_wsa;
    int permission_len = 0;//permission部分报文的长度
    struct permission per;
    string unsigned_wsa;//接收到的wsa数据部分
    serviceinfo_array permissions;//需要填充的permission数组
    time32 life_time;

    string signed_wsa;
    /*
     * 验证请求需要用到的参数
     * */
    struct dot2_tobe_verified_wsa v_head;//接收到的需要验证的报文头部
    struct verified_wsa v_wsa;//验证成功需要发送给内核的报文头部
    string unverified_wsa;

    result_array results;
    string wsa_data;
    ssp_array ssp_array;
    time64_with_standard_deviation generation_time;
    time64 expiry_time;
    three_d_location location;
    struct time32_array last_crl_time;
    struct time32_array next_crl_time;
    certificate cert;

    int fd = dot2_init_netlink(&nlh, &msg);
    if(fd < 0){
        wave_error_printf("netlink初始化失败");
        return;
    }
    while(1){
        memset((char*)NLMSG_DATA(&nlh), 0, MAX_PAYLOAD);
        memset(rbuf, 0, MAX_PAYLOAD);

        ret = recvmsg(fd, &msg, 0);
        if(ret < 0){
            wave_error_printf("接收netlink消息失败");
            goto destructor;
        }
        recv_data_len = nlh.nlmsg_len;
        memcpy(rbuf, NLMSG_DATA(&nlh), recv_data_len);

        //解析报文
        char *shift = rbuf;
        //0为签名
        if(*shift = 0){
            INIT(permissions);
            INIT(unsigned_wsa);
            INIT(signed_wsa);
            INIT(s_head);
            INIT(s_wsa);

            memcpy(&s_head, shift, RECV_S_HEAD_LEN);
            life_time = s_head.lifetime;
            shift += RECV_S_HEAD_LEN;

            unsigned_wsa.len = s_head.wsa_len;
            unsigned_wsa.buf = malloc(unsigned_wsa.len);
            if(!unsigned_wsa.buf){
                wave_malloc_error();
                goto destructor;
            }
            memcpy(unsigned_wsa.buf, shift, unsigned_wsa.len);
            shift += unsigned_wsa.len;

            permission_len = recv_data_len - RECV_S_HEAD_LEN - unsigned_wsa.len;

            permissions.len = 0;
            permissions.serviceinfos = malloc(sizeof(serviceinfo)*32);//分配32个为最大的长度
            while(permission_len > 0){
                memcpy(&per, shift, 4);
                shift += 4;

                memcpy(&permissions.serviceinfos[permissions.len].max_priority, &per.priority, 1);

                permissions.serviceinfos[permissions.len].psid = psidn2h(shift, per.psid_len);

                if(per.ssp_len > 0){
                    permissions.serviceinfos[permissions.len].ssp.len = per.ssp_len;
                    permissions.serviceinfos[permissions.len].ssp.buf = malloc(per.ssp_len);
                    if(!permissions.serviceinfos[permissions.len].ssp.buf){
                        wave_malloc_error();
                        goto destructor;
                    }
                    memcpy(permissions.serviceinfos[permissions.len].ssp.buf, shift, per.ssp_len);
                }
                else{
                    permissions.serviceinfos[permissions.len].ssp.len = 0;
                    permissions.serviceinfos[permissions.len].ssp.buf = NULL;
                }
                shift += per.ssp_len;
                
                if(per.pssi_len > 4){
                    wave_error_printf("lsis太长");
                    goto destructor;
                }
                permissions.serviceinfos[permissions.len].lsis = 0;
                for(i = 0; i < per.pssi_len; i++){
                    permissions.serviceinfos[permissions.len].lsis += (*shift)*256;
                    shift++;
                }
                permissions.len++;
                permission_len = permission_len - per.psid_len - per.ssp_len - per.pssi_len - 4;
            }
            ret = sec_signed_wsa(&sec_db, &unsigned_wsa, &permissions, life_time, &signed_wsa);
            memset((char*)NLMSG_DATA(&nlh), 0, MAX_PAYLOAD);
            memset(sbuf, 0, MAX_PAYLOAD);
            if(ret == SUCCESS){
                s_wsa.wsa_len = signed_wsa.len;
                s_wsa.broadcast = s_head.broadcast;
                s_wsa.change_count = s_head.change_count;
                s_wsa.channel = s_head.channel;
                s_wsa.result_code = DOT2_SIGN_SUCCESS;
                memcpy(sbuf, &s_wsa, sizeof(struct signed_wsa));
                memcpy(sbuf+sizeof(struct signed_wsa), signed_wsa.buf, signed_wsa.len);

                memcpy(NLMSG_DATA(&nlh), sbuf, signed_wsa.len+sizeof(struct signed_wsa));
            }
            else{
                wave_error_printf("签名失败");
                s_wsa.wsa_len = 0;
                s_wsa.broadcast = s_head.broadcast;
                s_wsa.change_count = s_head.change_count;
                s_wsa.channel = s_head.channel;
                s_wsa.result_code = DOT2_SIGN_FAILURE;
                memcpy(sbuf, &s_wsa, sizeof(struct signed_wsa));
                memcpy(NLMSG_DATA(&nlh), sbuf, signed_wsa.len+sizeof(struct signed_wsa));
            }
            if(sendmsg(fd, &msg, 0) < 0){
                wave_error_printf("发送消息给内核失败了");
                goto destructor;
            }
        }
        //验证
        else if(*shift == 1){
            memcpy(&v_head, shift, RECV_V_HEAD_LEN);
            shift += RECV_V_HEAD_LEN;

            INIT(unverified_wsa);
            INIT(results);
            INIT(wsa_data);
            INIT(ssp_array);
            INIT(generation_time);
            INIT(expiry_time);
            INIT(location);
            INIT(last_crl_time);
            INIT(next_crl_time);
            INIT(cert);

            unverified_wsa.len = v_head.wsa_len;
            unverified_wsa.buf = malloc(v_head.wsa_len);
            if(!unverified_wsa.buf){
                wave_malloc_error();
                goto destructor;
            }
            memcpy(unverified_wsa.buf, shift, v_head.wsa_len);

            memset((char*)NLMSG_DATA(&nlh), 0, MAX_PAYLOAD);
            memset(sbuf, 0, MAX_PAYLOAD);
            ret = sec_signed_wsa_verification(&sec_db, &unverified_wsa, &results, &wsa_data, &ssp_array, &generation_time,
                    &expiry_time, &location, &last_crl_time, &next_crl_time, &cert);
            if(ret == SUCCESS){
                v_wsa.pid = getpid();
                memcpy(v_wsa.src_mac, v_head.src_mac, 6);
                v_wsa.rcpi = v_head.rcpi;
                v_wsa.result_code[0] = DOT2_SUCCESS;
                v_wsa.result_code[1] = DOT2_SUCCESS;
                for(i = 0; i < results.len; i++){
                    if(results.result[i] == UNSECURED){
                        v_wsa.result_code[1] = DOT2_UNSECURED;
                        break;
                    }
                }
                v_wsa.wsa_len = wsa_data.len; 
                v_wsa.gen_time = generation_time.time;
                v_wsa.expire_time = expiry_time;
                v_wsa.ssp_len = 0;
                v_wsa.next_crl_time_len = next_crl_time.len*sizeof(time32);

                memcpy(sbuf, &v_wsa, sizeof(struct verified_wsa));
                memcpy(sbuf+sizeof(struct verified_wsa), wsa_data.buf, wsa_data.len);

                char *ssp_shift = sbuf + sizeof(struct verified_wsa) + wsa_data.len;
                for(i = 0; i < ssp_array.len; i++){
                    if(ssp_array.ssps[i].len != 0){
                        memcpy(ssp_shift, ssp_array.ssps[i].buf, ssp_array.ssps[i].len);
                        ssp_shift += ssp_array.ssps[i].len;
                        v_wsa.ssp_len += ssp_array.ssps[i].len;
                    }
                    else{
                        *ssp_shift = '\0';
                        ssp_shift++;
                        v_wsa.ssp_len++;
                    }
                }

                memcpy(ssp_shift, next_crl_time.times, sizeof(time32)*next_crl_time.len);
                memcpy(NLMSG_DATA(&nlh), sbuf, sizeof(struct verified_wsa)+v_wsa.wsa_len+v_wsa.ssp_len+v_wsa.next_crl_time_len);
            }
            else if(ret == INVALID_INPUT){
                v_wsa.pid = getpid();
                memcpy(v_wsa.src_mac, v_head.src_mac, 6);
                v_wsa.rcpi = v_head.rcpi;
                v_wsa.result_code[0] = DOT2_INVALID_INPUT;
                v_wsa.result_code[1] = DOT2_INVALID_INPUT;
                v_wsa.wsa_len = 0; 
                v_wsa.gen_time = 0;
                v_wsa.expire_time = 0;
                v_wsa.ssp_len = 0;
                v_wsa.next_crl_time_len = 0;

                memcpy(sbuf, &v_wsa, sizeof(struct verified_wsa));
                memcpy(NLMSG_DATA(&nlh), sbuf, sizeof(struct verified_wsa));
            }
            else{
                v_wsa.pid = getpid();
                memcpy(v_wsa.src_mac, v_head.src_mac, 6);
                v_wsa.rcpi = v_head.rcpi;
                v_wsa.result_code[0] = DOT2_OTHER_FALURE;
                v_wsa.result_code[1] = DOT2_OTHER_FALURE;
                for(i = 0; i < results.len; i++){
                    if(results.result[i] == UNSECURED){
                        v_wsa.result_code[1] = DOT2_UNSECURED;
                        break;
                    }
                }
                v_wsa.wsa_len = wsa_data.len; 
                v_wsa.gen_time = generation_time.time;
                v_wsa.expire_time = expiry_time;
                v_wsa.ssp_len = 0;
                v_wsa.next_crl_time_len = next_crl_time.len*sizeof(time32);

                memcpy(sbuf, &v_wsa, sizeof(struct verified_wsa));
                memcpy(sbuf+sizeof(struct verified_wsa), wsa_data.buf, wsa_data.len);
                memcpy(NLMSG_DATA(&nlh), sbuf, sizeof(struct verified_wsa)+v_wsa.wsa_len);
            }
            if(sendmsg(fd, &msg, 0) < 0){
                wave_error_printf("发送消息给内核失败了");
                goto destructor;
            }
        }
        else
            wave_error_printf("不支持的dot3请求类型");
destructor:
        string_free(&unsigned_wsa);
        string_free(&signed_wsa);
        serviceinfo_array_free(&permissions);
        string_free(&unverified_wsa);
        string_free(&wsa_data);
        ssp_array_free(&ssp_array);
        result_array_free(&results);
        time32_array_free(&last_crl_time);
        time32_array_free(&next_crl_time);
        certificate_free(&cert);
    }
}
Exemple #17
0
static int others_2_file(struct cmp_db* cmdb,int fd){
    u8  *mbuf,*buf=NULL;
    int needlen,i;
    pthread_mutex_lock(&cmdb->lock);
    needlen =   cmdb->identifier.len + 4+
                sizeof(cmdb->region.region_type)+sizeof(u32);
    switch(cmdb->region.region_type){
        case FROM_ISSUER:
        case CIRCLE:
            needlen += sizeof(s32)*2 + sizeof(u16);
            break;
        case RECTANGLE:
            needlen = needlen + cmdb->region.u.rectangular_region.len * (sizeof(s32)*4) +  4;
            break;
        case POLYGON:
            needlen = needlen + cmdb->region.u.polygonal_region.len * (sizeof(s32) *2) + 4;
            break;
        case NONE:
            needlen = needlen + 4 + cmdb->region.u.other_region.len;
            break;
        default:
            pthread_mutex_unlock(&cmdb->lock);
            goto fail;
    }
    buf = (u8*)malloc(needlen);
    if(buf == NULL){
        pthread_mutex_unlcok(&cmdb->lock);
        goto fail;
    }
    mbuf = buf;
    *(u32*)mbuf = host_to_be32(cmdb->identifier.len);
    mbuf += 4;
    memcpy(mbuf,cmdb->identifier.buf,cmdb->identifier.len);
    mbuf += cmdb->identifier.len;

    ptr_host_to_be(mbuf,cmdb->region.region_type);
    switch(cmdb->region.region_type){
        case FROM_ISSUER:
        case CIRCLE:
            ptr_host_to_be(mbuf,cmdb->region.u.circular_region.center.latitude);
            ptr_host_to_be(mbuf,cmdb->region.u.circular_region.center.longitude);
            ptr_host_to_be(mbuf,cmdb->region.u.circular_region.radius);
            break;
        case RECTANGLE:
            ptr_host_to_be(mbuf,(u32)(cmdb->region.u.rectangular_region.len));
            for(i=0;i<cmdb->region.u.rectangular_region.len;i++){
                ptr_host_to_be(mbuf,(cmdb->region.u.rectangular_region.buf+i)->north_west.latitude);
                ptr_host_to_be(mbuf,(cmdb->region.u.rectangular_region.buf+i)->north_west.longitude);
                ptr_host_to_be(mbuf,(cmdb->region.u.rectangular_region.buf+i)->south_east.latitude);
                ptr_host_to_be(mbuf,(cmdb->region.u.rectangular_region.buf+i)->south_east.longitude);
            }
            break;
        case POLYGON:
            ptr_host_to_be(mbuf,(u32)(cmdb->region.u.polygonal_region.len));
            for(i=0;i<cmdb->region.u.polygonal_region.len;i++){
                ptr_host_to_be(mbuf,(cmdb->region.u.polygonal_region.buf+i)->latitude);
                ptr_host_to_be(mbuf,(cmdb->region.u.polygonal_region.buf+i)->longitude);
            }
            break;
        case NONE:
            *(u32*)mbuf = host_to_be32(cmdb->region.u.other_region.len);
            mbuf += 4;
            memcpy(mbuf,cmdb->region.u.other_region.buf,cmdb->region.u.other_region.len);
            break;
        default:
            pthread_mutex_unlock(&cmdb->lock);
            goto fail;
    }
    ptr_host_to_be(mbuf,cmdb->life_time);
    pthread_mutex_unlock(&cmdb->lock);
    if ( write(fd,buf,needlen) != needlen){
        wave_error_printf("文件写入失败");
        goto fail;
    }
    free(buf);
    return 0;
fail:
    if(buf != NULL)
        free(buf);
    return -1;
}
Exemple #18
0
static int file_2_others(struct cmp_db* cmdb,int fd){
    u32 len,i;
    if( file_2_len(&len,fd)){
        return -1;
    }
    pthread_mutex_lock(&cmdb->lock);
    cmdb->identifier.len = len;
    cmdb->identifier.buf = (u8*)malloc(len);
    if(cmdb->identifier.buf == NULL){
        wave_error_printf("分配失败");
        pthread_mutex_unlock(&cmdb->lock);
        return -1;
    }
    if( read(fd,cmdb->identifier.buf,len) != len){
        wave_error_printf("读取文件失败");
        pthread_mutex_unlock(&cmdb->lock);
        return -1;
    }
    if(file_2_element(fd,&cmdb->region.region_type,sizeof(cmdb->region.region_type))){
        pthread_mutex_unlock(&cmdb->lock);
        return -1;
    }
    switch(cmdb->region.region_type){
        case FROM_ISSUER:
        case CIRCLE:
            if( file_2_element(fd,&cmdb->region.u.circular_region.center.latitude,
                        sizeof(cmdb->region.u.circular_region.center.latitude)) ||
                file_2_element(fd,&cmdb->region.u.circular_region.center.longitude,
                    sizeof(cmdb->region.u.circular_region.center.longitude)) ||
                file_2_element(fd,&cmdb->region.u.circular_region.radius,
                    sizeof(cmdb->region.u.circular_region.radius))){
                wave_error_printf("读取文件失败");
                pthread_mutex_unlock(&cmdb->lock); 
                return -1;      
            }
            break;
        case RECTANGLE:
            if ( file_2_len(&len,fd) ){
                pthread_mutex_unlock(&cmdb->lock);
                return -1;
            }
            cmdb->region.u.rectangular_region.len = len;
            cmdb->region.u.rectangular_region.buf = (struct rectangular_region*)malloc(
                   sizeof(struct rectangular_region) * len);
            if(cmdb->region.u.rectangular_region.buf == NULL){
                wave_error_printf("内存空间分配失败");
                pthread_mutex_unlock(&cmdb->lock);
                return -1;
             }
             for(i=0;i<len;i++){
                if( file_2_element(fd,&((cmdb->region.u.rectangular_region.buf+i)->north_west.latitude),sizeof(s32)) ||
                        file_2_element(fd,&((cmdb->region.u.rectangular_region.buf+i)->north_west.longitude),sizeof(s32)) ||
                        file_2_element(fd,&((cmdb->region.u.rectangular_region.buf+i)->south_east.latitude),sizeof(s32)) ||
                        file_2_element(fd,&((cmdb->region.u.rectangular_region.buf+i)->south_east.longitude),sizeof(s32))){ 
                    free(cmdb->region.u.rectangular_region.buf);
                    wave_error_printf("读取文件失败");
                    pthread_mutex_unlock(&cmdb->lock);
                    return -1;
                }
            }
            break;
        case POLYGON:
            if( file_2_len(&len,fd) ){
                pthread_mutex_unlock(&cmdb->lock);
                return -1;
            }
            cmdb->region.u.polygonal_region.len = len;
            cmdb->region.u.polygonal_region.buf = (two_d_location*)malloc(sizeof(two_d_location) * len);
            if(cmdb->region.u.polygonal_region.buf == NULL){
                wave_error_printf("内存分配失败");
                pthread_mutex_unlock(&cmdb->lock);
                return -1;
            }
            if( file_2_element(fd,&(cmdb->region.u.polygonal_region.buf + i)->latitude,sizeof(s32)) ||
                        file_2_element(fd,&(cmdb->region.u.polygonal_region.buf+i)->longitude,sizeof(s32) )){
                free(cmdb->region.u.polygonal_region.buf);
                wave_error_printf("读取文件失败");
                pthread_mutex_unlock(&cmdb->lock); 
                return -1;      
            }
            break;
        case NONE:
            if( file_2_len(&len,fd) ){
                pthread_mutex_unlock(&cmdb->lock);
                return -1;
            }
            cmdb->region.u.other_region.len = len;
            cmdb->region.u.other_region.buf = (u8*)malloc(len);
            if(cmdb->region.u.other_region.buf == NULL){
                wave_error_printf("内存分配失败");
                pthread_mutex_unlock(&cmdb->lock);
                return -1;
            }
            if( read(fd,cmdb->region.u.other_region.buf,len) != len){
                free(cmdb->region.u.other_region.buf);
                wave_error_printf("读取文件失败");
                pthread_mutex_unlock(&cmdb->lock);
                return -1;
            }
            break;
        default:
            pthread_mutex_unlock(&cmdb->lock);
            return -1;
    }

    if(file_2_element(fd,&cmdb->life_time,sizeof(cmdb->life_time))){
        wave_error_printf("读取文件失败");
        pthread_mutex_unlock(&cmdb->lock);
        return -1;
    } 
    pthread_mutex_unlock(&cmdb->lock);
    return 0;
}