遇银
遇银

TLS双向认证,三级证书链

  1. 服务器
/**
 *  Filename: server.c
 *   Created: 2019-09-19 11:15:30
 *      Desc: TODO (some description)
 *    Author: hair-man 
 *   Company: owner 
 */

#include 
#include 
#include 
#include 
#include 
#include 

#include 
#include 
#include 


#include 
#include 

#include 
#include 

#define USETLS


#define MAX_EPOLL_EVENTS 1000000
#define MAX_BUFFER_SIZE  65536 

//static __attribute__((unused))char* version = "VERSION"VERSION;

typedef struct _ssl_ctx_context
{
    int fd;
    SSL* ssl;
}scontext_t;


/* 证书打印信息 */
void ShowCerts(SSL *ssl)
{
    X509 *cert;
    char *line;

    cert = SSL_get_peer_certificate(ssl);
    if (cert != NULL)
    {
        printf("数字证书信息:\n");
        line = X509_NAME_oneline(X509_get_subject_name(cert), 0, 0);
        printf("证书: %s\n", line);
        free(line);

        line = X509_NAME_oneline(X509_get_issuer_name(cert), 0, 0);
        printf("颁发者: %s\n", line);
        free(line);
        X509_free(cert);
    }
    else
    {
        printf("无证书信息！\n");
    }
}

int verify_callback(int ok, X509_STORE_CTX *ctx)
{
    printf("\r\n ok = %d\r\n", ok);
    if (!ok) 
    {
        ok = 1;
    }
    return (ok);
}

SSL_CTX* init_ssl_ctx(int verify_client)
{
    SSL_CTX *ctx = NULL;
    int ret_err = 0;

    ctx = SSL_CTX_new(SSLv23_server_method());
    if (ctx == NULL)
    {
        ERR_print_errors_fp(stderr);
        fprintf(stderr, "SSL_CTX_new failed!\n");
        return NULL;
    }

#define SERVER_CERT     "third_cert/server.crt"
#define SERVER_KEY      "third_cert/ca.key"
#define SERVER_CA_CERT  "third_cert/ca.crt"

    /* 加载服务器证书 */
    ret_err = SSL_CTX_use_certificate_file(ctx, SERVER_CA_CERT, SSL_FILETYPE_PEM);
    if (ret_err <= 0)
    {
        ERR_print_errors_fp(stderr);
        fprintf(stderr, "SSL_CTX_use_certificate_file failed!\n");
        return NULL;
    }

    /* 加载证书链 */
    ret_err = SSL_CTX_use_certificate_chain_file(ctx, SERVER_CA_CERT);
    if (ret_err <= 0)
    {
        ERR_print_errors_fp(stderr);
        fprintf(stderr, "SSL_CTX_use_certificate_chain_file failed!\n");
        return NULL;
    }

    /* 加载服务器密钥 */
    ret_err = SSL_CTX_use_PrivateKey_file(ctx, SERVER_KEY, SSL_FILETYPE_PEM);
    if (ret_err <= 0)
    {
        ERR_print_errors_fp(stderr);
        fprintf(stderr, "SSL_CTX_use_PrivateKey_file failed!\n");
        return NULL;
    }

    /* 检查私钥与证书是否匹配 */
    if (!SSL_CTX_check_private_key(ctx))
    {
        ERR_print_errors_fp(stderr);
        fprintf(stderr, "SSL_CTX_check_private_key failed!\n");
        return NULL;
    }

    if(1 == verify_client)   /* 双向认证 */
    {
        /* 加载根证书 */
        ret_err = SSL_CTX_load_verify_locations(ctx, SERVER_CA_CERT, NULL);
        if (ret_err <= 0)
        {
            ERR_print_errors_fp(stderr);
            fprintf(stderr, "SSL_CTX_load_verify_locations failed!\n");
            return NULL;
        } 

        SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, verify_callback);
        SSL_CTX_set_verify_depth(ctx, 2);
    }
    else    /* 单向认证 */
    {
        SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, NULL);
    }

    //设置单双向认证
    //SSL_VERIFY_NONE
    //作为服务器：服务器不会向客户端询问客户端证书
    //作为客户端：服务器会向客户端发送一个证书，不关心校验结果
    //SSL_VERIFY_PEER
    //作为服务器：服务器向客户端询问客户端证书，并检查，验证失败则终止
    //作为客户端：检查服务求发来的证书，验证失败则终止
    //
    //
    //
    //下面两个标志必须与SSL_VERIFY_PEER联合使用
    //SSL_VERIFY_FAIL_IF_NO_PEER_CERT
    //作为服务器有效：客户端如果不发送证书则表示验证失败，终止
    //SSL_VERIFY_CLIENT_ONCE
    //作为服务器有效：尽在初始TLS握手时请求客户端证书，重新协商不需要客户端证书
    
    //双向 - 让客户端发送客户端证书并进行验证
    //SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT, NULL);

    //单向 - 不需要客户端发送证书
    //SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, NULL);




    return ctx;
}

int readn(int fd, uint8_t* buffer, int n)
{
    int nleft = n;
    int nread = 0;

    while(nleft > 0)
    {
        if((nread = read(fd, buffer + nread, nleft)) == -1)
        {
            if(errno == EINTR)
                nread = 0;
            else
                return -1;
        }
        else if(nread == 0)
            break;

        nleft -= nread;
    }

    return n - nleft;
}

int writen(int fd, uint8_t* buffer, int n)
{
    int nleft = n;
    int nwrite = 0;

    while(nleft > 0)
    {
        if((nwrite = write(fd, buffer + nwrite, nleft)) <= 0)
        {
            if(errno == EINTR)
                nwrite = 0;
            else
                return -1;
        }

        nleft -= nwrite;
    }

    return n;
}

int set_nonblock(int fd)
{
    int block_mode = 0;

    //设置非阻塞模式
    block_mode = fcntl(fd, F_GETFL);
    if(block_mode < 0)
    {
        fprintf(stderr, "get block mode failed!Error:%d ErrMsg:%s\n", errno, strerror(errno));
        return -1;
    }

    block_mode = O_NONBLOCK | block_mode;
    if(fcntl(fd, F_SETFL, block_mode) < 0)
    {
        fprintf(stderr, "set block mode failed!Error:%d ErrMsg:%s\n", errno, strerror(errno));
        return -1;
    }

    return 0;
}


//ip - 网络序
//port - 主机序
int init_socket(int *sockfd, uint32_t ip, uint16_t port)
{
    int val = 1;
    int ret_err = 0;
    int sndmem = 1024*1024;
    int rcvmem = 1024*1024;

    struct sockaddr_in my_addr;

    *sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if(*sockfd < 0)
    {
        fprintf(stderr, "socket failed.\n");
        return -1;
    }
    //设置端口复用
    ret_err = setsockopt(*sockfd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));
    if (ret_err)
    {
        fprintf(stderr, "set reuse addr failed.\n");
        close(*sockfd);
        *sockfd = -1;
        return -1;
    }

    bzero(&my_addr, sizeof(my_addr));
    my_addr.sin_family = AF_INET;
    my_addr.sin_port = htons(port);
    my_addr.sin_addr.s_addr = ip;
    ret_err = bind(*sockfd, (struct sockaddr *)&my_addr, sizeof(my_addr));
    if(ret_err)
    {
        fprintf(stderr, "bind failed. ip: %s port: %d\n", inet_ntoa(*(struct in_addr *)&ip), port);
        close(*sockfd);
        *sockfd = -1;
        return -1;
    }
    else
        fprintf(stderr, "bind success. ip: %s port: %d\n", inet_ntoa(*(struct in_addr *)&ip), port);


    if(0 != setsockopt(*sockfd, SOL_SOCKET, SO_RCVBUF, (const char*)&rcvmem, sizeof(int)))
    {
        fprintf(stderr, "setsockopt SO_RCVBUF failed. ip: %s port: %d\n", inet_ntoa(*(struct in_addr *)&ip), port);
    }
    
    if(0 != setsockopt(*sockfd, SOL_SOCKET, SO_SNDBUF, (const char*)&sndmem, sizeof(int)))
    {
        fprintf(stderr, "setsockopt SO_SNDBUF failed. ip: %s port: %d\n", inet_ntoa(*(struct in_addr *)&ip), port);
    }

    if(listen(*sockfd, 32) != 0)
    {
        fprintf(stderr, "listen socket tcp fd failed! Error:%d ErrMsg:%s\n", errno, strerror(errno));
        return -1;
    }

