xtools.cpp

Go to the documentation of this file.

 
#include "xtools.h"
 
 
// Networks for IPv4 互換用
//
 
int  udp_recv_Buffer_sockaddr_in(int sock, Buffer* str, struct sockaddr_in* sv_addr)
{
    int cc, cadlen;
 
    if (sv_addr==NULL) return JBXL_ARGS_ERROR;
 
    cadlen = sizeof(*sv_addr);
    memset(str->buf, 0, str->bufsz);
    str->vldsz = 0;
    str->state = JBXL_NORMAL;
    cc = recvfrom(sock, (char*)str->buf, str->bufsz, 0, (struct sockaddr*)sv_addr, (socklen_t*)&cadlen);
 
    if (cc>=0) str->vldsz = cc;
    else       str->state = cc = JBXL_NET_RECV_ERROR;
 
    return cc;
}
 
 
int  udp_send_Buffer_sockaddr_in(int sock, Buffer* str, struct sockaddr_in* sv_addr)
{
    int cc;
 
    if (sv_addr==NULL) return JBXL_ARGS_ERROR;
    
    if (str->vldsz<0) str->vldsz = (int)strlen((const char*)str->buf);
    cc = sendto(sock, (char*)str->buf, str->vldsz, 0, (struct sockaddr*)sv_addr, sizeof(*sv_addr));
 
    if (cc<0) cc = JBXL_NET_SEND_ERROR;
    return cc;
}
 
 
int  udp_send_sBuffer_sockaddr_in(int sock, Buffer* str, struct sockaddr_in* sv_addr)
{
    int cc;
 
    if (sv_addr==NULL) return JBXL_ARGS_ERROR;
    
    cc = sendto(sock, (char*)str->buf, (int)strlen((const char*)str->buf), 0, (struct sockaddr*)sv_addr, sizeof(*sv_addr));
    if (cc<0) cc = JBXL_NET_SEND_ERROR;
 
    return cc;
}
 
 
int  udp_recv_Buffer_wait_sockaddr_in(int sock, Buffer* str, struct sockaddr_in* sv_addr, int tm)
{
    int cc;
 
    if (sv_addr==NULL) return JBXL_ARGS_ERROR;
 
    //memset(str->buf, 0, str->bufsz);
    str->vldsz = 0;
    cc = udp_recv_wait_sockaddr_in(sock, (char*)str->buf, str->bufsz, sv_addr, tm);
    if (cc>=0) str->vldsz = cc;
 
    return cc;
}
 
 
struct sockaddr_in  get_sockaddr_in_Buffer(Buffer buf)
{
    int i, port = 0;
    struct sockaddr_in  addr;
    memset(&addr, 0, sizeof(struct sockaddr_in));
 
    if (buf.buf==NULL) return addr;
    
    i = 0;
    while (buf.buf[i]!='\0' && buf.buf[i]!=':') i++;
    buf.buf[i] = '\0';
 
    port = atoi((char*)&buf.buf[i+1]);
    addr = get_sockaddr_in((char*)buf.buf, port);
 
    return addr;
}
 
 
/*
Buffer get_hostport_sockaddr_in(struct sockaddr_in addr)
{
    Buffer buf;
    char  hostport[LBUF];
    char* ip = get_ipaddr_ipv4(addr.sin_addr);
    unsigned short port = ntohs(addr.sin_port);
 
    snprintf(hostport, LBUF, "%s:%d", ip, port);
    
    buf = make_Buffer_bystr(hostport);
    return buf;
}
*/
 
 
 
// Networks for IPv4/IPv6 
//
 
