http_tool.c

Go to the documentation of this file.

 
#ifdef CPLUSPLUS
    #undef CPLUSPLUS
#endif
 
 
#include "http_tool.h"
 
 
// Basic Function.  
//
 
int  send_http_header(int sofd, 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  = tcp_send_Buffer(sofd, &buf);
        if (mode==ON) sz = sz - hs;
    }
 
    free_Buffer(&buf);
    return sz;
}
 
 
Buffer  rebuild_http_Buffer(tList* pl, Buffer* buf)
{
    Buffer rbd;
    int nobody = FALSE;
 
    if (pl==NULL) {
        rbd = dup_Buffer(*buf);
        return rbd;
    }
    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;
        }
    }
 
    rbd = restore_protocol_header(pl, (char*)": ", OFF, NULL);
    if (!nobody) cat_Buffer(buf, &rbd);
 
    return rbd;
}
 
 
int  send_http_Buffer(int sofd, 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  = tcp_send_Buffer(sofd, &snd);
    free_Buffer(&snd);
 
    return sz;
}
 
 
int  send_http_file(int sofd, 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 = tcp_send_Buffer(sofd, &buf);
    free_Buffer(&buf);
 
    return sz;
}
 
 
int  recv_http_header(int sofd, 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  = tcp_recv_Buffer_wait(sofd, &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 HTTP ?
                    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  = tcp_recv_Buffer_wait(sofd, &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_NET_RECV_ERROR;
    if (*pl==NULL)      return JBXL_NET_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_http_content(int sofd, 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 = tcp_recv_Buffer_wait(sofd, &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_http_chunked(int sofd, 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 = tcp_recv_Buffer_wait(sofd, &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_http_chunked_remain(sofd, &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 = tcp_recv_Buffer_wait(sofd, &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_http_chunked_remain(int sofd, 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 = tcp_recv_Buffer_wait(sofd, &rcv, tm);
        if (cc<=0) {
            sz = cc;
            break;
        }
        cat_Buffer(&rcv, buf);
        sz += cc;
    }
 
    free_Buffer(&rcv);
    return sz;
}
 
 
int  recv_http_closed(int sofd, 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 = tcp_recv_Buffer(sofd, &rcv);
        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_http_Buffer(int sofd, 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_http_header(sofd, &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_http_content(sofd, buf, len, tsecond, NULL, &connect);
        }
        else if (len==HTTP_HEADER_CHUNKED) {
            connect = HTTP_HEADER_CHUNKED;
            if (!nochunk) {
                cc = recv_http_chunked(sofd, buf, tsecond, NULL, &connect);
            }
        }
        else {  //if (len==HTTP_HEADER_CLOSED_SESSION) {
            cc = recv_http_closed(sofd, 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_http_file(int sofd, 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_http_header(sofd, 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;
    }
 
    // ヘッダ中に紛れ込んだコンテンツの取り出し
    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_HTTP_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_http_content(sofd, &buf, len, tsecond, NULL, &connect);
        }
        else if (len==HTTP_HEADER_CHUNKED) {
            cc = recv_http_chunked(sofd, &buf, tsecond, NULL, &connect);
        }
        else {  //if (len==HTTP_HEADER_CLOSED_SESSION) {
            cc = recv_http_closed(sofd, &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_HTTP_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_HTTP_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_http_xml(int cofd, 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_http_file(cofd, pl, *recvfn, wdir, timeout, &header, state);
    if (cc<=0 || *pl==NULL) {
        free(*recvfn);
        *recvfn = NULL;
        if (cc==0) return 0;
        return JBXL_NET_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;
}
 
 
 
// Tools
//
 
int  get_http_method(char* data)
{
    if      (ex_strcmp("GET ", data))       return HTTP_GET_METHOD;
    else if (ex_strcmp("PUT ", data))       return HTTP_PUT_METHOD;
    else if (ex_strcmp("POST ", data))      return HTTP_POST_METHOD;
    else if (ex_strcmp("DELETE ", data))    return HTTP_DELETE_METHOD;
    else if (ex_strcmp("OPTIONS ", data))   return HTTP_OPTIONS_METHOD;
    else if (ex_strcmp("HEAD ", data))      return HTTP_HEAD_METHOD;
    else if (ex_strcmp("TRACE ", data))     return HTTP_TRACE_METHOD;
    else if (ex_strcmp("CONNECT ", data))   return HTTP_CONNECT_METHOD;
    else if (ex_strcmp("PATCH ", data))     return HTTP_PATCH_METHOD;
    else if (ex_strcmp("LINK ", data))      return HTTP_LINK_METHOD;
    else if (ex_strcmp("UNLINK ", data))    return HTTP_UNLINK_METHOD;
    else if (ex_strcmp("HTTP/", data))      return HTTP_RESPONSE_METHOD;
    // WebDAV
    else if (ex_strcmp("PROPFIND ", data))  return HTTP_PROPFIND_METHOD;
    else if (ex_strcmp("PROPPATCH ", data)) return HTTP_PROPPATCH_METHOD;
    else if (ex_strcmp("MKCOL ", data))     return HTTP_MKCOL_METHOD;
    else if (ex_strcmp("COPY ", data))      return HTTP_COPY_METHOD;
    else if (ex_strcmp("MOVE ", data))      return HTTP_MOVE_METHOD;
    else if (ex_strcmp("LOCK ", data))      return HTTP_LOCK_METHOD;
    else if (ex_strcmp("UNLOCK ", data))    return HTTP_UNLOCK_METHOD;
 
    return HTTP_UNKNOWN_METHOD;
}
 
 
int  is_http_header_field(tList* pl, char* field, char* value, int n)
{
    int ret = FALSE;
 
    Buffer hbuf = search_protocol_header(pl, field, n);
    if (hbuf.buf!=NULL) {
        if (!strcasecmp((char*)hbuf.buf, value)) {
            ret = TRUE;
        }
        free_Buffer(&hbuf);
    }
 
    return ret;
}
 
 
int  get_http_header_method(tList* pl)
{
    int ret = HTTP_UNKNOWN_METHOD;
 
    if (pl==NULL) return ret;
 
    Buffer hbuf = search_protocol_header(pl, (char*)HDLIST_FIRST_LINE_KEY, 1);
    if (hbuf.buf!=NULL) ret = get_http_method((char*)hbuf.buf);
 
    return ret;
}
 
 
void  set_http_host_header(tList* pl, char* hname, unsigned short hport)
{
    Buffer buf;
    char   num[LEN_INT];
    
    if (pl==NULL) return;
 
    buf = make_Buffer(LBUF);
    snprintf(num, LEN_INT-1, "%d", hport);
    copy_s2Buffer(hname, &buf);
    cat_s2Buffer (":",   &buf);
    cat_s2Buffer (num,   &buf);
 
    set_protocol_header(pl, (char*)"Host", (char*)buf.buf, 1, ON);
 
    free_Buffer(&buf);
    return;
}
 
 
void  dump_http_header(FILE* fp, tList* pp)
{
    if (fp==NULL) fp = stderr;
 
    if (pp!=NULL) {
        int image = FALSE;
        while(pp!=NULL) {
            tList_data ld = pp->ldat;
            if (!strcasecmp((const char*)ld.key.buf, "Content-Type")) {
                if (!strncasecmp((const char*)ld.val.buf, "image", 5)) image = TRUE;
                //else if (!strncasecmp((unsigned char*)ld.val.buf, "xxxx", 5)) image = TRUE;
            }
 
            if (!strcasecmp((const char*)ld.key.buf, HDLIST_CONTENTS_KEY) && image==TRUE) {
                fprintf(fp, "[%d] [%d] [%s] [%d]\n", ld.id, ld.lv, ld.key.buf, ld.val.vldsz);
                fdump(fp, (unsigned char*)ld.val.buf, ld.val.vldsz);
            }
            else {
                fprintf(fp, "[%d] [%d] [%s] [%s]\n", ld.id, ld.lv, ld.key.buf, ld.val.buf);
            }
            pp = pp->next;
        }
    }
    else {
        fprintf(fp, "(List is NULL)\n");
    }
    return;
}
 
 
int  get_chunked_size(char* ptr, int* hdsz, int* tlsz)
{
    int  ck = 0, hd = 0, tl = 0;
    char hex[L_32];
 
    int i = 0;
    while (ptr[i]!=0x0d && i<L_32) {
        hex[i] = ptr[i];
        i++;
    }
    if (i==L_32) {
        if (hdsz!=NULL) *hdsz = 0;
        if (tlsz!=NULL) *tlsz = 0;
        return -1;
    }
 
    if (ptr[i+1]==0x0a) hd = i + 2;
    else                hd = i + 1;
    if (hdsz!=NULL) *hdsz = hd;
 
    hex[i] = '\0';
    ck = hexstr2i(hex);
 
    if (ptr[ck+hd]==0x0d) {
        tl++;
        if (ptr[ck+hd+tl]==0x0a) tl++;
    }
    if (tlsz!=NULL) *tlsz = tl;
 
    return ck; 
}
 
 
// need free()
char*  get_http_header_date(time_t date) 
{
    char* buf = get_gmt_timestamp(date, "%a, %d %b %Y %H:%M:%S %Z");
 
    return buf;
}
 
 
 
// HTTP Simple Proxy
//
 
void  simple_web_proxy(int bofd, char* myip, int tmout)
{
    int    wofd = 0;
    int    len, nd, cc, state;
    int    btm, wtm, keep;
    char*  ipa;
    tList* pl;
 
    unsigned short sport = 0;
    Buffer  server, com;
 
    fd_set  mask;
    struct timeval timeout;
 
    //DEBUG_MODE PRINT_MESG("[%d] SIMPLE_WEB_PROXY: Start Simple WEB Proxy.\n", (int)getpid());
 
    //init_rand();
    if (tmout<0) tmout = HTTP_PROXY_TIMEOUT;
    btm = wtm = tmout;
    keep = TRUE;
 
    do {
        timeout.tv_sec  = btm*10;
        timeout.tv_usec = 0;
        FD_ZERO(&mask); 
        FD_SET(bofd, &mask);
        nd = select(bofd+1, &mask, NULL, NULL, &timeout);
    } while (nd<0);
 
    while (FD_ISSET(bofd, &mask) && keep) {
        cc = recv_http_header(bofd, &pl, &len, tmout, NULL, &state);
        if (cc<=0) break;
        if (pl==NULL) break;
 
        /*
        DEBUG_MODE {
            PRINT_MESG("[%d] --- Web Proxy Request ---\n", getpid());
            print_tList(stderr, pl);
            PRINT_MESG("\n");
        }*/
 
        com = http_proxy_header_analyze(pl, &server, &sport, &btm, &keep);
        if (btm==0) btm = tmout;
        else        btm = Min(btm, 60);
 
        wofd = 0;
        if (server.buf!=NULL && sport!=0) {
            ipa = get_ipaddr_byname((char*)server.buf, AF_INET);
            if (ipa!=NULL && !strcmp(ipa, myip)) {
                free_Buffer(&server);
                server = make_Buffer_bystr("127.0.0.1");
            }
            freeNull(ipa);
 
            wofd = tcp_client_socket((char*)server.buf, sport);
            free_Buffer(&server);
        }
 
        if (wofd<=0) {
            free_Buffer(&com);
            del_tList(&pl);
            break;
        }
 
        // for HTTPS
        if (com.buf!=NULL && !strcasecmp((char*)com.buf, "CONNECT")) {
            cc = tcp_send(bofd, (char*)"HTTP/1.1 200 Connection established.\r\nProxy-Connection: close\r\n\r\n", 0);
            cc = tcp_relay(bofd, wofd, 5);
 
            del_tList(&pl);
            free_Buffer(&com);
            break;
        }
        free_Buffer(&com);
 
        cc = send_http_header(wofd, pl, ON);
        if (cc<len && state) {
            Buffer buf = make_Buffer(RECVBUFSZ);
            cc = recv_http_content(bofd, &buf, len-cc, wtm, NULL, &state);
            if (cc<=0) {
                del_tList(&pl);
                break;
            }
 
            tcp_send_Buffer(wofd, &buf);
            free_Buffer(&buf);
        }
        del_tList(&pl);
 
        cc = www2browser_relay(bofd, wofd, btm, wtm, keep);
        if (cc<=0) break;
 
        do {
            timeout.tv_sec  = btm;
            timeout.tv_usec = 0;
            FD_ZERO(&mask); 
            FD_SET(bofd, &mask);
            nd = select(bofd+1, &mask, NULL, NULL, &timeout);
        } while (nd<0);
    }
 
    socket_close(wofd);
 
    return;
}
 
 
Buffer  http_proxy_header_analyze(tList* pl, Buffer* server, unsigned short* sport, int* timeout, int* keep)
{
    tList*  frst;
    tList*  lst;
    Buffer  cmnd, url, ptcl;
    Buffer  srvdir, bufport;
 
    cmnd     = init_Buffer();
    srvdir   = init_Buffer();
    *server  = init_Buffer();
    *sport   = 0;
    *timeout = 0;
    *keep    = FALSE;
 
    frst = strncasecmp_tList(pl, (char*)HDLIST_FIRST_LINE_KEY, 0, 1);
    if (frst!=NULL) {
        cmnd = cawk_Buffer(frst->ldat.val, ' ', 1);
        url  = cawk_Buffer(frst->ldat.val, ' ', 2);
        ptcl = cawk_Buffer(frst->ldat.val, ' ', 3);
        decomp_url(url, NULL, NULL, server, sport, &srvdir);
    }
    else return cmnd;
 
    if (server->buf==NULL) {
        lst = strncasecmp_tList(pl, (char*)"Host", 0, 1);
        if (lst!=NULL) {
            *server = cawk_Buffer(lst->ldat.val, ':', 1);
            bufport = cawk_Buffer(lst->ldat.val, ':', 2);
            if (bufport.buf!=NULL) *sport = atoi((char*)bufport.buf);
            free_Buffer(&bufport);
        }
    }
    if (*sport==0) *sport = 80;
 
    lst = strncasecmp_tList(pl, (char*)"Keep-Alive", 0, 1);
    if (lst!=NULL) {
        if (lst->ldat.val.buf!=NULL) *timeout = atoi((char*)(lst->ldat.val.buf));
        del_tList_node(&lst);
    }
 
    lst = strncasecmp_tList(pl, (char*)"Proxy-Connection", 0, 1);
    if (lst!=NULL) {
        if (!strcasecmp((char*)(lst->ldat.val.buf), "keep-alive")) *keep = TRUE;
        del_tList_node(&lst);
    }
 
    free_Buffer(&(frst->ldat.val));
    copy_Buffer (&cmnd, &(frst->ldat.val));
    cat_s2Buffer(" ", &(frst->ldat.val));
    cat_Buffer  (&srvdir, &(frst->ldat.val));
    cat_s2Buffer(" ", &(frst->ldat.val));
    cat_Buffer  (&ptcl, &(frst->ldat.val));
 
    free_Buffer(&url);
    free_Buffer(&ptcl);
    free_Buffer(&srvdir);
 
    return cmnd;
}
 
 
int  www2browser_relay(int bofd, int wofd, int btm, int wtm, int keep)
{
    int    len, cc, cx, sz, tout, state;
    Buffer buf;
    tList* pl;
    tList* lst;
 
    if (!recv_wait(wofd, wtm*10)) return JBXL_NET_RECV_TIMEOUT;
    cc = recv_http_header(wofd, &pl, &len, wtm, NULL, &state);
    if (cc<=0) {
        if (pl!=NULL) del_tList(&pl);
        return cc;
    }
    if (pl==NULL) return JBXL_NET_RECV_ERROR;
 
    /*
    DEBUG_MODE {
        PRINT_MESG("[%d] --- Web Proxy Response --\n", getpid());
        print_tList(stderr, pl);
        PRINT_MESG("\n");
    }*/
 
    lst = strncasecmp_tList(pl, (char*)HDLIST_END_KEY, 0, 1);
    if (lst!=NULL && lst->prev!=NULL) {
        if (keep) {
            char   pxcn[48];
            snprintf(pxcn, 46, "keep-alive, timeout=%d", btm);
            add_tList_node_str(lst->prev, "Proxy-Connection", pxcn);
        }
        else {
            add_tList_node_str(lst->prev, "Proxy-Connection", "close");
        }
    }
 
    sz = cx = send_http_header(bofd, pl, ON);
    del_tList(&pl);
 
    if (len>0) {
        buf = make_Buffer(RECVBUFSZ);
        while(sz<len) {
            if (!recv_wait(wofd, wtm)) {
                free_Buffer(&buf);
                return JBXL_NET_RECV_TIMEOUT;
            }
            cc = tcp_recv_Buffer(wofd, &buf);
            if (cc>0) {
                sz += cc;
                cx = tcp_send_Buffer(bofd, &buf);
                if (cx<=0) break;
            }
            else break;
        }
 
        free_Buffer(&buf);
        if (cc<=0 || (cc>0&&cx<=0)) return 0;
    }
 
    else if (len==HTTP_HEADER_CHUNKED || len==HTTP_HEADER_CLOSED_SESSION) {
        buf = make_Buffer(RECVBUFSZ);
        while ((tout=recv_wait(wofd, 1))){
            cc = tcp_recv_Buffer(wofd, &buf);
            if (cc>0) {
                sz += cc;
                cx = tcp_send_Buffer(bofd, &buf);
                if (cx<=0) break;
            }
            else break;
        }
 
        free_Buffer(&buf);
        if (!tout) return JBXL_NET_RECV_TIMEOUT;
        return 0;
    }
 
    return sz;
}
 
 
 
// Alternative Tools
//
 
int  tcp_relay(int sofd, int cofd, int tm)
{
    int     num, nd, cx, cc = JBXL_NET_RECV_TIMEOUT;
    Buffer  buf;
    fd_set  mask;
    struct timeval timeout;
 
    buf = make_Buffer(RECVBUFSZ);
    num = Max(sofd, cofd);
 
    do {
        timeout.tv_sec  = tm;
        timeout.tv_usec = 0;
        FD_ZERO(&mask); 
        FD_SET(sofd, &mask);
        FD_SET(cofd, &mask);
        nd = select(num+1, &mask, NULL, NULL, &timeout);
    } while (nd<0);
 
    //while (FD_ISSET(cofd, &mask) || FD_ISSET(sofd, &mask)) {
    while (nd>0 && (FD_ISSET(cofd, &mask) || FD_ISSET(sofd, &mask))) {
 
        if (FD_ISSET(cofd, &mask)) {
            cc = tcp_recv_Buffer(cofd, &buf);
            if (cc>0) {
                cx = tcp_send_Buffer(sofd, &buf);
                if (cx<=0) {
                    cc = cx;
                    break;
                }
            }
            else break;
            //memset(buf.buf, 0, cc);
        }
 
        if (FD_ISSET(sofd, &mask)) {
            cc = tcp_recv_Buffer(sofd, &buf);
            if (cc>0) {
                cx = tcp_send_Buffer(cofd, &buf);
                if (cx<=0) {
                    cc = cx;
                    break;
                }
            }
            else break;
            //memset(buf.buf, 0, cc);
        }
 
        do {
            timeout.tv_sec  = tm;
            timeout.tv_usec = 0;
            FD_ZERO(&mask); 
            FD_SET(sofd, &mask);
            FD_SET(cofd, &mask);
            nd = select(num+1, &mask, NULL, NULL, &timeout);
        } while (nd<0);
    }
 
    free_Buffer(&buf);
 
    if (!FD_ISSET(cofd, &mask) && !FD_ISSET(sofd, &mask)) return JBXL_NET_RECV_TIMEOUT;
    return cc;
}
 
 
int  get_http_status_num(tList* pl)
{
    int pnum = 0;
 
    Buffer dat = search_protocol_header(pl, (char*)HDLIST_FIRST_LINE_KEY, 1);
    if (dat.buf!=NULL) {
        if (!strncasecmp((const char*)dat.buf, "HTTP/", 5)) {
            Buffer num = cawk_Buffer(dat, ' ', 2);
            if (num.buf!=NULL) {
                pnum = atoi((const char*)num.buf);
                free_Buffer(&num);
            }
        }
        free_Buffer(&dat);
    }
 
    return pnum;
}
 
 
float  get_http_version_num(tList* pl)
{
    float ver = 0.0;
 
    Buffer dat = search_protocol_header(pl, (char*)HDLIST_FIRST_LINE_KEY, 1);
    if (dat.buf!=NULL) {
        if (!strncasecmp((const char*)dat.buf, "HTTP/", 5)) {
            Buffer num = cawk_Buffer(dat, ' ', 1);
            if (num.buf!=NULL) {
                ver = (float)atof((char*)&num.buf[5]);
                free_Buffer(&num);
            }
        }
        else {
            Buffer buf = cawk_Buffer(dat, ' ', 3);
            if (!strncasecmp((const char*)buf.buf, "HTTP/", 5)) {
                Buffer num = cawk_Buffer(buf, ' ', 1);
                if (num.buf!=NULL) {
                    ver = (float)atof((char*)&num.buf[5]);
                    free_Buffer(&num);
                }
            }
            free_Buffer(&buf);
        }
        free_Buffer(&dat);
    }
 
    return ver;
}
 
 
 
// Server Side Code  (Junk)
//
 
int  send_http_res_file(int sofd, char* fname, int mode)
{
    int   sz;
    FILE* fp;
    char  buf[LBUF];
    char* html;
    size_t rs;
    UNUSED(rs);
 
    sz = file_size(fname);
    if (sz<=0) {
        sz = 0;
        mode = HTTP_CONNECTION_CLOSE;
    }
 
    tcp_send(sofd, (char*)"HTTP/1.1 200 OK\r\n", 0);
    tcp_send(sofd, (char*)"Accept-Ranges: bytes\r\n", 0);
    tcp_send(sofd, (char*)"Pragma: no-cache\r\n", 0);
    tcp_send(sofd, (char*)"Cache-Control: no-cache\r\n", 0);
    memset(buf, 0, LBUF);
    snprintf(buf, LBUF-2, "Content-Length: %d\r\n", sz);
    tcp_send(sofd, buf, 0);
    if (mode==HTTP_CONNECTION_CLOSE) tcp_send(sofd, (char*)"Connection: Close\r\n", 0);
    else {
        tcp_send(sofd, (char*)"Keep-Alive: timeout=1800, max=100\r\n", 0);
        tcp_send(sofd, (char*)"Connection: Keep-Alive\r\n", 0);
    }
    tcp_send(sofd, (char*)"\r\n", 0);
 
    if (sz!=0) fp = fopen(fname, "rb");
    else       fp = NULL;
    if (fp==NULL) return JBXL_FILE_OPEN_ERROR;
 
    html = (char*)malloc(sz);
    if (html==NULL) {
        fclose(fp);
        return JBXL_MALLOC_ERROR;
    }
    memset(html, 0, sz);
 
    rs = fread(html, sz, 1, fp); 
    tcp_send(sofd, html, sz);
    fclose(fp);
 
    free(html);
    return sz;
}
 
 
void  send_http_passwd_req(int sofd)
{
    tcp_send(sofd, (char*)"HTTP/1.1 401 Authorization Required\r\n", 0);
    tcp_send(sofd, (char*)"WWW-Authenticate: Basic realm=\"TTS\"\r\n", 0);
    tcp_send(sofd, (char*)"Pragma: no-cache\r\n", 0);
    tcp_send(sofd, (char*)"Cache-Control: no-cache\r\n", 0);
    tcp_send(sofd, (char*)"Connection: Close\r\n", 0);
    tcp_send(sofd, (char*)"Content-Length: 0\r\n", 0);
    tcp_send(sofd, (char*)"Content-Type: text/html\r\n\r\n", 0);
    
    return;
}