#if 1
    /* 非阻塞 */
    if(0 != set_nonblock(*sockfd))
    {
        printf("set nonblock failed!\n");
        return -1;
    }
#endif


    return 0;
}

int add_epoll_fd(int efd, int fd, uint32_t events, void* user_data)
{
    struct epoll_event ev;

    ev.events = events;
    ev.data.ptr = (void *)user_data;
    if(epoll_ctl(efd, EPOLL_CTL_ADD, fd, &ev) == -1) 
    {   
        fprintf(stderr, "epoll_ctl ADD failed! efd:%u, connfd:%u Error:%d ErrMsg:%s\n", efd, fd, errno, strerror(errno));
        return -1; 
    }   

    return 0;
}

int del_epoll_fd(int efd, int fd)
{
    struct epoll_event ev;

    if(epoll_ctl(efd, EPOLL_CTL_DEL, fd, &ev) == -1) 
    {   
        fprintf(stderr, "epoll_ctl DEL failed! efd:%u, connfd:%u Error:%d ErrMsg:%s\n", efd, fd, errno, strerror(errno));
        return -1; 
    }   

    return 0;
}

void init_ssl()
{
    SSL_library_init();
    OpenSSL_add_all_algorithms();
    SSL_load_error_strings();
}

void usage(int argc, char** argv)
{
#if 1
    fprintf(stderr, "argc:%d", argc);
#endif

    fprintf(stdout, "\neg \n\t%s --ip [x.x.x.x] --port [0~65535]\n\n", argv[0]);
    exit(0);
}



int check_option(char*ip, uint16_t* port, int argc, char** argv)
{
    int opt = 0;
    struct option opts[] = 
    {
        {"ip", 1, NULL, 1},
        {"port", 1, NULL, 2},
        {0, 0, 0, 0}
    };

    while((opt = getopt_long(argc, argv, "", opts, NULL)) != -1)
    {
        switch(opt)
        {
            case 1:
                strcpy(ip, optarg);
                fprintf(stdout, "ip:%s\n", optarg);
                break;
            case 2:
                *port = atoi(optarg);
                fprintf(stdout, "port:%s\n", optarg);
                break;
            default:
                
                fprintf(stdout, "get opt fialed!\n");
                return -1;
        }
    }

    return 0;
}