int  udp_recv_Buffer(int sock, Buffer* str, struct addrinfo* sv_addr)
{
    int cc;
    socklen_t cadlen;
 
    if (str==NULL || str->buf==NULL) return JBXL_ARGS_ERROR;
    if (sv_addr==NULL) return JBXL_ARGS_ERROR;
 
    cadlen = (int)sv_addr->ai_addrlen;
    memset(str->buf, 0, str->bufsz);
    str->vldsz = 0;
    str->state = JBXL_NORMAL;
    cc = recvfrom(sock, (char*)str->buf, str->bufsz, 0, sv_addr->ai_addr, &cadlen);
 
    if (cc>=0) str->vldsz = cc;
    else       str->state = cc = JBXL_NET_RECV_ERROR;
 
    return cc;
}
 
 
int  udp_send_Buffer(int sock, Buffer* str, struct addrinfo* sv_addr)
{
    int cc;
 
    if (str==NULL || str->buf==NULL) return JBXL_ARGS_ERROR;
    if (sv_addr==NULL) return JBXL_ARGS_ERROR;
    
    if (str->vldsz<0) str->vldsz = (int)strlen((const char*)str->buf);
    cc = sendto(sock, (char*)str->buf, str->vldsz, 0, sv_addr->ai_addr, (int)sv_addr->ai_addrlen);
 
    if (cc<0) cc = JBXL_NET_SEND_ERROR;
 
    return cc;
}
 
 
int  tcp_recv_Buffer(int sock, Buffer* str)
{
    int cc;
 
    if (str==NULL || str->buf==NULL) return JBXL_ARGS_ERROR;
 
    memset(str->buf, 0, str->bufsz);
    str->vldsz = 0;
    str->state = JBXL_NORMAL;
    cc = recv(sock, (char*)str->buf, str->bufsz, 0);
 
    if (cc>=0) str->vldsz = cc;
    else       str->state = cc = JBXL_NET_RECV_ERROR;
 
    return cc;
}
 
 
int  tcp_send_Buffer(int sock, Buffer* str)
{
    int cc;
 
    if (str==NULL || str->buf==NULL) return JBXL_ARGS_ERROR;
 
    if (str->vldsz<0) str->vldsz = (int)strlen((const char*)str->buf);
    cc = send(sock, (char*)str->buf, str->vldsz, 0);
 
    if (cc<0) cc = JBXL_NET_SEND_ERROR;
    return cc;
}
 
 
int  udp_recv_Buffer_wait(int sock, Buffer* str, struct addrinfo* sv_addr, int tm)
{
    int cc;
 
    if (str==NULL || str->buf==NULL) return JBXL_ARGS_ERROR;
    if (sv_addr==NULL) return JBXL_ARGS_ERROR;
 
    //memset(str->buf, 0, str->bufsz);
    str->vldsz = 0;
    cc = udp_recv_wait(sock, (char*)str->buf, str->bufsz, sv_addr, tm);
    if (cc>=0) str->vldsz = cc;
 
    return cc;
}
 
 
int  tcp_recv_Buffer_wait(int sock, Buffer* str, int tm)
{
    int cc;
 
    if (str==NULL || str->buf==NULL) return JBXL_ARGS_ERROR;
 
    //memset(str->buf, 0, str->bufsz);
    str->vldsz = 0;
    cc = tcp_recv_wait(sock, (char*)str->buf, str->bufsz, tm);
    if (cc>=0) str->vldsz = cc;
 
    return cc;
}
 
 
int  tcp_recv_Buffer_tosize(int sock, Buffer* str, Buffer* mod, int size)
{
    int cc, sz;
    int modon = FALSE;
 
    if (str==NULL || str->buf==NULL) return JBXL_ARGS_ERROR;
    if (mod!=NULL && mod->buf!=NULL) modon = TRUE;
 
    if (modon) memset(mod->buf, 0, mod->vldsz);
    Buffer buf = make_Buffer(RECVBUFSZ);
 
    sz = str->vldsz;
    while (sz<size) {
        cc = tcp_recv_Buffer(sock, &buf);
        if (cc>0) {
            cat_Buffer(&buf, str);
            sz += cc;
        }
        else {
            if (cc<0) sz = cc;
            break;
        }
    }
    free_Buffer(&buf);
 
    if (sz>size && modon) {
        copy_b2Buffer((void*)(str->buf+size), mod, sz-size);
        str->vldsz = size;
    }
    return sz;
}
 
 
int  tcp_recv_Buffer_tosize_wait(int sock, Buffer* str, Buffer* mod, int size, int tm)
{
    int cc, sz;
    int modon = FALSE;
 
    if (str==NULL || str->buf==NULL) return JBXL_ARGS_ERROR;
    if (mod!=NULL && mod->buf!=NULL) modon = TRUE;
 
    if (modon) memset(mod->buf, 0, mod->vldsz);
    Buffer buf = make_Buffer(RECVBUFSZ);
 
    sz = str->vldsz;
    while (sz<size) {
        cc = tcp_recv_Buffer_wait(sock, &buf, tm);
        if (cc>0) {
            cat_Buffer(&buf, str);
            sz += cc;
        }
        else {
            if (cc<0) sz = cc;
            break;
        }
    }
    free_Buffer(&buf);
 
    if (sz>size && modon) {
        copy_b2Buffer((void*)(str->buf+size), mod, sz-size);
        str->vldsz = size;
    }
    return sz;
}
 
 
int  udp_send_sBuffer(int sock, Buffer* str, struct addrinfo* sv_addr)
{
    int cc;
 
    if (str==NULL || str->buf==NULL) return JBXL_ARGS_ERROR;
    if (sv_addr==NULL) return JBXL_ARGS_ERROR;
    
    cc = sendto(sock, (char*)str->buf, (int)strlen((const char*)str->buf), 0, sv_addr->ai_addr, (int)sv_addr->ai_addrlen);
    if (cc<0) cc = JBXL_NET_SEND_ERROR;
 
    return cc;
}
 
 
int  tcp_send_sBuffer(int sock, Buffer* str)
{
    int cc;
 
    if (str==NULL || str->buf==NULL) return JBXL_ARGS_ERROR;
 
    cc = send(sock, (char*)str->buf, (int)strlen((const char*)str->buf), 0);
    return cc;
}
 
 
int  tcp_send_sBufferln(int sock, Buffer* str)
{
    int   cc;
    Buffer buf;
 
    if (str==NULL || str->buf==NULL) return JBXL_ARGS_ERROR;
 
    buf = dup_Buffer(*str);
    cat_s2Buffer("\r\n", &buf);
    cc = send(sock, (char*)buf.buf, (int)strlen((const char*)buf.buf), 0);
    free_Buffer(&buf);
 
    return cc;
}
 
 
int  tcp_recv_mstream_Buffer(int sock, Buffer* mesg, mstream* sb, int tm)
{
    int    cc;
    unsigned char* pp;
 
    if (mesg==NULL || sb==NULL) return JBXL_ARGS_ERROR;
    *mesg = make_Buffer(LBUF);
 
    if (sb->buf==NULL) {
        *sb = make_mstream(RECVBUFSZ);
        if (sb->buf==NULL) return JBXL_MALLOC_ERROR;
    }
 
    while (sb->datano==0) {
        cc = tcp_recv_Buffer_wait(sock, mesg, tm);
        if (cc<=0) {
            free_Buffer(mesg);
            return cc;
        }
        put_mstream(sb, mesg->buf);
        clear_Buffer(mesg);
    }
 
    pp = get_mstream(sb);
    if (pp==NULL) return JBXL_NET_BUF_ERROR;
    copy_s2Buffer((char*)pp, mesg);
    free(pp);
 
    return mesg->vldsz;
}
 
 
int  tcp_recv_lines_Buffer(int sock, Buffer* mesg, int tm)
{
    int    cc;
    Buffer buf;
 
    if (mesg==NULL) return JBXL_ARGS_ERROR;
    buf = make_Buffer(LBUF);
 
    cc = tcp_recv_Buffer_wait(sock, &buf, tm);
    while (cc>0) {
        cat_Buffer(&buf, mesg);
        if (buf.buf[cc-1]==CHAR_LF) break;
        clear_Buffer(&buf);
        cc = tcp_recv_Buffer_wait(sock, &buf, tm);
    }
    free_Buffer(&buf);
        
    if (cc<=0) {
        free_Buffer(mesg);
        return cc;
    }
 
    return mesg->vldsz;
}
 
 
 
