https_tool.c

Go to the documentation of this file.

 
#ifdef CPLUSPLUS
    #undef CPLUSPLUS
#endif
 
 
#include "https_tool.h"
 
 
#ifdef ENABLE_SSL
 
int  send_https_header(int sofd, SSL* ssl, tList* pp, int mode)
{
    int    hs=0, sz=0;
    Buffer buf;
 
    if (pp==NULL) return JBXL_ARGS_ERROR;
 
    buf = restore_protocol_header(pp, (char*)": ", mode, &hs);
    if (buf.vldsz>0) {
        sz  = ssl_tcp_send_Buffer(sofd, ssl, &buf);
        if (mode==ON) sz = sz - hs;
    }
 
    free_Buffer(&buf);
    return sz;
}
 
 
int  send_https_Buffer(int sofd, SSL* ssl, tList* pl, Buffer* buf)
{
    int sz;
    Buffer snd;
 /*
    int nobody = FALSE;
 
    if (pl==NULL) return JBXL_ARGS_ERROR;
    if (buf==NULL || buf->vldsz<0 || buf->buf==NULL) nobody = TRUE;
 
    if (!nobody) {
        // Content-Length の書き換え
        tList* pp = pl;
        while(pp!=NULL) {
            if (!strcasecmp((const char*)(pp->ldat.key.buf), "Content-Length")) {
                copy_i2Buffer(buf->vldsz, &(pp->ldat.val));
                break;
            }
            pp = pp->next;
        }
    }
 
    snd = restore_protocol_header(pl, (char*)": ", OFF, NULL);
    if (!nobody) cat_Buffer(buf, &snd);
*/
    snd = rebuild_http_Buffer(pl, buf);
    sz  = ssl_tcp_send_Buffer(sofd, ssl, &snd);
    free_Buffer(&snd);
 
    return sz;
}
 
 
int  send_https_file(int sofd, SSL* ssl, tList* pl, const char* fname)
{
    int   sz = 0;
    FILE* fp = NULL;
    char num[20];
    tList* pp;
    unsigned char* html;
    Buffer  buf;
 
    size_t rs;
    UNUSED(rs);
 
    if (pl==NULL) return JBXL_ARGS_ERROR;
    if (fname!=NULL) sz = file_size((char*)fname);
    if (sz<=0) sz = 0;
    snprintf(num, 18, "%d", sz);
 
    // Content-Length の書き換え
    pp = pl;
    while(pp!=NULL) {
        if (!strcasecmp((const char*)(pp->ldat.key.buf), "Content-Length")) {
            copy_s2Buffer(num, &(pp->ldat.val));
            break;
        }
        pp = pp->next;
    }
 
    buf = restore_protocol_header(pl, (char*)": ", OFF, NULL);
 
    if (fname!=NULL && sz!=0) fp = fopen(fname, "rb");
    if (fp!=NULL) {
        html = (unsigned char*)malloc(sz+1);
        if (html==NULL) {
            fclose(fp);
            free_Buffer(&buf);
            return JBXL_MALLOC_ERROR;
        }
 
        memset(html, 0, sz+1);
        rs = fread(html, sz, 1, fp); 
        fclose(fp);
 
        cat_b2Buffer(html, &buf, sz);
        free(html);
    }
 
    sz = ssl_tcp_send_Buffer(sofd, ssl, &buf);
    free_Buffer(&buf);
 
    return sz;
}
 
 
int  recv_https_header(int sofd, SSL* ssl, tList** pl, int* len, int tm, FILE* fp, int* state)
{
    int  cc, sz, com;
    Buffer mbuf;
    tList* lp;
    int  connect = TRUE;
 
    if (sofd<=0)   return JBXL_ARGS_ERROR;
    if (len==NULL) return JBXL_ARGS_ERROR;
    *len = HTTP_HEADER_UNKNOWN_LEN;
 
    mbuf = make_Buffer(RECVBUFSZ);
 
    sz  = 0;
    lp  = NULL;
    *pl = NULL;
 
    cc  = ssl_tcp_recv_Buffer_wait(sofd, ssl, &mbuf, tm);
    com = get_http_method((char*)mbuf.buf);
 
    if (com>HTTP_UNKNOWN_METHOD) {
        Loop {
            if (cc>0) {
                if (fp!=NULL) fwrite(mbuf.buf, cc, 1, fp);
                lp = get_protocol_header_list_seq(lp, mbuf, ':', TRUE, TRUE);
                sz += cc;
                /*
                if (sz==cc) {       // is HTTPS?
                    tList* ll = find_tList_top(lp);
                    if (get_http_header_method(ll)==HTTP_UNKNOWN_METHOD) {
                        connect = HTTP_HEADER_NOT_HTTP;
                        *pl = ll;
                        break;
                    }
                }*/
            }
            else {
                connect = FALSE;
                break;
            }
 
            *pl = find_tList_top(lp);
            if (strncasecmp_tList(*pl, (char*)HDLIST_END_KEY, 0, 1)!=NULL) break;
            //
            cc = ssl_tcp_recv_Buffer_wait(sofd, ssl, &mbuf, tm);
        }
    }
    else {
        if (mbuf.vldsz>0) {
            Buffer key = make_Buffer_str(HDLIST_CONTENTS_KEY);
            *pl = add_tList_node_Buffer(NULL, key, mbuf);
            free_Buffer(&key);
        }
        *len = HTTP_HEADER_NOT_HTTP;
        connect = FALSE;
    }
 
    free_Buffer(&mbuf);
    if (*pl!=NULL) (*pl)->ldat.id = com;
    if (state!=NULL) *state = connect;
    //
    if (sz==0 && cc==0) return 0;      // 正常切断
    if (sz==0 && cc<0)  return JBXL_SSL_RECV_ERROR;
    if (*pl==NULL)      return JBXL_SSL_RECV_ERROR;
    if (*len==HTTP_HEADER_NOT_HTTP) return cc;
 
    // コンテンツの長さを得る．
    /*
    Buffer hbuf = search_protocol_header(*pl, (char*)HDLIST_FIRST_LINE_KEY, 1);
    if (hbuf.buf!=NULL) {
        if (!strncasecmp((char*)hbuf.buf, "GET ", 4)) {
            *len = 0;
        }
        free_Buffer(&hbuf);
    }*/
 
    if (com==HTTP_GET_METHOD) *len = 0;
 
    if (*len==HTTP_HEADER_UNKNOWN_LEN) {
        if (is_http_header_field(*pl, (char*)"Transfer-Encoding", (char*)"chunked", 1)) {
            *len = HTTP_HEADER_CHUNKED;
        }
    }
 
    if (*len==HTTP_HEADER_UNKNOWN_LEN) {
        Buffer hbuf = search_protocol_header(*pl, (char*)"Content-Length", 1);
        if (hbuf.buf!=NULL) {
            *len = atoi((const char*)hbuf.buf);
            free_Buffer(&hbuf);
        }
    }
 
    if (*len==HTTP_HEADER_UNKNOWN_LEN) {
        if (get_http_version_num(*pl)<=1.0 && get_http_status_num(*pl)>=200) {
            if (is_http_header_field(*pl, (char*)"Connection", (char*)"close", 1)) {
                *len = HTTP_HEADER_CLOSED_SESSION;
            }
        }
    }
 
    return sz;
}
 
 
int  recv_https_content(int sofd, SSL* ssl, Buffer* buf, int len, int tm, FILE* fp, int* state)
{
    int cc, sz;
    Buffer rcv;
 
    if (state!=NULL) *state = TRUE;
    sz = buf->vldsz;
    if (sz>0 && fp!=NULL) fwrite(buf->buf, sz, 1, fp);
 
    // コンテンツの残りを受信
    rcv = make_Buffer(RECVBUFSZ);
    while(sz<len) {
        //
        cc = ssl_tcp_recv_Buffer_wait(sofd, ssl, &rcv, tm);
        if (cc>0) {
            if (fp!=NULL) fwrite(rcv.buf, cc, 1, fp);
            cat_Buffer(&rcv, buf);
            sz += cc;
        }
        else {
            if (state!=NULL) *state = FALSE;
            sz = cc;
            break;
        }
        //memset(rcv.buf, 0, cc);
    }
 
    free_Buffer(&rcv);
    return sz;
}
 
 
int  recv_https_chunked(int sofd, SSL* ssl, Buffer* buf, int tm, FILE* fp, int* state)
{
    int cc, sz, i;
    int chnksz, hdsz, tlsz;
    if (state!=NULL) *state = TRUE;
 
    Buffer tmp = make_Buffer(RECVBUFSZ);
 
    sz = buf->vldsz;
    if (sz<=0) {    // chunk のサイズを含んだデータを読み込む
        cc = ssl_tcp_recv_Buffer_wait(sofd, ssl, &tmp, tm);
        if (cc<=0) {
            if (state!=NULL) *state = FALSE;
            free_Buffer(&tmp);
            return cc;
        }
    }
    else {          // 既にコンテンツがある場合は tmpへ移動 
        cat_Buffer(buf, &tmp);
        clear_Buffer(buf);
    }
 
    //
    chnksz = sz = get_chunked_size((char*)tmp.buf, &hdsz, &tlsz);
 
    while (chnksz>0) {
        //
        if (chnksz+hdsz+tlsz > tmp.vldsz) {
            cc = recv_https_chunked_remain(sofd, ssl, &tmp, chnksz+hdsz+tlsz, tm);
            if (cc<=0) {
                sz = cc;
                break;
            }
        }
    
        Buffer cat = tmp;
        cat.buf = tmp.buf + hdsz;
        cat.vldsz = chnksz;
        cat_Buffer(&cat, buf);
        //tmp.buf[tmp.vldsz] = '\0';
 
        // 次の chunk用にデータをつめる
        for (i=0; i<tmp.vldsz-chnksz-hdsz-tlsz; i++) {
            tmp.buf[i] = tmp.buf[chnksz + hdsz + tlsz + i];
        }
        tmp.vldsz = tmp.vldsz - chnksz - hdsz - tlsz;
        //tmp.buf[tmp.vldsz] = '\0';
 
        if (tmp.vldsz==0) {
            cc = ssl_tcp_recv_Buffer_wait(sofd, ssl, &tmp, tm);
            if (cc<=0) {
                sz = cc;
                break;
            }
        }
        chnksz = get_chunked_size((char*)tmp.buf, &hdsz, &tlsz);
        sz += chnksz;
    }
 
    if (fp!=NULL) fwrite(buf->buf, buf->vldsz, 1, fp);
 
    free_Buffer(&tmp);
    return sz;
}
 
 
int  recv_https_chunked_remain(int sofd, SSL* ssl, Buffer* buf, int chnksz, int tm)
{
    int cc = 0;
    int sz = buf->vldsz;
    if (chnksz<=sz) return 0;
 
    Buffer rcv = make_Buffer(RECVBUFSZ);
 
    while (chnksz>sz) {
        //memset(rcv.buf, 0, cc);
        cc = ssl_tcp_recv_Buffer_wait(sofd, ssl, &rcv, tm);
        if (cc<=0) {
            sz = cc;
            break;
        }
        cat_Buffer(&rcv, buf);
        sz += cc;
    }
 
    free_Buffer(&rcv);
    return sz;
}
 
 
int  recv_https_closed(int sofd, SSL* ssl, Buffer* buf, int tm, FILE* fp)
{
    int cc, sz, tout;
    Buffer rcv;
 
    sz = buf->vldsz;
 
    rcv = make_Buffer(RECVBUFSZ);
    while ((tout=recv_wait(sofd, tm))) {
        cc = ssl_tcp_recv_Buffer_wait(sofd, ssl, &rcv, tm);
        if (cc>0) {
            if (fp!=NULL) fwrite(rcv.buf, cc, 1, fp);
            cat_Buffer(&rcv, buf);
            sz += cc;
        }
        else {
            break;
        }
        //memset(rcv.buf, 0, cc);
    }
    free_Buffer(&rcv);
 
    if (!tout) return JBXL_NET_RECV_TIMEOUT;
 
    return sz;
}
 
 
int  recv_https_Buffer(int sofd, SSL* ssl, tList** pl, Buffer* buf, int tsecond, int* hdonly, int* state, int nochunk)
{
    int    cc=0, hs, len;
    int    connect;
    Buffer cnt;
    tList* lp;
    
    if (buf==NULL || buf->buf==NULL) return JBXL_ARGS_ERROR;
    if (hdonly!=NULL) *hdonly = FALSE;
 
    clear_Buffer(buf);
 
    // ヘッダの受信
    hs = recv_https_header(sofd, ssl, &lp, &len, tsecond, NULL, &connect);
    if (state!=NULL) *state = connect;
    if (hs<=0) return hs;                                           // エラー
    if (len==0 || len==HTTP_HEADER_UNKNOWN_LEN) {                   // ヘッダのみ
        if (hdonly!=NULL) *hdonly = TRUE;
        if (pl!=NULL) *pl = lp;
        else del_tList(&lp);
        return hs;
    }
 
    // ヘッダ中に紛れ込んだコンテンツの取り出し
    cnt = search_protocol_header(lp, (char*)HDLIST_CONTENTS_KEY, 1);
    if (cnt.buf!=NULL) {
        cc = cnt.vldsz;
        hs = hs - cc;
        copy_Buffer(&cnt, buf);
        free_Buffer(&cnt);
    }
 
    if (lp!=NULL && lp->ldat.id==HTTP_UNKNOWN_METHOD) {             // not HTTP
        *pl = lp;
        return cc;
    }
 
    // コンテンツの受信
    if (connect) {
        if (len>0) {
            cc = recv_https_content(sofd, ssl, buf, len, tsecond, NULL, &connect);
        }
        else if (len==HTTP_HEADER_CHUNKED) {
            connect = HTTP_HEADER_CHUNKED;
            if (!nochunk) {
                cc = recv_https_chunked(sofd, ssl, buf, tsecond, NULL, &connect);
            }
        }
        else {  //if (len==HTTP_HEADER_CLOSED_SESSION) {
            cc = recv_https_closed(sofd, ssl, buf, tsecond, NULL);
            connect = FALSE;
        }
    }
 
    // for Chunked
    if (!nochunk && is_http_header_field(lp, (char*)"Transfer-Encoding", (char*)"chunked", 1)) {
        delete_protocol_header(&lp, (char*)"Transfer-Encoding", 0); 
        char* str = itostr_ts(cc);
        add_protocol_header(lp, (char*)"Content-Length", str);   
        freeNull(str);
    }
 
    if (pl!=NULL) *pl = lp;
    else del_tList(&lp);
 
    if (cc>0) cc = cc + hs;
 
    if (state!=NULL) *state = connect;
    return cc;
}
 
 
int  recv_https_file(int sofd, SSL* ssl, tList** pl, const char* fname, const char* wdir, int tsecond, int* hdonly, int* state)
{
    int    cc=0, hs, len;
    Buffer buf, cnt;
    FILE*  fp = NULL;
    const char tmpd[] = "/tmp";
    int   connect;
 
    if (hdonly!=NULL) *hdonly = FALSE;
 
    // ヘッダの受信
    hs = recv_https_header(sofd, ssl, pl, &len, tsecond, NULL, &connect);
    if (state!=NULL) *state = connect;
    if (hs<=0) return hs;                                           // エラー
    if (len==0 || len==HTTP_HEADER_UNKNOWN_LEN) {                   // ヘッダのみ
        if (hdonly!=NULL) *hdonly = TRUE;
        return hs;
    }
 
    //PRINT_MESG("++ RECV HEADER ++++++++++\n");
    //print_tList(stderr, *pl);
    //PRINT_MESG("+++++++++++++++++++++++++\n");
 
    // ヘッダ中に紛れ込んだコンテンツの取り出し
    buf = make_Buffer(RECVBUFSZ);
    cnt = search_protocol_header(*pl, (char*)HDLIST_CONTENTS_KEY, 1);
    if (cnt.buf!=NULL) {
        /*DEBUG_MODE {
            if (len==HTTP_HEADER_CHUNKED) {
                char* line = get_line((char*)cnt.buf, 1);
                int chnksz = hexstr2i(line);
                PRINT_MESG("RECV_HTTPS_FILE: INFO: Chunk Size in Header = %d\n", chnksz);
                freeNull(line);
            }
        }*/
        cc = cnt.vldsz;
        hs = hs - cc;
        copy_Buffer(&cnt, &buf);
        free_Buffer(&cnt);
    }
 
    // コンテンツの受信
    if (connect) {
        if (len>0) {
            cc = recv_https_content(sofd, ssl, &buf, len, tsecond, NULL, &connect);
        }
        else if (len==HTTP_HEADER_CHUNKED) {
            cc = recv_https_chunked(sofd, ssl, &buf, tsecond, NULL, &connect);
            //PRINT_MESG("+++++++++ RECVSZ = %d\n", buf.vldsz);
        }
        else { //if (len==HTTP_HEADER_CLOSED_SESSION) {
            cc = recv_https_closed(sofd, ssl, &buf, tsecond, NULL);
            connect = FALSE;
        }
    }
 
    if (cc>0) {
        // コンテンツをファイルへ保存
        if (fname!=NULL) fp = fopen(fname, "wb");
        if (fp!=NULL) {
            fwrite(buf.buf, buf.vldsz, 1, fp);
            fclose(fp);
        }
        free_Buffer(&buf);
 
        //
        if (fname!=NULL) {
            buf = search_protocol_header(*pl, (char*)"Content-Encoding", 1);
 
            // Encoding 処理
            if (buf.buf!=NULL) {
                // gzip or deflate
                if (!strncasecmp((const char*)buf.buf, "gzip",    4) ||
                    !strncasecmp((const char*)buf.buf, "deflate", 7)) {
                    #ifdef DISABLE_ZLIB
                        DEBUG_MODE PRINT_MESG("RECV_HTTPS_FILE: WARNING: Content-Encoding is [%s]. But zlib is not installed!!\n", buf.buf);
                    #else
                        if (wdir==NULL) wdir = tmpd;
                        cc = gz_decode_file_replace(fname, wdir);
                        delete_protocol_header(pl, (char*)"Content-Encoding",  0);
 
                        // for chunked
                        if (is_http_header_field(*pl, (char*)"Transfer-Encoding", (char*)"chunked", 1)) {
                            delete_protocol_header(pl, (char*)"Transfer-Encoding", 0);  
                            char* str = itostr_ts(cc);
                            add_protocol_header(*pl, (char*)"Content-Length", str);  
                            freeNull(str);
                        }
                    #endif
                }
 
                else { 
                    DEBUG_MODE PRINT_MESG("RECV_HTTPS_FILE: WARNING: unknown Content-Encoding [%s]\n", buf.buf);
                }
                free_Buffer(&buf);
            }
            
            // No Encofing
            else {
                // for chunked
                if (is_http_header_field(*pl, (char*)"Transfer-Encoding", (char*)"chunked", 1)) {
                    delete_protocol_header(pl, (char*)"Transfer-Encoding", 0);  
                    char* str = itostr_ts(cc);
                    add_protocol_header(*pl, (char*)"Content-Length", str);  
                    freeNull(str);
                }
            }
        }
        cc = cc + hs;
    }
 
    if (state!=NULL) *state = connect;
    return cc;
}
 
 
int   save_https_xml(int cofd, SSL* ssl, tList** pl, tXML** xml, char** recvfn, const char* wdir, int timeout, int* state)
{
    int header;
 
    if (pl==NULL || recvfn==NULL) return 0;
 
    *pl = NULL;
    if (xml!=NULL) *xml = NULL;
    *recvfn = temp_filename(wdir, WORK_FILENAME_LEN);
   
    int cc = recv_https_file(cofd, ssl, pl, *recvfn, wdir, timeout, &header, state);
    if (cc<=0 || *pl==NULL) {
        free(*recvfn);
        *recvfn = NULL;
        if (cc==0) return 0;
        return JBXL_SSL_RECV_ERROR;
    }
 
    if (header) {
        free(*recvfn);
        *recvfn = NULL;
    }
    else {
 
        if (xml!=NULL && *pl!=NULL && *recvfn!=NULL && cc>0) {
            Buffer buf = search_protocol_header(*pl, (char*)"Content-Type", 1);
            *xml = xml_parse_file(*recvfn);
            if (*xml!=NULL && (*xml)->state<0) del_all_xml(xml);
            free_Buffer(&buf);
        }
    }
 
    return  cc;
}
 
 
#endif  //  ENABLE_SSL