int main(int argc, char** argv)
{
    int ret = 0;
    int serverfd = 0;

    int clientfd = 0;
    struct sockaddr_in client_addr;
    socklen_t client_len = sizeof(struct sockaddr);

    int efd = 0;
    int num = 0;
    int fd_counts = 0;

#ifdef USETLS
    SSL* ssl = NULL;
    SSL_CTX* ctx = NULL;
#endif

    uint8_t* buffer = (uint8_t*)malloc(MAX_BUFFER_SIZE);

    char ip[32] = {0};
    uint16_t port = 0;
    uint8_t* ca = (uint8_t*)malloc(MAX_BUFFER_SIZE);
    uint8_t* pri = (uint8_t*)malloc(MAX_BUFFER_SIZE);
    uint8_t* cer = (uint8_t*)malloc(MAX_BUFFER_SIZE);

    struct epoll_event* events = (struct epoll_event*)malloc(sizeof(struct epoll_event) * MAX_EPOLL_EVENTS);
    memset(events, 0, sizeof(struct epoll_event) * MAX_EPOLL_EVENTS);

    if(argc != 5)
        usage(argc, argv);

    if(-1==  check_option(ip, &port, argc, argv))
    {
        fprintf(stderr, "check option failed!\n");
        exit(0);
    }

#ifdef USETLS
    init_ssl();
#endif

    ret = init_socket(&serverfd, inet_addr(ip), port);
    if(ret != 0)
    {
        exit(0);
    }


    efd = epoll_create(MAX_EPOLL_EVENTS);
    if(efd <= 0)
    {
        fprintf(stderr, "epoll_create failed! Error:%d ErrMsg:%s\n", errno, strerror(errno));
        return -1;
    }

    scontext_t* scontext = (scontext_t*)malloc(sizeof(scontext_t));
    if(scontext)
        memset(scontext, 0, sizeof(scontext_t));
    else
    {
        fprintf(stderr, "ssl ctx context create failed!\n");
        exit(0);
    }

    scontext->fd = serverfd;

#ifdef USETLS
    ctx = init_ssl_ctx(1);
#endif

    if(0 != add_epoll_fd(efd, serverfd, EPOLLIN, scontext))
    {
        printf("add listen socket tcp fd to epoll handle failed!");
        return -1;
    }

    fd_counts ++;


    do
    {
        num = epoll_wait(efd, events, fd_counts, -1);

        while(num--)
        {
            scontext = (scontext_t*)events[num].data.ptr;
            
            if(events[num].events & EPOLLERR || events[num].events & EPOLLHUP)
            {
                fprintf(stderr, "events ERR or HUP!\n");
                close(scontext->fd);
            }
            else if(scontext->fd == serverfd)
            {
                fprintf(stdout, "new connect is comming\n");

                memset(&client_addr, 0, sizeof(struct sockaddr));
                clientfd = accept(scontext->fd, (struct sockaddr*)&client_addr, &client_len);
                if(clientfd < 0)
                {
                    fprintf(stderr, "new client accept failed!\n");
                    continue;
                }

                fprintf(stdout, "new client [%s:%d] is accepted!\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));

                scontext = (scontext_t*)malloc(sizeof(scontext_t));
                scontext->ssl = NULL;
#ifdef USETLS
                ssl = SSL_new(ctx);
                SSL_set_fd(ssl, clientfd);
                if ((ret = SSL_accept(ssl)) != 1)
                {
                    ERR_print_errors_fp(stderr);
                    ERR_print_errors_fp(stdout);
                    fprintf(stderr, "ssl accept failed! ret %d errcode:%d\n", ret, SSL_get_error(ssl, ret));
                    close(clientfd);
                    continue;
                }

                /* 显示对端证书 */
                ShowCerts(ssl);

                scontext->ssl = ssl;
#endif

                scontext->fd = clientfd;
#if 1
                if(0 != set_nonblock(clientfd))
                {
                    printf("client fd set nonblock failed!\n");
                    continue;
                }
#endif

                if(0 != add_epoll_fd(efd, clientfd, EPOLLIN | EPOLLOUT, scontext))
                {
                    fprintf(stderr, "add epoll fd failed!\n");
                    continue;
                }

                continue;
            }


            if(events[num].events & EPOLLIN)
            {
                clientfd = scontext->fd;
                if(clientfd < 0)
                {
                    fprintf(stderr, "read fd < 0\n");
                    continue;
                }

                printf("epollin socket [%d]\n", clientfd);

                memset(buffer, 0, MAX_BUFFER_SIZE);
#ifndef USETLS
                ret = recv(clientfd, buffer, MAX_BUFFER_SIZE - 1, 0);
                if(ret <= 0)
                {
                    printf("cliet close!\n");
                    if(errno == ECONNRESET || ret == 0)    
                    {

                        if(0 != del_epoll_fd(efd, clientfd))
                        {
                            printf("del epoll fd failed!\n");
                        }

                        close(clientfd);
                    }

                    continue;
                }
#else
                ssl = scontext->ssl;
                ret = SSL_read(ssl, buffer, MAX_BUFFER_SIZE);
                if(ret <= 0)
                {
                    ret = SSL_get_error(ssl, ret);
                    fprintf(stderr, "SSL_read has error! ssl get errcode:%d\n", ret);

                    if(ret == SSL_ERROR_WANT_READ)
                    {
                        fprintf(stderr, "SSL_ERROR_WANT_READ\n");
                    }
                    else if(ret == SSL_ERROR_WANT_WRITE)
                    {
                        fprintf(stderr, "SSL_ERROR_WANT_WRITE");
                    }
                    
                }
#endif

                fprintf(stdout, "recv buffer: %s\n", buffer);

                memset(buffer, 0, MAX_BUFFER_SIZE);

                if(!getpeername(clientfd, (struct sockaddr*)&client_addr, &client_len))
                {
                    sprintf((char*)buffer, "HTTP/1.1 200 OK >>>> ------------- %s:%u", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
                }

#ifndef USETLS
                if(-1 == writen(clientfd, (uint8_t*)buffer, (int)strlen((char*)buffer)))
                {
                    fprintf(stderr, "write failde!\n");
                }
#else
                ret = SSL_write(ssl, buffer, (int)strlen((char*)buffer));
                if(ret <= 0)
                {
                    ret = SSL_get_error(ssl, ret);
                    fprintf(stderr, "SSL_write has error! ssl get errcode:%d\n", ret);

                    if(ret == SSL_ERROR_WANT_READ)
                    {
                        fprintf(stderr, "-> SSL_ERROR_WANT_READ\n");
                    }
                    else if(ret == SSL_ERROR_WANT_WRITE)
                    {
                        fprintf(stderr, "-> SSL_ERROR_WANT_WRITE");
                    }
                    
                }
#endif

            }

#if 0
            if(events[num].events & EPOLLOUT)
            {
                clientfd = scontext->fd;
                if(clientfd < 0)
                {
                    fprintf(stderr, "read fd < 0\n");
                    continue;
                }

                printf("epollout socket [%d]\n", clientfd);

                memset(buffer, 0, MAX_BUFFER_SIZE);
                sprintf((char*)buffer, "HTTP/1.1 200 OK\r\nContent-Length: %d\r\n\r\n%s", (int)strlen("hello tls world"), "hello tls world");

                if(-1 == writen(clientfd, (uint8_t*)buffer, (int)strlen((char*)buffer)))
                {
                    fprintf(stderr, "write failde!\n");
                }
            }
#endif

        }
    }while(1);
        
    return 0;
}

2.客户端

/**
 *  Filename: client.c
 *   Created: 2019-09-19 17:38:25
 *      Desc: TODO (some description)
 *    Author: hair-man
 *   Company: owner 
 */


#include 
#include 
#include 
#include 
#include 
#include 
#include 

#include 
#include 
#include 
#include 


#include 
#include 

#include 

#define MAX_BUFFER_SIZE 65536
#define USETLS


int readn(int fd, uint8_t* buffer, int n)
{
    int nleft = n;
    int nread = 0;

    while(nleft > 0)
    {
        if((nread = read(fd, buffer + nread, nleft)) == -1)
        {
            if(errno == EINTR)
                nread = 0;
            else
                return -1;
        }
        else if(nread == 0)
            break;

        nleft -= nread;
    }

    return n - nleft;
}

int writen(int fd, uint8_t* buffer, int n)
{
    int nleft = n;
    int nwrite = 0;

    while(nleft > 0)
    {
        if((nwrite = write(fd, buffer + nwrite, nleft)) <= 0)
        {
            if(errno == EINTR)
                nwrite = 0;
            else
                return -1;
        }

        nleft -= nwrite;
    }

    return n;
}


void usage(int argc, char** argv)
{
#if 1
    fprintf(stderr, "argc:%d", argc);
#endif

    fprintf(stdout, "\neg \n\t%s --ip [xxx.xxx.xxx.xxx] --port [1~65535]\n\n", argv[0]);
    exit(0);
}


int check_option(char* ip, uint16_t* port, int argc, char** argv)
{
    int opt = 0;
    struct option opts[] = 
    {
        {"ip", 1, NULL, 1},
        {"port", 1, NULL, 2},
        {0, 0, 0, 0}
    };

    while((opt = getopt_long(argc, argv, "", opts, NULL)) != -1)
    {
        switch(opt)
        {
            case 1:
                strcpy(ip, optarg);
                fprintf(stdout, "ip:%s\n", optarg);
                break;
            case 2:
                *port = atoi(optarg);
                fprintf(stdout, "port:%s\n", optarg);
                break;
            default:
                
                fprintf(stdout, "get opt fialed!\n");
                return -1;
        }
    }

    return 0;
}

int set_nonblock(int fd)
{
    int block_mode = 0;

    //设置非阻塞模式
    block_mode = fcntl(fd, F_GETFL);
    if(block_mode < 0)
    {
        fprintf(stderr, "get block mode failed!Error:%d ErrMsg:%s\n", errno, strerror(errno));
        return -1;
    }

    block_mode = O_NONBLOCK | block_mode;
    if(fcntl(fd, F_SETFL, block_mode) < 0)
    {
        fprintf(stderr, "set block mode failed!Error:%d ErrMsg:%s\n", errno, strerror(errno));
        return -1;
    }

    return 0;
}

/* 证书打印信息 */
void ShowCerts(SSL *ssl)
{
    X509 *cert;
    char *line;

    cert = SSL_get_peer_certificate(ssl);
    if (cert != NULL)
    {
        printf("数字证书信息:\n");
        line = X509_NAME_oneline(X509_get_subject_name(cert), 0, 0);
        printf("证书: %s\n", line);
        free(line);

        line = X509_NAME_oneline(X509_get_issuer_name(cert), 0, 0);
        printf("颁发者: %s\n", line);
        free(line);
        X509_free(cert);
    }
    else
    {
        printf("无证书信息！\n");
    }
}

/* SSL 初始化 */
void init_ssl()
{
    SSL_library_init();
    OpenSSL_add_all_algorithms();
    SSL_load_error_strings();
}

/* 创建socket */
int init_socket(char* ip, uint16_t port)
{
    int clientfd = 0;
    int sndmem = 1024*1024;
    int rcvmem = 1024*1024;

    clientfd = socket(PF_INET, SOCK_STREAM, 0);
    if(clientfd < 0)
    {
        fprintf(stderr, "client fd create failed\n");
        return -1;
    }

#if 1
    /* 设置发送接收缓冲区 */
    if(0 != setsockopt(clientfd, SOL_SOCKET, SO_SNDBUF, (const char*)&sndmem, sizeof(int)))
    {
        fprintf(stderr, "setsockopt SO_SNDBUF FAILED. ip: %s,  port: %d\n", inet_ntoa(*(struct in_addr*)&ip), port);
        return -2;
    }

    if(0 != setsockopt(clientfd, SOL_SOCKET, SO_RCVBUF, (const char*)&rcvmem, sizeof(int)))
    {
        fprintf(stderr, "setsockopt SO_RCVBUF FAILED. ip : %d, port : %d\n", inet_ntoa(*(struct in_addr*)&ip), port);
        return -3;
    }
#endif
#if 0
    /* 设置阻塞等待时间 */
    struct timeval tv_out;
    tv_out.tv_sec = 2;
    tv_out.tv_usec = 0;

    if(0 != setsockopt(clientfd, SOL_SOCKET, SO_RCVTIMEO, &tv_out, sizeof(tv_out)))
    {
        fprintf(stderr, "setsockopt SO_RCVTIMEO FAILED. ip : %d, port : %d\n", inet_ntoa(*(struct in_addr*)&ip), port);
        return -4;
    }
    if(0 != setsockopt(clientfd, SOL_SOCKET, SO_SNDTIMEO, &tv_out, sizeof(tv_out)))
    {
        fprintf(stderr, "setsockopt SO_SNDTIMEO FAILED. ip : %d, port : %d\n", inet_ntoa(*(struct in_addr*)&ip), port);
        return -5;
    }
#endif

    return clientfd;
}


SSL_CTX *ssl_ctx_init(int verify_option)
{
    SSL_CTX *ctx = NULL;
    const SSL_METHOD *meth;

    meth = SSLv23_client_method();
    ctx = SSL_CTX_new(meth);

    if(2 == verify_option)  //双向认证
    {

#define CLIENT_S_CERT   "third_cert/client.crt"
#define CLIENT_S_KEY    "third_cert/ca.key"
#define CLIENT_CA_CERT  "third_cert/ca.crt"
  
        #if 1
        if(SSL_CTX_use_certificate_chain_file(ctx, CLIENT_CA_CERT) <= 0)
        {
            ERR_print_errors_fp(stderr);
            goto err_proc;
        }
        #endif

        /* 加载服务端证书 */
        if(SSL_CTX_use_certificate_file(ctx, CLIENT_CA_CERT, SSL_FILETYPE_PEM) <= 0)
        {
            ERR_print_errors_fp(stderr);
            goto err_proc;
        }

        /* 加载服务端密钥 */
        if(SSL_CTX_use_PrivateKey_file(ctx, CLIENT_S_KEY, SSL_FILETYPE_PEM) <= 0)
        {
            ERR_print_errors_fp(stderr);
            goto err_proc;
        }
        #if 1
        /* 加载根证书 */
        if(!SSL_CTX_load_verify_locations(ctx, CLIENT_CA_CERT, NULL))
        {
            ERR_print_errors_fp(stderr);
            goto err_proc;
        }
        #endif
        SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, NULL);
    }
    else if(1 == verify_option) //单向认证
    {
        if(!SSL_CTX_load_verify_locations(ctx, CLIENT_CA_CERT, NULL))
        {
            ERR_print_errors_fp(stderr);
            goto err_proc;
        }
        SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, NULL);
        SSL_CTX_set_verify_depth(ctx, 2);
    }
    else    //不验证
    {
        SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, NULL);
    }
    
    return ctx;