// for URL
//
 
Buffer  comp_hostport(char* host, unsigned short port)
{
    Buffer buf;
    char   hostport[LBUF];
 
    hostport[0] = '\0';
 
    if (host!=NULL) {
        if (port!=0) snprintf(hostport, LBUF-1, "%s:%d", host, port);
        else         snprintf(hostport, LBUF-1, "%s", host);
    }
    else {
        if (port!=0) snprintf(hostport, LBUF-1, "%d", port);
    }
 
    buf = make_Buffer_bystr(hostport);
 
    return buf;
}
 
 
int  decomp_hostport(Buffer buf, Buffer* host, unsigned short* port)
{
    if (buf.buf==NULL) return FALSE;
 
    if (port!=NULL) {
        int i = 0;
        while (buf.buf[i]!='\0' && buf.buf[i]!=':') i++;
        if (buf.buf[i]!='\0') *port = (unsigned short)atoi((char*)&buf.buf[i+1]);
        else *port = 0;
    }
 
    if (host!=NULL) {
        Buffer hostport = dup_Buffer(buf);
    
        int i = 0;
        while (hostport.buf[i]!='\0' && hostport.buf[i]!=':') i++;
        hostport.buf[i] = '\0';
        hostport.vldsz  = (int)strlen((char*)hostport.buf);
        *host = hostport;
    }
 
    return TRUE;
}
 
 
Buffer  comp_url(char* protocol, char* host, unsigned short port, char* dir)
{
    Buffer url;
    char   num[20];
 
    url = make_Buffer(LNAME);
 
    if (protocol!=NULL) {
        copy_s2Buffer(protocol, &url);
        cat_s2Buffer("://", &url);
    }
 
    cat_s2Buffer(host, &url);
 
    if (port!=0) {
        snprintf(num, 10, ":%d", port);
        cat_s2Buffer(num, &url);
    }
 
    if (dir!=NULL) {
        if (dir[0]!='/') cat_s2Buffer("/", &url);
        cat_s2Buffer(dir, &url);
    }
 
    return url;
}
 
 
int  decomp_url(Buffer url, Buffer* srvurl, Buffer* protocol, Buffer* srvfqdn, unsigned short* sport, Buffer* srvdir)
{
    Buffer item1, item2, item3, item4, wrk;
 
    if (srvurl  !=NULL) *srvurl   = init_Buffer();
    if (protocol!=NULL) *protocol = init_Buffer();
    if (srvfqdn !=NULL) *srvfqdn  = init_Buffer();
    if (srvdir  !=NULL) *srvdir   = init_Buffer();
    if (sport   !=NULL) *sport    = 0;
    if (url.buf ==NULL) return FALSE;
 
    item1 = init_Buffer();
    item2 = init_Buffer();
    item3 = init_Buffer();
    item4 = init_Buffer();
     
    if (strstr((char*)url.buf, "://")!=NULL) {
        // http(s)://www.tuis.ac.jp:8100/..... 
        item1 = awk_Buffer(url, '/', 1);    // http(s):
        item2 = awk_Buffer(url, '/', 3);    // www.tuis.ac.jp:8100
        if (protocol!=NULL) {
            *protocol = dup_Buffer(item1);
            protocol->buf[protocol->vldsz-1] = '\0';
            protocol->vldsz--;
        }
    }
    else {
        // www.tuis.ac.jp:8100/..... 
        item2 = awk_Buffer(url, '/', 1);    // www.tuis.ac.jp:8100
    }
 
    if (item2.buf!=NULL) {
        item3 = awk_Buffer(item2, ':', 1);  // www.tuis.ac.jp
        if (item3.buf==NULL) {
            free_Buffer(&item1);
            free_Buffer(&item2);
            return FALSE;
        }
        item4 = awk_Buffer(item2, ':', 2);  // 8100
    }
    else {
        free_Buffer(&item1);
        return FALSE;
    }
 
    if (item4.buf!=NULL && sport!=NULL) {
        *sport = (unsigned short)atoi((char*)item4.buf);
    }
     
    wrk = make_Buffer(LBUF);
    if (item1.buf!=NULL) {
        copy_Buffer(&item1, &wrk);
        cat_s2Buffer("//",  &wrk);
    }
    cat_Buffer(&item2,  &wrk);
 
    if (item3.buf!=NULL) {
        if (srvfqdn!=NULL) *srvfqdn = item3;
        else free_Buffer(&item3);
    }
     
    if (srvdir!=NULL) {
        *srvdir = make_Buffer_bystr((char*)(url.buf+strlen((char*)(wrk.buf))));
        if ((srvdir->buf)[0]=='\0') copy_s2Buffer("/", srvdir);
    }
 
    if (srvurl!=NULL) *srvurl = wrk;
    else free_Buffer(&wrk);
 
    free_Buffer(&item1);
    free_Buffer(&item2);
    free_Buffer(&item4);
     
    return TRUE;
}                                           
 
 
Buffer  make_form_urlenc(const char* key, const char* val)
{
    Buffer buf = init_Buffer();
    if (key==NULL) return buf;
 
    buf = make_Buffer_str(key);
    cat_s2Buffer("=", &buf);
 
    if (val!=NULL) {
        unsigned char* val_enc = encode_urlenc((unsigned char*)val, -1);
        if (val_enc!=NULL) {
            cat_s2Buffer(val_enc, &buf);
            free(val_enc);
        }
    }
    
    return buf;
}
 
 
void   add_form_urlenc(Buffer* buf, const char* key, const char* val)
{
    if (buf==NULL || key==NULL) return;
 
    cat_s2Buffer("&", buf);
    cat_s2Buffer(key, buf);
    cat_s2Buffer("=", buf);
 
    if (val!=NULL) {
        unsigned char* val_enc = encode_urlenc((unsigned char*)val, -1);
        if (val_enc!=NULL) {
            cat_s2Buffer(val_enc, buf);
            free(val_enc);
        }
    }
 
    return;
}
 
 
 
// File I/O 
//
 
int   save_tagged_Buffer(Buffer buf, FILE* fp, unsigned int mode, int prfm)
{    
    int     cc;
    Buffer  tag, enc;
 
    tag = make_Buffer(2);
    if (tag.buf==NULL) return FALSE;
    tag.buf[0] = mode & 0x0f;            // データの種別
    tag.buf[1] = mode & 0xf0;            // データの形式
 
    // JBXL_FIO_ORIGINAL, JBXL_FIO_BASE64 以外は未サポート
    if (tag.buf[1]==JBXL_FIO_ORIGINAL || !prfm) {
        enc = dup_Buffer(buf);
    }
    else if (tag.buf[1]==JBXL_FIO_BASE64) {
        enc = encode_base64_Buffer(buf);
    }
    else {                            
        enc = dup_Buffer(buf);
    }
 
    tag.vldsz = 2;
    cc = save_Buffer2_format_fp(tag, enc, fp); 
    free_Buffer(&enc);
    free_Buffer(&tag);
 
    if (!cc) return FALSE;
    return  TRUE;
}
 
 
Buffer  read_tagged_Buffer(FILE* fp, unsigned int* mode)
{    
    unsigned char mthd, kind;
    Buffer   tmp, tag, enc, buf;
 
    buf = init_Buffer();
    if (mode==NULL) return buf;
 
    if (!read_Buffer2_format_fp(&tag, &enc, fp)) return buf;
 
    kind = *mode & 0x0f;                // データの種別
    mthd = *mode & 0xf0;                // データの形式
    if (kind!=tag.buf[0] && kind!=JBXL_FIO_ANY) {
        free_Buffer(&enc);
        free_Buffer(&tag);
        return buf;
    }
 
    // JBXL_FIO_ORIGINAL, JBXL_FIO_BASE64 以外は未サポート
    if (mthd==tag.buf[1]) {                // 保存形式と呼び出し形式は同じ
        buf = dup_Buffer(enc);
    }
    else {
        // 保存データをオリジナルへ
        if (tag.buf[1]==JBXL_FIO_BASE64) {
            tmp = decode_base64_Buffer(enc);
        }
        else {
            tmp = dup_Buffer(enc);
        }
 
        // オリジナルを呼び出し形式へ
        if (mthd==JBXL_FIO_BASE64) {
            buf = encode_base64_Buffer(tmp);
        }
        else {
            buf = dup_Buffer(tmp);
        }
        free_Buffer(&tmp);
    }
 
    *mode = (unsigned int)tag.buf[0];    // データ種別
    free_Buffer(&enc);
    free_Buffer(&tag);
 
    return  buf;
}
 
 
Buffer  fgets_mstream_Buffer(Buffer buf, mstream* sb)
{
    Buffer   ret;
    unsigned char* pp;
 
    ret = init_Buffer();
 
    pp = fgets_mstream(buf.buf, sb);
    if (pp!=NULL) {
        ret = make_Buffer(LBUF);
        copy_s2Buffer((char*)pp, &ret);
        free(pp);
    }
    return ret;
}
 
 
 
// Run Length
//
 
int  get_runlength_byte(unsigned char* buf, int len, int pos)
{
    int i, sz;
 
    sz = -1;
    for (i=0; i<len; i++) {
        if (buf[i]==0x00) {
            if (i+1>=len) return JBXL_XTOOLS_RUNLEN_ERROR;
            if (buf[i+1]==0x00) return JBXL_XTOOLS_RUNLEN2_ERROR;
            sz += buf[i+1];
            if (sz>=pos) return i;
            i++;
        }
        else sz++;
 
        if (sz>=pos) return i;
    }
 
    return JBXL_ERROR;
}
 
 
Buffer  decode_runlength(unsigned char* buf, int len, int sz)
{
    int    i, j, k;
    Buffer ret = init_Buffer();
 
    // 長さを数える
    i = j = 0;
    if (sz<=0) {
        while (j<len) {
            if (buf[j]==0x00) {
                if (j+1<len) {
                    if (buf[j+1]==0x00) return ret;
                    i += (int)buf[j+1];
                    j += 2;
                }
                else break;
            }
            else {
                i++;
                j++;
            }
        }
 
        if (j==len) sz = i;
        else return ret;
    }
        
    ret = make_Buffer(sz);
    if (ret.buf==NULL) return ret;
 
    i = j = 0;
    while (i<sz && j<len) {
        if (buf[j]==0x00) {
            if (j+1<len) {
                for (k=0; k<(int)buf[j+1]; k++) ret.buf[i++] = 0x00;
                j += 2;
            }
            else break;
        }    
        else ret.buf[i++] = buf[j++];
    }
 
    if (i==sz) ret.vldsz = sz;
    else free_Buffer(&ret);
 
    return ret;
}
 
 
Buffer  encode_runlength(unsigned char* buf, int len)
{
    int    i, j, k;
    Buffer ret = init_Buffer();
 
    ret = make_Buffer(2*len);
    if (ret.buf==NULL) return ret;
 
    i = j = 0;
    while (j<len) {
        ret.buf[i] = buf[j];
 
        if (buf[j]==0x00) {
            k = 0;
            while (buf[j]==0x00 && j<len) {
                k++;
                j++;
            }
            ret.buf[i+1] = (unsigned char)k;
            i += 2;
        }
        else {
            i++;
            j++;
        }
    }
 
    ret.vldsz = i;
    return ret;
}
 
 
 
// Ring Buffer
// 
 