err_proc:
    if(ctx)
    {
        SSL_CTX_free(ctx);
        ctx = NULL;
    }
    return NULL;
}


void u_alarm_handler()
{
    printf("connect time out \n");
}

int main(int argc, char** argv)
{
    int ret = 0;
    int clientfd = 0;
    struct sockaddr_in server_addr;
    socklen_t server_len = sizeof(struct sockaddr);

    char* buffer = (char*)malloc(MAX_BUFFER_SIZE);
    char ip[32] = {0};
    uint16_t port = 0;

    /* 输入校验 */
    if(argc != 5)
        usage(argc, argv);

    if(-1 == check_option((char*)ip, &port, argc, argv))
    {
        fprintf(stderr, "check option failed!\n\n");
        usage(argc, argv);
        exit(-1);
    }

#ifdef USETLS
    SSL* ssl = NULL;
    SSL_CTX* ctx = NULL;

    init_ssl();
#endif

    /* 创建socket */
    clientfd = init_socket(ip,port);
    if(clientfd < 0 )
    {
        fprintf(stderr, "create failed, result = %d\n", clientfd);
        return -1;
    }

    /* connect 超时处理 */
    sigset(SIGALRM, u_alarm_handler);
    alarm(2);

    /* 服务器地址初始化 */
    memset(&server_addr, 0, sizeof(struct sockaddr_in));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = inet_addr(ip);
    server_addr.sin_port = htons(port);

    ret = connect(clientfd, (struct sockaddr*)&server_addr, server_len);
    if(ret < 0)
    {
        fprintf(stderr, "connect [%s:%d] failed! clientfd:%d errno:%u errmsg:%s\n", inet_ntoa(server_addr.sin_addr), ntohs(server_addr.sin_port), clientfd, errno, strerror(errno));
        return -1;
    }
    alarm(0);
    sigrelse(SIGALRM);

#ifdef USETLS

    //不需要验证服务器证书
    //SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, NULL);

    //需要验证服务器证书
    //如果是非权威CA（自己生成的TEST CA） 则需要先加载CA证书才能通过校验
    //ret = SSL_CTX_load_verify_locations(ctx, ca_file, NULL);
    //
    //加载成功之后，服务器证书就可以验证通过，否则验证失败Unkonw CA
    //
    //SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, NULL);


    /* 创建ctx对象 */
    ctx = ssl_ctx_init(2);

    ssl = SSL_new(ctx);
    SSL_set_fd(ssl, clientfd);

    if((ret = SSL_connect(ssl)) != 1)
    {
        ShowCerts(ssl);
        ERR_print_errors_fp(stderr);
        fprintf(stderr, "SSL connect failed! ret %d errcode:%d\n", ret, SSL_get_error(ssl, ret));  
        return -1;
    }
    else
        ShowCerts(ssl);
        fprintf(stdout, "Connect with [%s] encryption\n", SSL_get_cipher(ssl));

#endif

#if 0
    if(0 != set_nonblock(clientfd))
    {
        printf("set nonblock failed!\n");
        return -1;
    }
#endif

    while(1)
    {
        memset(buffer, 0, MAX_BUFFER_SIZE);
        memset(&server_addr, 0, sizeof(struct sockaddr_in));

        if(!getsockname(clientfd, (struct sockaddr*)&server_addr, &server_len))
        {
            sprintf(buffer, "TLS -> %s, %d Comming!", inet_ntoa(server_addr.sin_addr), ntohs(server_addr.sin_port));
        }

        /* write */
#ifndef USETLS
        if(-1 == writen(clientfd, (uint8_t*)buffer, strlen(buffer)))
            fprintf(stderr, "write [%s] failed!\n", buffer);
        else
            fprintf(stdout, "write [%s] success!\n", buffer);
#else
        ret = SSL_write(ssl, buffer, strlen(buffer));
        if(ret <= 0)
        {
            ret = SSL_get_error(ssl, ret);
            fprintf(stderr, "SSL_read has error! ssl get errcode:%d\n", ret);

            if(ret == SSL_ERROR_WANT_READ)
            {
                fprintf(stderr, "SSL_ERROR_WANT_READ\n");
            }
            else if(ret == SSL_ERROR_WANT_WRITE)
            {
                fprintf(stderr, "SSL_ERROR_WANT_WRITE");
            }

        }
         fprintf(stdout, "write [%s] success!\n", (char*)buffer);
#endif

        /* read */
        memset(buffer, 0, MAX_BUFFER_SIZE);
#ifndef USETLS
        if(-1 == read(clientfd, (uint8_t*)buffer, MAX_BUFFER_SIZE))
            fprintf(stderr, "read failed! errno:%u, errmsg:%s\n", errno, strerror(errno));
        else
            fprintf(stdout, "read [%s] success!\n", (char*)buffer);
#else
        ret = SSL_read(ssl, buffer, MAX_BUFFER_SIZE);
        if(ret <= 0)
        {
            ret = SSL_get_error(ssl, ret);
            fprintf(stderr, "SSL_read has error! ssl get errcode:%d\n", ret);

            if(ret == SSL_ERROR_WANT_READ)
            {
                fprintf(stderr, "SSL_ERROR_WANT_READ\n");
            }
            else if(ret == SSL_ERROR_WANT_WRITE)
            {
                fprintf(stderr, "SSL_ERROR_WANT_WRITE");
            }

        }

        fprintf(stdout, "read [%s] success!\n", (char*)buffer);
#endif

        sleep(1);
    }


    /* 与OpenSSL_add_all_algorithms对应  */
    EVP_cleanup();

    return 0;
}