int  put_Buffer_ringBuffer(ringBuffer* rb, Buffer* buf)
{
    if (rb==NULL) return JBXL_ARGS_ERROR;
    rb->state = JBXL_NORMAL;
 
    if (buf==NULL)     return JBXL_ARGS_ERROR;
    if (rb->buf==NULL) return JBXL_TOOLS_BUF_ERROR;
    if (rb->datasz + buf->vldsz > rb->bufsz) {
        rb->state = JBXL_ERROR;
        return JBXL_TOOLS_BUFSZ_ERROR;
    }
 
    if (rb->epoint + buf->vldsz <= rb->bufsz) {
        memcpy(&(rb->buf[rb->epoint]), buf->buf, buf->vldsz);
        rb->epoint = rb->epoint + buf->vldsz;
        if (rb->epoint==rb->bufsz) rb->epoint = 0;
    }
    else {
        memcpy(&(rb->buf[rb->epoint]), buf->buf, rb->bufsz - rb->epoint);
        memcpy(rb->buf, &(buf->buf[rb->bufsz - rb->epoint]), buf->vldsz - (rb->bufsz - rb->epoint));
        rb->epoint = rb->epoint + buf->vldsz - rb->bufsz;
    }
 
    rb->datasz += buf->vldsz;
    return buf->vldsz;
}
 
 
Buffer*  get_Buffer_ringBuffer(ringBuffer* rb, int sz)
{
    if (rb==NULL) return NULL;
    if (rb->buf==NULL) return NULL;
    if (sz>rb->datasz) return NULL;
 
    Buffer* buf = new_Buffer(sz);
 
    if (rb->spoint + sz <= rb->bufsz) {
        copy_b2Buffer(&(rb->buf[rb->spoint]), buf, sz);
        rb->spoint = rb->spoint + sz;
        if (rb->spoint==rb->bufsz) rb->spoint = 0;
    }
    else {
        copy_b2Buffer(&(rb->buf[rb->spoint]), buf, rb->bufsz - rb->spoint);
        cat_b2Buffer(rb->buf, buf, sz - (rb->bufsz - rb->spoint));
        rb->spoint = rb->spoint + sz - rb->bufsz;
    }
 
    rb->datasz -= sz;
    return buf;
}
 
 
 
//  Buffer 配列
// 
 
Buffer*  get_Buffer_dim_tList(tList* lp)
{
    int     nn, mx;
    tList*  lt;
    Buffer* buf;
    Buffer* ret;
 
    if (lp==NULL) return NULL;
 
    // リスト中のノードの数を数える．
    lt = lp;
    nn = 0;
    while(lt!=NULL && lt->ldat.key.buf!=NULL) {
        nn++;
        lt = lt->next;
    }
    if (nn==0) return NULL;
 
    mx = nn;
    buf = ret = (Buffer*)malloc(sizeof(Buffer)*mx);
    if (ret==NULL) return NULL;
    memset(buf, 0, sizeof(Buffer)*mx);
    
    nn = 0;
    while(lp!=NULL && lp->ldat.key.buf!=NULL) {
        *buf = dup_Buffer(lp->ldat.key);
        buf->state = mx - nn;
        nn++;
        buf++;
        lp = lp->next;
    }
        
    return ret;
}
 
 
Buffer*  get_Buffer_dim_tList_value(tList* lp)
{
    int     nn, mx;
    tList*  lt;
    Buffer* buf;
    Buffer* ret;
 
    if (lp==NULL) return NULL;
 
    lt = lp;
    nn = 0;
    while(lt!=NULL && lt->ldat.val.buf!=NULL) {
        nn++;
        lt = lt->next;
    }
    if (nn==0) return NULL;
 
    mx = nn;
    buf = ret = (Buffer*)malloc(sizeof(Buffer)*mx);
    if (ret==NULL) return NULL;
    memset(buf, 0, sizeof(Buffer)*mx);
    
    nn = 0;
    while(lp!=NULL && lp->ldat.val.buf!=NULL) {
        *buf = dup_Buffer(lp->ldat.val);
        buf->state = mx - nn;
        nn++;
        buf++;
        lp = lp->next;
    }
        
    return ret;
}
 
 
Buffer*  awk_Buffer_dim(Buffer buf, char cc)
{
    Buffer* bf = NULL;
 
    tList*  lp = awk_Buffer_tList(buf, cc);
    if (lp!=NULL) bf = get_Buffer_dim_tList(lp);
    del_all_tList(&lp);
    
    return  bf;
}
 
 
Buffer*  cawk_Buffer_dim(Buffer buf, char cc)
{
    Buffer* bf = NULL;
 
    tList*  lp = cawk_Buffer_tList(buf, cc);
    if (lp!=NULL) bf = get_Buffer_dim_tList(lp);
    del_all_tList(&lp);
    
    return  bf;
}
 
 
Buffer*  decompline_Buffer_dim(Buffer buf, int mode)
{
    Buffer* dim;
    int i, n, m;
 
    if (buf.buf==NULL) return NULL;
 
    n = i = 0;
    while(buf.buf[i]!='\0' && i<buf.vldsz) {
        if (buf.buf[i]==CHAR_CR) {
            n++;
            if (i+1<buf.vldsz && buf.buf[i+1]==CHAR_LF) i++;
        }
        else if (buf.buf[i]==CHAR_LF) n++;
        else if (i+1<buf.vldsz  && buf.buf[i+1]=='\0') n++;
        else if (i+1==buf.vldsz || buf.buf[i+1]=='\0') n++;
        i++;
    }
    if (n==0) n = 1;            // buf.buf[0]=='\0' の場合
 
    dim = (Buffer*)malloc(sizeof(Buffer)*n);
    if (dim==NULL) return NULL;
    memset(dim, 0, sizeof(Buffer)*n);
 
    int nxt = 0;
    for (m=0; m<n-1; m++) {
        int cnt = 0;
        int fwd = 0;
        while (buf.buf[nxt+cnt]!=CHAR_CR && buf.buf[nxt+cnt]!=CHAR_LF && nxt+cnt<buf.vldsz)  cnt++;
 
        if (buf.buf[nxt+cnt]==CHAR_CR || buf.buf[nxt+cnt]==CHAR_LF) fwd++;
        if (buf.buf[nxt+cnt]==CHAR_CR && nxt+cnt+1<buf.vldsz && buf.buf[nxt+cnt+1]==CHAR_LF) fwd++;
        if (mode==ON) cnt += fwd;
 
        dim[m] = make_Buffer(cnt);
        for (i=0; i<cnt; i++) {
            dim[m].buf[i] = buf.buf[nxt+i];
        }
        dim[m].vldsz = cnt;
        dim[m].state = n;
 
        if (mode==ON) nxt += cnt;
        else          nxt += cnt + fwd;
    }
 
    // m == n-1  一番最後の領域
    dim[n-1] = make_Buffer(buf.vldsz-nxt);
    for (i=0; i<buf.vldsz-nxt; i++) {
        dim[n-1].buf[i] = buf.buf[nxt+i];
    }
    dim[n-1].vldsz = buf.vldsz - nxt;
    dim[n-1].state = n;
 
    return dim;
}
 
 
Buffer  join_Buffer_dim(Buffer* dim, const char* deli)
{
    int    i, nn;
    Buffer buf;
 
    buf = init_Buffer();
    if (dim==NULL) return buf;
 
    buf = make_Buffer(LBUF);
    nn  = dim->state;
 
    for (i=0; i<nn; i++) {
        cat_Buffer(dim, &buf);
        if (deli!=NULL && i!=nn-1) cat_s2Buffer(deli, &buf);
        dim++;
    }
 
    return buf;
}
 
 
void  del_Buffer_dim(Buffer** dim)
{
    int  i, nn;
    Buffer* buf;
 
    if (dim==NULL || *dim==NULL) return;
    buf = *dim;
    
    nn = buf->state;
    if (nn<=0) free_Buffer(buf);
 
    for (i=0; i<nn; i++) {
        free_Buffer(buf);
        buf++;
    }
 
    free(*dim);
    *dim = NULL;
    return;
}
 
 
 
//  リスト Buffer 
// 
 
tList*  get_tList_line_Buffer(Buffer buf, int n)
{
    if (buf.buf==NULL || n<=0) return NULL;
 
    Buffer line = get_line_Buffer(buf, n);
    if (line.buf==NULL) return NULL;
 
    char*  packline = pack_char((char*)line.buf, ' ');
    free_Buffer(&line);
    if (packline==NULL) return NULL;
 
    tList* list = awk_tList(packline, ' ');
    free(packline);
 
    return list;
}
 
 
tList*  get_tList_seq_data_Buffer(Buffer buf, int* ptr)
{
    if (buf.buf==NULL || *ptr<0) return NULL;
    if (*ptr>=buf.vldsz) return NULL;
 
    Buffer line = get_seq_data_Buffer(buf, ptr);
    if (line.buf==NULL) return NULL;
 
    char*  packline = pack_char((char*)line.buf, ' ');
    free_Buffer(&line);
    if (packline==NULL) return NULL;
 
    tList* list = awk_tList(packline, ' ');
    free(packline);
 
    return list;
}
 
 
 
// Extend tList
//
 
int  set_item_tList(tList* list, char* key, int no, char deli, int nm, char* value)
{
    int    cn = 0;
    tList* lp;
 
    if (list==NULL || key==NULL || value==NULL) return JBXL_ARGS_ERROR;
 
    if (no>0) {
        lp = strncasecmp_tList(list, key, 0, no);
        if (lp!=NULL) {
            int rep = set_item_tList_node(lp, deli, nm, value);
            if (rep) cn = 1;
        }
    }   
    else {      // no<=0
        int nn = 1;
        cn = 0;
        lp = strncasecmp_tList(list, key, 0, nn);
        while (lp!=NULL) {
            int rep = set_item_tList_node(lp, deli, nm, value);
            if (rep) cn++;
            lp = strncasecmp_tList(list, key, 0, ++nn);
        }
    }
 
    return cn;
}
 
 
int  set_item_tList_node(tList* lp, char deli, int nm, char* value)
{
    int  rep = FALSE;
    char dl[2] = " ";
    Buffer* bp;
 
    if (lp==NULL || value==NULL) return FALSE;
 
    dl[0] = deli;
 
    bp = cawk_Buffer_dim(lp->ldat.val, deli);
    if (bp!=NULL && bp->state>=nm) {
        Buffer buf = make_Buffer_bystr(value);
        free_Buffer(&bp[nm-1]);
        bp[nm-1] = buf;
 
        free_Buffer(&lp->ldat.val);
        lp->ldat.val = join_Buffer_dim(bp, dl);
        rep = TRUE;
    }
    del_Buffer_dim(&bp);
 
    return rep;
}
 
 
int  replace_item_tList(tList* list, char* key, int no, char deli, int nm, char* srcval, char* value)
{
    int    cn = 0;
    tList* lp;
 
    if (list==NULL || key==NULL || value==NULL) return JBXL_ARGS_ERROR;
    if (srcval==NULL) {
        return     set_item_tList(list, key, no, deli, nm, value);
    }
 
    if (no>0) {
        lp = strncasecmp_tList(list, key, 0, no);
        if (lp!=NULL) {
            int rep = replace_item_tList_node(lp, deli, nm, srcval, value);
            if (rep) cn = 1;
        }
    }   
    else {      // no<=0
        int nn = 1;
        cn = 0;
        lp = strncasecmp_tList(list, key, 0, nn);
        while (lp!=NULL) {
            int rep = replace_item_tList_node(lp, deli, nm, srcval, value);
            if (rep) cn++;
            lp = strncasecmp_tList(list, key, 0, ++nn);
        }
    }
 
    return cn;
}
 
 
int  replace_item_tList_node(tList* lp, char deli, int nm, char* srcval, char* value)
{
    int  rep = FALSE;
    char dl[2] = " ";
    Buffer* bp;
    Buffer  buf;
 
    if (lp==NULL || value==NULL) return FALSE;
    if (nm<=0) nm = 1;
    if (srcval==NULL) {
        return set_item_tList_node(lp, deli, nm, value);
    }
 
    dl[0] = deli;
 
    bp = cawk_Buffer_dim(lp->ldat.val, deli);
    if (bp!=NULL && bp->state>=nm) {
           buf = replace_sBuffer(bp[nm-1], srcval, value);
        free_Buffer(&bp[nm-1]);
        bp[nm-1] = buf;
        free_Buffer(&lp->ldat.val);
        lp->ldat.val = join_Buffer_dim(bp, dl);
        rep = TRUE;
    }
    del_Buffer_dim(&bp);
 
    return rep;
}
 
 
 