你可能感兴趣的:(TLS双向认证,三级证书链)

  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码 说私域 人工智能小程序
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
  • 【加密社】Solidity 中的事件机制及其应用 加密社 闲侃区块链智能合约区块链
    加密社引言在Solidity合约开发过程中，事件（Events）是一种非常重要的机制。它们不仅能够让开发者记录智能合约的重要状态变更，还能够让外部系统（如前端应用）监听这些状态的变化。本文将详细介绍Solidity中的事件机制以及如何利用不同的手段来触发、监听和获取这些事件。事件存储的地方当我们在Solidity合约中使用emit关键字触发事件时，该事件会被记录在区块链的交易收据中。具体而言，事件
  • 在一台Ubuntu计算机上构建Hyperledger Fabric网络 落叶无声9 区块链超级账本Hyperledgerfabric区块链ubuntu构建hyperledgerfabric
    在一台Ubuntu计算机上构建HyperledgerFabric网络Hyperledgerfabric是一个开源的区块链应用程序平台，为开发基于区块链的应用程序提供了一个起点。当我们提到HyperledgerFabric网络时，我们指的是使用HyperledgerFabric的正在运行的系统。即使只使用最少数量的组件，部署Fabric网络也不是一件容易的事。Fabric社区创建了一个名为Cello
  • Linux MariaDB使用OpenSSL安装SSL证书 Meta39 MySQLOracleMariaDBLinuxWindowsssllinuxmariadb
    进入到证书存放目录，批量删除.pem证书警告：确保已经进入到证书存放目录find.-typef-iname\*.pem-delete查看是否安装OpenSSLopensslversion没有则安装yuminstallopensslopenssl-devel开启SSL编辑/etc/my.cnf文件（没有的话就创建，但是要注意，在/etc/my.cnf.d/server.cnf配置了datadir的，
  • Kafka是如何保证数据的安全性、可靠性和分区的 喜欢猪猪 kafka分布式
    Kafka作为一个高性能、可扩展的分布式流处理平台，通过多种机制来确保数据的安全性、可靠性和分区的有效管理。以下是关于Kafka如何保证数据安全性、可靠性和分区的详细解析：一、数据安全性SSL/TLS加密：Kafka支持SSL/TLS协议，通过配置SSL证书和密钥来加密数据传输，确保数据在传输过程中不会被窃取或篡改。这一机制有效防止了中间人攻击，保护了数据的安全性。SASL认证：Kafka支持多种
  • 崩坏星穹铁道哪个角色值得培养 崩坏星穹铁道新手角色优先级教学 会飞滴鱼儿
    崩坏星穹铁道新手角色培养攻略：哪些角色值得投资？在《崩坏星穹铁道》中，角色的强度和培养一直是玩家们关心的焦点。要想体验更爽快的游戏过程，选对角色至关重要。那么，哪些角色值得投资培养呢?本篇教学文章将针对新手玩家，从T0到T1强度的角色中为你做出详尽解析。游戏豹官网现在的手游平台很多，但是在游戏界有这么一个传说：“喜欢肝的玩家不如氪金玩家，氪金玩家不如内部福利玩家”，这就是游戏界可悲的生物链，很多平
  • 现金贷“租系统”产业崛起：租金3000，本金10万，一月回本 Dayon
    最近，地下现金贷的全面崛起，已成了不可阻挡的趋势。大量民间资本开始涌入，民间高利贷、炒房团、土豪的钱，都裹挟其中。而地下现金贷的入门门槛正在不断降低，一条新的产业链开始崛起：租现金贷系统。现在，只需要10万本金，花3000元租个系统，两个人的团队，一个月就能回本。大量的小本金玩家进场了，为了急速获利，他们甚至将利率调到1600%以上。业内人士称，真实的现金贷用户，现在大概只有200多万。整个行业几
  • 最简单将静态网页挂载到服务器上(不用nginx) 全能全知者 服务器nginx运维前端html笔记
    最简单将静态网页挂载到服务器上(不用nginx)如果随便弄个静态网页挂在服务器都要用nignx就太麻烦了，所以直接使用Apache来搭建一些简单前端静态网页会相对方便很多检查Web服务器服务状态：sudosystemctlstatushttpd#ApacheWeb服务器如果发现没有安装web服务器：安装Apache：sudoyuminstallhttpd启动Apache：sudosystemctl
  • 新能源汽车 BMS 学习笔记篇—BMS 基本定义及分类 WPG大大通 其他笔记汽车BMS经验分享新能源电池
    一、BMS定义1、概念：BMS（BatteryManagementSystem）即电池管理系统，其管理对象是二次电池（充电电池或蓄电池），其主要目的是电池的利用率，防止电池出现过度充电和过度放电，可应用于电动汽车、电瓶车、机器人、无人机等图片来源：腾讯网https://new.qq.com《标准普尔警告，电动汽车电池生产面临供应链和地缘政治风险》2、四大功能①感知和测量：检测电池的电压、电流、温度
  • Rust是否会取代C/C++？Rust与C/C++的较量 AI与编程之窗 源码编译与开发rustc语言c++内存安全并发编程代码安全性能优化
    目录引言第一部分：Rust语言的优势内存安全性并发性性能社区和生态系统的成长第二部分：C/C++语言的优势和地位历史积淀和成熟度广泛的库和工具支持性能优化和硬件控制丰富的行业应用社区和行业支持第三部分：挑战和阻碍学习曲线现有代码库的迁移成本生态系统和工具链的完善度社区和人才培养行业应用和推广法规和标准化第四部分：未来趋势和可能性行业趋势教育和人才培养兼容和共存行业标准化企业支持和应用开源社区和生态
  • MySQL事务隔离级别和MVCC 简书徐小耳
    MySQL事务隔离级别和MVCC参考：https://mp.weixin.qq.com/s/Jeg8656gGtkPteYWrG5_Nw1.MVCC只对读已提交和可重复的读有效果，而未提交读和串行则无意义。2.每条记录都会有trx_id(事务修改记录的id）和roll_pointer是一个指针指向旧版本的undo日志链表（row_id不是必必要的，如果有主键存在就不需要了）3.版本链的头结点就是记
  • 设计模式 23 访问者模式 WineMonk #设计模式设计模式访问者模式
    设计模式23创建型模式（5）：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式结构型模式（7）：适配器模式、桥接模式、组合模式、装饰者模式、外观模式、享元模式、代理模式行为型模式（11）：责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式、访问者模式文章目录设计模式23访问者模式（VisitorPattern）1定义2结构3
  • 用kubedam搭建的k8s证书过期处理方法 我滴鬼鬼呀wks k8s1024程序员节
    kubeadm部署的k8s证书过期1、查看证书过期时间kubeadmalphacertscheck-expiration若证书已经过期无法试用kubectl命令建议修改服务器时间到未过期的时间段2、配置kube-controller-manager.yaml文件cat/etc/kubernetes/manifests/kube-controller-manager.yamlapiVersion:v
  • 2021-04-06 四叶草_add9
    中原焦点团队李金梅坚持分享第549天2021.4.6凌晨两点多忽然被乳腺疼痛惊醒，上完课后我便去了医院，结果显示三级，预约了穿刺。乳腺疾病与情绪和压力紧密相关，看来是身体向我发出信号了，果真比大脑更智慧。但愿这个信号发的并不算迟，给自己减减压，面对孩子，从心底里接纳吧！面对工作，不用精益求精，尽力就好。
  • 我的红本绿本 红海儿
    帮妈收拾屋子，洗被擦灰，翻箱倒柜。偶然，发现一处新大陆，我小学，中学的毕业证书。二十多年啦，我老妈还替我保管得挺好，没破相，没断篇。我不起眼的成绩单红色绿色还是那样鲜艳，好像我还没长大的模样。把本子翻开，我的照片映入眼帘，诶呦，这是谁家的小丫头啊？怎么这么招人稀罕呢？哈哈哈，我与本子对视，要笑掉下巴了。上面还有老师的钢笔字评语，被岁月褪淡了些许颜色，是姓李还有姓王，姓孙，姓闫……很多老师的名字还在
  • k8s证书过期问题处理 olina_qin kubernetes容器云原生
    k8s证书过期问题处理opensslx509-in/etc/kubernetes/pki/apiserver.crt-noout-dateskubeadmcertsrenewallsystemctlrestartkubeleopensslx509-in/etc/kubernetes/pki/apiserver.crt-noout-text|grep"NotAfter"cp/etc/kubernet
  • 【K8s】专题十一：Kubernetes 集群证书过期处理方法 行者Sun1989 Kuberneteskubernetes云原生容器
    本文内容均来自个人笔记并重新梳理，如有错误欢迎指正！如果对您有帮助，烦请点赞、关注、转发、订阅专栏！专栏订阅入口Linux专栏|Docker专栏|Kubernetes专栏往期精彩文章【Docker】（全网首发）KylinV10下MySQL容器内存占用异常的解决方法【Docker】（全网首发）KylinV10下MySQL容器内存占用异常的解决方法（续）【Docker】MySQL源码构建Docker镜
  • Go编程语言前景怎么样？参加培训好就业吗 QFdongdong
    Go语言专门针对多处理器系统应用程序的编程进行了优化，使用Go编译的程序可以媲美C或C++代码的速度，而且更加安全、支持并行进程。不仅可以开发web,可以开发底层，目前知乎就是用golang开发。区块链首选语言就是go,以-太坊，超级账本都是基于go语言，还有go语言版本的btcd.Go的目标是希望提升现有编程语言对程序库等依赖性(dependency)的管理，这些软件元素会被应用程序反复调用。由
  • 区块链～我的念 夜未央0075460
    世界上最快的速度不是光，不是电，而是我们的「念」。一念起，万水千山；一念灭，沧海桑田。念起念灭当随缘，切莫执迷。执念区块链
  • linux挂载文件夹 小码快撩 linux
    1.使用NFS（NetworkFileSystem）NFS是一种分布式文件系统协议，允许一个系统将其文件系统的一部分共享给其他系统。检查是否安装NFSrpm-qa|grepnfs2.启动和启用NFS服务假设服务名称为nfs-server.service，你可以使用以下命令启动和启用它：sudosystemctlstartnfs-server.servicesudosystemctlenablenf
  • MacOS Catalina 从源码构建Qt6.2开发库之01: 编译Qt6.2源代码 捕鲸叉 QTmacosc++QT
    安装xcode，cmake，ninjabrewinstallnodemac下安装OpenGL库并使之对各项目可见在macOS上安装OpenGL通常涉及到安装一些依赖库，如MGL、GLUT或者是GLEW等，同时确保LLVM的OpenGL框架和相关工具链的兼容性。以下是一个基本的安装步骤，你可以在终端中执行：安装Homebrew（如果还没有安装的话）：/bin/bash-c"$(curl-fsSLht
  • HTTPS 安全最佳实践（一）之SSLTLS部署 SHENHUANJIE HTTPSSSLTLS
    SSL/TLS是一种简单易懂的技术，它很容易部署及运行。但想要部署的安全通常是不容易的。这也使系统管理员和开发者不得不去了解SSL和TLS相关的技术，掌握如何配置一个安全的web服务器或应用。无疑会耗费很大的精力去看相关的技术文档，乏味且宽泛。受理SSL数字证书客户问题，包括产品咨询、技术支持、投诉受理、建议反馈，以及购买帮助等。1证书和私钥在TLS中，所有的安全性都从服务器的密码标识开始；需要一
  • Python和MATLAB及C++信噪比导图(算法模型) 亚图跨际 算法交叉知识Python视频图像修复模数转换信号链噪音频谱计算量化周期性视觉刺激高斯噪声的矩形脉冲心率失常检测算法
    要点视频图像修复模数转换中混合信号链噪音测量频谱计算和量化周期性视觉刺激脑电图高斯噪声的矩形脉冲总谐波失真周期图功率谱密度各种心率失常检测算法胶体悬浮液跟踪检测计算交通监控摄像头图像噪音计算Python信噪比信噪比是科学和工程中使用的一种测量方法，用于比较所需信号水平与背景噪声水平。信噪比定义为信号功率与噪声功率之比，通常以分贝表示。高于1:1（大于0dB）的比率表示信号大于噪声。信噪比是影响处理
  • Spring Security静态资源过滤（11） 小黑屋说YYDS spring
    在一个实际项目中，并非所有的请求都需要经过SpringSecurity过滤器，有一些特殊的请求，例如静态资源等，一般来说并不需要经过SpringSecurity过滤器链，用户如果访问这些静态资源，直接返回对应的资源即可。回顾关于WebSecurity的讲解，提到它里边维护了一个ignoredRequests变量,该变量，记录的就是所有需要被忽略的请求，这些被忽略的请求将不再经过SpringSecu
  • Spring Security定义多个过滤器链（10） 小黑屋说YYDS spring
    在SpringSecurity中可以同时存在多个过滤器链，一个WebSecurityConfigurerAdapter的实例就可以配置一条过滤器链。我们来看如下一个案例：@ConfigurationpublicclassSecurityConfig{@BeanUserDetailsServiceus(){InMemoryUserDetailsManagerusers=newInMemoryUser
  • vue keep-alive w_wx_x
    作用：  vue内置组件，能在组件切换过程中将状态保留在内存中，防止重复渲染DOM  keep-alive是用在一个直属子组件被开关的情形，同时只有一个子组件在渲染，若有v-for则不会工作  注：keep-alive是一个抽象组件，自身不会渲染一个DOM元素，也不会出现在父组件链中//页面文件//路由exportdefaultnewRouter({routes:[{path:'/',name:'
  • 文本编辑器markdown语法 花北城 科技随笔Markdown
    markdown语法1.介绍Markdown是一种使用一定的语法将普通的文本转换成HTML标签文本的编辑语言，它的特点是可以使用普通的文本编辑器来编写，只需要按照特定的语法标记就可以得到丰富多样的HTML格式的文本。2.标题分级"#"->一级标题"##"->二级标题"###"->三级标题3.分割线使用三个或以上的“-”或者“*”表示(混合的不行)4.斜体和粗体使用(*或者_)和(**或者__)分别
  • "五项管理"之作业 胡军锋
    （一）统筹规划，轻负高效1.制定作业管理规范。加强教务处、年级组、班级三级统筹管理，合理调控学科作业结构和总量，严格控制电子作业内容与时长，引导学生正确使用网络、注意用眼卫生，杜绝家庭作业变家长作业，严禁布置家长作业，要求所有作业在校内完成。2.建立作业公示制度。每月定期开展学生作业情况反馈调研，并将调查结果及时反馈到每位学科教师。3.强化延时服务管理。在老师的指导下，应在延时期间完成作业。以完成
  • 以太坊DApp开发指南 Kirn
    DApp架构设计DApp架构.png如上图，DApp的架构我们可以简单分为以上三种类型：轻钱包模式、重钱包模式和兼容模式。轻钱包模式轻钱包模式下我们需要有一个开放HttpRPC协议的节点与钱包通信，这个节点可以是任意链上的节点。轻钱包通常会作为一个浏览器插件存在，插件在运行时会自动注入Web3框架，DApp可以通过Web3与区块链节点通信。当DApp只是单纯的获取数据时是不需要钱包介入的，但是当D
  • 2019-11-06强大的人，有人爱 夕颜日知录
    周一上午，去看了生病在家的妹纸梅梅。梅梅是一个单亲妈妈，结婚10年两个孩子换来一纸离婚证书。其中二宝还是在出轨闹离婚阶段生的，所有人都劝她不要生下来，可是她依然生下来了。如今二宝已经4.5岁了，家里雇了一个阿姨，一直都是有阿姨带大。梅梅的家里父母没有帮她，各方面原因，一方面父母的性格强，一方面梅梅的性格也强。离婚四年了，梅梅也做过几份工作，每一份都有各种各样的原因离职了。现在这家单位是梅梅喜欢的，
  • 数据采集高并发的架构应用 3golden .net
    问题的出发点：          最近公司为了发展需要，要扩大对用户的信息采集，每个用户的采集量估计约2W。如果用户量增加的话，将会大量照成采集量成3W倍的增长，但是又要满足日常业务需要，特别是指令要及时得到响应的频率次数远大于预期。       &n
  • 不停止 MySQL 服务增加从库的两种方式 brotherlamp linuxlinux视频linux资料linux教程linux自学
    现在生产环境MySQL数据库是一主一从，由于业务量访问不断增大，故再增加一台从库。前提是不能影响线上业务使用，也就是说不能重启MySQL服务，为了避免出现其他情况，选择在网站访问量低峰期时间段操作。  一般在线增加从库有两种方式，一种是通过mysqldump备份主库，恢复到从库，mysqldump是逻辑备份，数据量大时，备份速度会很慢，锁表的时间也会很长。另一种是通过xtrabacku
  • Quartz——SimpleTrigger触发器 eksliang SimpleTriggerTriggerUtilsquartz
    转载请出自出处：http://eksliang.iteye.com/blog/2208166 一.概述 SimpleTrigger触发器，当且仅需触发一次或者以固定时间间隔周期触发执行；   二.SimpleTrigger的构造函数 SimpleTrigger(String name, String group)：通过该构造函数指定Trigger所属组和名称； Simpl
  • Informatica应用（1） 18289753290 sqlworkflowlookup组件Informatica
    1.如果要在workflow中调用shell脚本有一个command组件，在里面设置shell的路径；调度wf可以右键出现schedule，现在用的是HP的tidal调度wf的执行。 2.designer里面的router类似于SSIS中的broadcast（多播组件）;Reset_Workflow_Var：参数重置 （比如说我这个参数初始是1在workflow跑得过程中变成了3我要在结束时还要
  • python 获取图片验证码中文字 酷的飞上天空 python
    根据现成的开源项目 http://code.google.com/p/pytesser/改写 在window上用easy_install安装不上  看了下源码发现代码很少  于是就想自己改写一下   添加支持网络图片的直接解析   #coding:utf-8 #import sys #reload(sys) #sys.s
  • AJAX 永夜-极光 Ajax
    1.AJAX功能:动态更新页面,减少流量消耗,减轻服务器负担   2.代码结构:    <html> <head> <script type="text/javascript"> function loadXMLDoc() { .... AJAX script goes here ...
  • 创业OR读研 随便小屋 创业
            现在研一，有种想创业的想法，不知道该不该去实施。因为对于的我情况这两者是矛盾的，可能就是鱼与熊掌不能兼得。                研一的生活刚刚过去两个月，我们学校主要的是
  • 需求做得好与坏直接关系着程序员生活质量 aijuans IT 生活
            这个故事还得从去年换工作的事情说起，由于自己不太喜欢第一家公司的环境我选择了换一份工作。去年九月份我入职现在的这家公司，专门从事金融业内软件的开发。十一月份我们整个项目组前往北京做现场开发，从此苦逼的日子开始了。        系统背景：五月份就有同事前往甲方了解需求一直到6月份，后续几个月也完
  • 如何定义和区分高级软件开发工程师 aoyouzi
    在软件开发领域，高级开发工程师通常是指那些编写代码超过 3 年的人。这些人可能会被放到领导的位置，但经常会产生非常糟糕的结果。Matt Briggs 是一名高级开发工程师兼 Scrum 管理员。他认为，单纯使用年限来划分开发人员存在问题，两个同样具有 10 年开发经验的开发人员可能大不相同。近日，他发表了一篇博文，根据开发者所能发挥的作用划分软件开发工程师的成长阶段。 　　初
  • Servlet的请求与响应 百合不是茶 servletget提交java处理post提交
      Servlet是tomcat中的一个重要组成,也是负责客户端和服务端的中介     1,Http的请求方式(get  ,post);   客户端的请求一般都会都是Servlet来接受的,在接收之前怎么来确定是那种方式提交的,以及如何反馈,Servlet中有相应的方法,  http的get方式 servlet就是都doGet(
  • web.xml配置详解之listener bijian1013 javaweb.xmllistener
    一.定义 <listener> <listen-class>com.myapp.MyListener</listen-class> </listener>   二.作用        该元素用来注册一个监听器类。可以收到事件什么时候发生以及用什么作为响
  • Web页面性能优化（yahoo技术） Bill_chen JavaScriptAjaxWebcssYahoo
    1.尽可能的减少HTTP请求数 content 2.使用CDN server 3.添加Expires头(或者 Cache-control) server 4.Gzip 组件 server 5.把CSS样式放在页面的上方。 css 6.将脚本放在底部(包括内联的) javascript 7.避免在CSS中使用Expressions css 8.将javascript和css独立成外部文
  • 【MongoDB学习笔记八】MongoDB游标、分页查询、查询结果排序 bit1129 mongodb
    游标   游标，简单的说就是一个查询结果的指针。游标作为数据库的一个对象，使用它是包括 声明 打开 循环抓去一定数目的文档直到结果集中的所有文档已经抓取完 关闭游标   游标的基本用法，类似于JDBC的ResultSet(hasNext判断是否抓去完,next移动游标到下一条文档)，在获取一个文档集时，可以提供一个类似JDBC的FetchSize
  • ORA-12514 TNS 监听程序当前无法识别连接描述符中请求服务 的解决方法 白糖_ ORA-12514
    今天通过Oracle SQL*Plus连接远端服务器的时候提示“监听程序当前无法识别连接描述符中请求服务”，遂在网上找到了解决方案： ①打开Oracle服务器安装目录\NETWORK\ADMIN\listener.ora文件，你会看到如下信息：   # listener.ora Network Configuration File: D:\database\Oracle\net
  • Eclipse 问题 A resource exists with a different case bozch eclipse
    在使用Eclipse进行开发的时候，出现了如下的问题： Description Resource Path Location TypeThe project was not built due to "A resource exists with a different case: '/SeenTaoImp_zhV2/bin/seentao'.&
  • 编程之美-小飞的电梯调度算法 bylijinnan 编程之美
    public class AptElevator { /** * 编程之美 小飞 电梯调度算法 * 在繁忙的时间，每次电梯从一层往上走时，我们只允许电梯停在其中的某一层。 * 所有乘客都从一楼上电梯，到达某层楼后，电梯听下来，所有乘客再从这里爬楼梯到自己的目的层。 * 在一楼时，每个乘客选择自己的目的层，电梯则自动计算出应停的楼层。 * 问：电梯停在哪
  • SQL注入相关概念 chenbowen00 sqlWeb安全
    SQL Injection：就是通过把SQL命令插入到Web表单递交或输入域名或页面请求的查询字符串，最终达到欺骗服务器执行恶意的SQL命令。 具体来说，它是利用现有应用程序，将（恶意）的SQL命令注入到后台数据库引擎执行的能力，它可以通过在Web表单中输入（恶意）SQL语句得到一个存在安全漏洞的网站上的数据库，而不是按照设计者意图去执行SQL语句。 首先让我们了解什么时候可能发生SQ
  • [光与电]光子信号战防御原理 comsci 原理
          无论是在战场上,还是在后方,敌人都有可能用光子信号对人体进行控制和攻击,那么采取什么样的防御方法,最简单,最有效呢?       我们这里有几个山寨的办法,可能有些作用,大家如果有兴趣可以去实验一下       根据光
  • oracle 11g新特性:Pending Statistics daizj oracledbms_stats
    oracle 11g新特性:Pending Statistics 转 从11g开始，表与索引的统计信息收集完毕后，可以选择收集的统信息立即发布，也可以选择使新收集的统计信息处于pending状态，待确定处于pending状态的统计信息是安全的，再使处于pending状态的统计信息发布，这样就会避免一些因为收集统计信息立即发布而导致SQL执行计划走错的灾难。 在 11g 之前的版本中，D
  • 快速理解RequireJs dengkane jqueryrequirejs
    RequireJs已经流行很久了，我们在项目中也打算使用它。它提供了以下功能： 声明不同js文件之间的依赖 可以按需、并行、延时载入js库 可以让我们的代码以模块化的方式组织 初看起来并不复杂。 在html中引入requirejs 在HTML中，添加这样的 <script> 标签： <script src="/path/to
  • C语言学习四流程控制if条件选择、for循环和强制类型转换 dcj3sjt126com c
    # include <stdio.h> int main(void) { int i, j; scanf("%d %d", &i, &j); if (i > j) printf("i大于j\n"); else printf("i小于j\n"); retu
  • dictionary的使用要注意 dcj3sjt126com IO
    NSDictionary *dict = [NSDictionary dictionaryWithObjectsAndKeys: user.user_id , @"id", user.username , @"username",
  • Android 中的资源访问(Resource) finally_m xmlandroidStringdrawablecolor
    简单的说，Android中的资源是指非代码部分。例如，在我们的Android程序中要使用一些图片来设置界面，要使用一些音频文件来设置铃声，要使用一些动画来显示特效，要使用一些字符串来显示提示信息。那么，这些图片、音频、动画和字符串等叫做Android中的资源文件。 在Eclipse创建的工程中，我们可以看到res和assets两个文件夹，是用来保存资源文件的，在assets中保存的一般是原生
  • Spring使用Cache、整合Ehcache 234390216 springcacheehcache@Cacheable
    Spring使用Cache            从3.1开始，Spring引入了对Cache的支持。其使用方法和原理都类似于Spring对事务管理的支持。Spring Cache是作用在方法上的，其核心思想是这样的：当我们在调用一个缓存方法时会把该方法参数和返回结果作为一个键值对存放在缓存中，等到下次利用同样的
  • 当druid遇上oracle blob(clob) jackyrong oracle
    http://blog.csdn.net/renfufei/article/details/44887371 众所周知，Oracle有很多坑, 所以才有了去IOE。 在使用Druid做数据库连接池后，其实偶尔也会碰到小坑，这就是使用开源项目所必须去填平的。【如果使用不开源的产品，那就不是坑，而是陷阱了，你都不知道怎么去填坑】 用Druid连接池，通过JDBC往Oracle数据库的
  • easyui datagrid pagination获得分页页码、总页数等信息 ldzyz007
    var grid = $('#datagrid');  var options = grid.datagrid('getPager').data("pagination").options;  var curr = options.pageNumber;  var total = options.total;  var max =
  • 浅析awk里的数组 nigelzeng 二维数组array数组awk
    awk绝对是文本处理中的神器，它本身也是一门编程语言，还有许多功能本人没有使用到。这篇文章就单单针对awk里的数组来进行讨论，如何利用数组来帮助完成文本分析。   有这么一组数据：   abcd,91#31#2012-12-31 11:24:00 case_a,136#19#2012-12-31 11:24:00 case_a,136#23#2012-12-31 1
  • 搭建 CentOS 6 服务器(6) - TigerVNC rensanning centos
    安装GNOME桌面环境 # yum groupinstall "X Window System" "Desktop" 安装TigerVNC # yum -y install tigervnc-server tigervnc 启动VNC服务 # /etc/init.d/vncserver restart # vncser
  • Spring 数据库连接整理 tomcat_oracle springbeanjdbc
    1、数据库连接jdbc.properties配置详解 　　jdbc.url=jdbc:hsqldb:hsql://localhost/xdb 　　jdbc.username=sa 　　jdbc.password= 　　jdbc.driver=不同的数据库厂商驱动，此处不一一列举 　　接下来，详细配置代码如下： 　　 Spring连接池    
  • Dom4J解析使用xpath java.lang.NoClassDefFoundError: org/jaxen/JaxenException异常 xp9802
    用Dom4J解析xml,以前没注意,今天使用dom4j包解析xml时在xpath使用处报错      异常栈：java.lang.NoClassDefFoundError: org/jaxen/JaxenException异常       导入包 jaxen-1.1-beta-6.jar 解决; &nb
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他