// File/Directory Tools
//
 
tList*  get_dir_files(const char* dirn)
{
    tList* lp = NULL;
    tList* ln = NULL;
 
#ifdef WIN32
//    WIN32_FIND_DATA  FindFileData;
    WIN32_FIND_DATAA FindFileData;
    HANDLE hFind;
 
    Buffer pth = make_Buffer_bystr(dirn);
    if (pth.buf[strlen((char*)pth.buf)-1]!='\\') cat_s2Buffer("\\", &pth);
    Buffer buf = dup_Buffer(pth);
    cat_s2Buffer("*", &buf);
 
//    hFind = FindFirstFile((LPCTSTR)(buf.buf), &FindFileData);
    hFind = FindFirstFileA((LPCSTR)(buf.buf), &FindFileData);
    if (hFind!=INVALID_HANDLE_VALUE) {
        Buffer tmp;    
        do {
            if (strcmp(".", FindFileData.cFileName) && strcmp("..", FindFileData.cFileName)) { 
                int fkind = 0;  // other file
                if (FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) fkind = 1;    // directory
                tmp = dup_Buffer(pth);
                cat_s2Buffer(FindFileData.cFileName, &tmp);
                ln = add_tList_node_str(ln, NULL, tmp.buf);
                if (ln!=NULL) ln->ldat.lv = fkind;
                if (lp==NULL) lp = ln;
                free_Buffer(&tmp);
            }
        } while (FindNextFileA(hFind, &FindFileData));
 
        FindClose(hFind);
    }
    free_Buffer(&buf);
    free_Buffer(&pth);
 
#else
 
    DIR *dp;
    struct dirent *dir;
    
    Buffer pth = make_Buffer_bystr(dirn);
    if (pth.buf[strlen((char*)pth.buf)-1]!='/') cat_s2Buffer("/", &pth);
 
    dp = opendir(dirn);
    if (dp!=NULL ){
        Buffer tmp;
        dir = readdir(dp);
        while (dir != NULL ){
            if (strcmp(".", dir->d_name) && strcmp("..", dir->d_name)) { 
                int fkind = 0;  // other file
                if (dir->d_type==DT_DIR) fkind = 1; // directory
                tmp = dup_Buffer(pth);
                cat_s2Buffer(dir->d_name, &tmp);
                ln = add_tList_node_str(ln, NULL, (char*)tmp.buf);
                if (ln!=NULL) ln->ldat.lv = fkind;
                if (lp==NULL) lp = ln;
                free_Buffer(&tmp);
            }
            dir = readdir(dp);
        }
 
        closedir(dp);
    }
    free_Buffer(&pth);
 
#endif
 
    // sort
    ln = lp;
    while (ln!=NULL) {
        tList* lo = ln->next;
        while (lo!=NULL) {
            if (strcmp((char*)ln->ldat.val.buf, (char*)lo->ldat.val.buf)>0) {
                swap_tList_node(ln, lo);
            }
            lo = lo->next;
        }
        ln = ln->next;
    }
 
    return lp;
}
 
 
tList*  get_dir_files_rcsv(const char* dirn)
{
    tList* lp = get_dir_files(dirn);
    if (lp==NULL) return NULL;
 
    tList* lt = dup_tList(lp);
    while (lt!=NULL) {
        if (lt->ldat.lv==1) {
            tList* lc = get_dir_files_rcsv((char*)lt->ldat.val.buf);
            if (lc!=NULL) lp = add_tList_end(lc, lp);
        }
        lt = lt->next;
    }
    del_tList(&lt);
 
    return lp;
}
 
 
void  rm_dir_rcsv(const char* dirn)
{
    if (dirn==NULL) return;
 
    tList* lp = get_dir_files_rcsv(dirn);
    tList* lt = lp;
    while (lt!=NULL) {
        if (lt->ldat.lv==1) rmdir((char*)lt->ldat.val.buf);
        else unlink((char*)lt->ldat.val.buf);
        lt = lt->next;
    }
    rmdir(dirn);
    //
    del_tList(&lp);
    return;
}
 
 
void  del_file_extension_Buffer(Buffer* path)
{
    if (path==NULL) return;
 
    int count = path->vldsz - 1;
    while (count>=0) {
        if (path->buf[count]=='.') {
            path->buf[count] = '\0';
            path->vldsz = (int)strlen((char*)path->buf);
            break;
        }
        count--;
    }
}
 
 
void  change_file_extension_Buffer(Buffer* path, const char* ext)
{
    if (path==NULL) return;
 
    int count = path->vldsz - 1;
    while (count>=0) {
        if (path->buf[count]=='.') {
            path->buf[count] = '\0';
            path->vldsz = (int)strlen((char*)path->buf);
            if (ext[0]!='.') cat_s2Buffer(".", path);
            cat_s2Buffer(ext, path);
            break;
        }
        else if (path->buf[count]=='/' || path->buf[count]=='\\') {
            count = -1;
            break;
        }
        count--;
    }
    //
    if (count<0) {
        if (ext[0]!='.') cat_s2Buffer(".", path);
        cat_s2Buffer(ext, path);
    }
}
 
 
/*
Buffer  relative_path_Buffer(Buffer src, Buffer dst)
 
src から dst への相対パスを返す．
 
片方が絶対パスでもう片方が相対パスの場合，結果は不正確になる．
*/
Buffer  relative_path_Buffer(Buffer src, Buffer dst)
{
    Buffer rlt = init_Buffer();
    if (src.buf==NULL || dst.buf==NULL) return rlt; 
    if (src.buf[0]=='\0') {
        rlt = dup_Buffer(dst);
        return rlt;
    }
 
    Buffer path_a = dup_Buffer(src);
    Buffer path_b = dup_Buffer(dst);
    //  区切り文字の追加
    if (path_a.buf[path_a.vldsz-1]!=CHAR_DELI_DIR) cat_s2Buffer(STR_DELI_DIR, &path_a);
    if (path_b.buf[path_b.vldsz-1]!=CHAR_DELI_DIR) cat_s2Buffer(STR_DELI_DIR, &path_b);
 
    int  i = 0;
    char a = path_a.buf[0];
    char b = path_b.buf[0];
    while (a==b && a!='\0') {
        i++;
        a = path_a.buf[i];
        b = path_b.buf[i];
    }   // i : pat_a と path_b の違っている箇所
    if (a==CHAR_DELI_DIR && i>0) a = path_a.buf[--i];
    //
    // 手前の区切り文字
    while (i>=0 && a!=CHAR_DELI_DIR) a = path_a.buf[--i];
    i++;    // 区切り文字の次
 
    int n = 0, h = i;
    char c = path_a.buf[h];
    while(c!='\0') {
        if (c==CHAR_DELI_DIR) n++;
        c = path_a.buf[++h];
    }
    if (h!=i) n++;
 
    if (n==0) {
        rlt = make_Buffer_str(STR_CRNT_DIR);
    }
    else {
        int j;
        for (j=0; j<n; j++) {
            cat_s2Buffer(STR_UPST_DIR, &rlt);
        }
        cat_s2Buffer(&path_b.buf[i], &rlt);
    }
 
    free_Buffer(&path_a);
    free_Buffer(&path_b);
    
    return rlt;
}
 
 
void  canonical_filename_Buffer(Buffer* fname, int no_dir)
{
    if (fname==NULL || fname->buf==NULL) return;
 
    rewrite_Buffer_bychar(fname, ' ', '_');
    rewrite_Buffer_bychar(fname, '!', '_');
    rewrite_Buffer_bychar(fname, '$', '_');
    rewrite_Buffer_bychar(fname, '&', '_');
    rewrite_Buffer_bychar(fname, '~', '_');
    rewrite_Buffer_bychar(fname, '|', '_');
    rewrite_Buffer_bychar(fname, ':', '_');
    rewrite_Buffer_bychar(fname, ';', '_');
    rewrite_Buffer_bychar(fname, '*', '_');
    rewrite_Buffer_bychar(fname, '?', '_');
    rewrite_Buffer_bychar(fname, '`', '_');
    rewrite_Buffer_bychar(fname, '"', '_');
    rewrite_Buffer_bychar(fname, '\'', '_');
    rewrite_Buffer_bychar(fname, '@', '_');
    rewrite_Buffer_bychar(fname, '[', '_');
    rewrite_Buffer_bychar(fname, ']', '_');
    rewrite_Buffer_bychar(fname, '(', '_');
    rewrite_Buffer_bychar(fname, ')', '_');
    rewrite_Buffer_bychar(fname, '<', '_');
    rewrite_Buffer_bychar(fname, '>', '_');
    if (no_dir) {
        rewrite_Buffer_bychar(fname, '/', '_');
        rewrite_Buffer_bychar(fname, '\\', '_');
    }
    return;
}
 
 
 
// ファイルリスト
 
tList*  _add_key_val_list(tList* pp, tList* list, const char* key, const char* val, int mode)
{
    // 同一キーがあった場合の処理
    tList* fnd = strncasecmp_tList(list, key, 0, 1);
    if (fnd!=NULL) {
        if (mode==1) {          // スキップ
            return pp;
        }
        else if (mode==2) {     // 上書き
            if (pp==fnd) pp = fnd->prev;
            del_tList_node(&fnd);
        }
    }
    // データ追加
    tList_data ldat = make_tList_data_str(key, val);
    pp = add_tList_node_bydata(pp, ldat);
 
    return pp;
}
 
 
tList*  add_resource_list(const char* path, int keylen, tList* list, tList* extn, int mode)
{
    if (path==NULL) return list;
    if (list==NULL) list = new_tList_anchor_node();
 
    tList* pp = find_tList_end(list);
    tList* lp = get_dir_files(path);
    tList* tp = lp;
 
    // Generate Key. ファイル名の先頭 keylen文字をキーにする．
    while (lp!=NULL) {
        Buffer fn = make_Buffer_bystr(get_file_name((char*)lp->ldat.val.buf));  // ファイル名
        char* ext = get_file_extension((char*)fn.buf);
        //
        if (extn==NULL || strncasecmp_tList(extn, ext, 0, 1)==NULL) {   // 拡張子の検査
            if (keylen<=0) {
                pp = _add_key_val_list(pp, list, (char*)fn.buf, (char*)lp->ldat.val.buf, mode);
            }
            else if (fn.vldsz>=keylen) {
                fn.buf[keylen] = '\0';
                fn.vldsz = keylen;
                pp = _add_key_val_list(pp, list, (char*)fn.buf, (char*)lp->ldat.val.buf, mode);
            }
        }
        if (list==NULL) list = pp;
        free_Buffer(&fn);
        lp = lp->next;
    }
 
    del_all_tList(&tp);
    return list;
}
 
 
char*   get_resource_path(const char* name, tList* lp)
{
    if (name==NULL) return NULL;
    if (lp==NULL) return NULL;
    if (lp->ldat.id==TLIST_ANCHOR_NODE) lp = lp->next;
 
    while (lp!=NULL) {
        if (!strcasecmp((char*)lp->ldat.key.buf, name)) {
            return (char*)lp->ldat.val.buf;
        }
        lp = lp->next;
    }
    return NULL;
}