BasicLib/Lib/tools.cpp

Go to the documentation of this file.

#ifdef CPLUSPLUS
    #undef CPLUSPLUS
#endif


#include "tools.h"
#include "jbxl_state.h"


int   DebugMode     = OFF;
int   UnitTestMode  = OFF;

int   KanjiCode     = CODE_UTF8;                     
int   HostEndian    = UNKNOWN_ENDIAN;                

//
unsigned char  LocalIPNum[4]   = {0x7f, 0x00, 0x00, 0x01};    
unsigned char  LocalIPNum6[16] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}; 


// 

// case of C++, isNull() is inline

#ifndef CPLUSPLUS

int  isNull(void* p)
{
    if (p==NULL) return TRUE;

#ifdef WIN32
    if (p==WIN_DD_NULL) return TRUE;
#endif

    return FALSE;
}

#endif




// 

int is_little_endian(void)
{
    unsigned char x[] = {0x01, 0x00};

    if (HostEndian==LITTLE_ENDIAN) return TRUE;

    else if (HostEndian==BIG_ENDIAN) return FALSE;

    else {
        unsigned short* xx = (unsigned short*)x;
        if (*xx==1) {
            HostEndian = LITTLE_ENDIAN;
            return TRUE;
        }
        else {
            HostEndian = BIG_ENDIAN;
            return FALSE;
        }
    }
}



int is_big_endian(void)
{
    unsigned char x[] = {0x00, 0x01};

    if (HostEndian==BIG_ENDIAN) return TRUE;

    else if (HostEndian==LITTLE_ENDIAN) return FALSE;

    else {
        unsigned short* xx = (unsigned short*)x;
        if (*xx==1) {
            HostEndian = BIG_ENDIAN;
            return TRUE;
        }
        else {
            HostEndian = LITTLE_ENDIAN;
            return FALSE;
        }
    }
}



void  check_endian(void)
{
    if (HostEndian==UNKNOWN_ENDIAN) is_little_endian();
} 



double double_from_little_endian(void* ptr)
{
    double ret = *((double*)ptr);
    
    if (HostEndian==UNKNOWN_ENDIAN) check_endian();
    if (HostEndian==BIG_ENDIAN) reverse_str((uByte*)(&ret), 8);
    return ret;
}



float float_from_little_endian(void* ptr)
{
    float ret = *((float*)ptr);

    if (HostEndian==UNKNOWN_ENDIAN) check_endian();
    if (HostEndian==BIG_ENDIAN) reverse_str((uByte*)(&ret), 4);
    return ret;
}



int  int_from_little_endian(void* ptr)
{
    int ret = *((int*)ptr);

    if (HostEndian==UNKNOWN_ENDIAN) check_endian();
    if (HostEndian==BIG_ENDIAN) reverse_str((uByte*)(&ret), 4);
    return ret;
}



unsigned int  uint_from_little_endian(void* ptr)
{
    unsigned int ret = *((unsigned int*)ptr);

    if (HostEndian==UNKNOWN_ENDIAN) check_endian();
    if (HostEndian==BIG_ENDIAN) reverse_str((uByte*)(&ret), 4);
    return ret;
}



short short_from_little_endian(void* ptr)
{
    short ret = *((short*)ptr);

    if (HostEndian==UNKNOWN_ENDIAN) check_endian();
    if (HostEndian==BIG_ENDIAN) reverse_str((uByte*)(&ret), 2);
    return ret;
}



unsigned short ushort_from_little_endian(void* ptr)
{
    unsigned short ret = *((unsigned short*)ptr);

    if (HostEndian==UNKNOWN_ENDIAN) check_endian();
    if (HostEndian==BIG_ENDIAN) reverse_str((uByte*)(&ret), 2);
    return ret;
}



double double_from_big_endian(void* ptr)
{
    double ret = *((double*)ptr);

    if (HostEndian==UNKNOWN_ENDIAN) check_endian();
    if (HostEndian==LITTLE_ENDIAN) reverse_str((uByte*)(&ret), 8);
    return ret;
}



float float_from_big_endian(void* ptr)
{
    float ret = *((float*)ptr);

    if (HostEndian==UNKNOWN_ENDIAN) check_endian();
    if (HostEndian==LITTLE_ENDIAN) reverse_str((uByte*)(&ret), 4);
    return ret;
}



int  int_from_big_endian(void* ptr)
{
    int ret = *((int*)ptr);

    if (HostEndian==UNKNOWN_ENDIAN) check_endian();
    if (HostEndian==LITTLE_ENDIAN) reverse_str((uByte*)(&ret), 4);
    return ret;
}



unsigned int  uint_from_big_endian(void* ptr)
{
    int ret = *((unsigned int*)ptr);

    if (HostEndian==UNKNOWN_ENDIAN) check_endian();
    if (HostEndian==LITTLE_ENDIAN) reverse_str((uByte*)(&ret), 4);
    return ret;
}



short short_from_big_endian(void* ptr)
{
    short ret = *((short*)ptr);

    if (HostEndian==UNKNOWN_ENDIAN) check_endian();
    if (HostEndian==LITTLE_ENDIAN) reverse_str((uByte*)(&ret), 2);
    return ret;
}



unsigned short ushort_from_big_endian(void* ptr)
{
    unsigned short ret = *((unsigned short*)ptr);

    if (HostEndian==UNKNOWN_ENDIAN) check_endian();
    if (HostEndian==LITTLE_ENDIAN) reverse_str((uByte*)(&ret), 2);
    return ret;
}




// Time

//char  _Local_Time[64];      ///< 作業用（ローカルタイム）


/*
char*  get_localtime(char c1, char c2, char c3, char c4)
{
    struct tm* pt;
    time_t tm;

    tm = time(NULL);
    pt = localtime(&tm);

    snprintf(_Local_Time, 63, "%04d%c%02d%c%02d%c%02d%c%02d%c%02d%c",
                pt->tm_year+1900, c1, pt->tm_mon+1, c1, pt->tm_mday, c2,
                pt->tm_hour, c3, pt->tm_min, c3, pt->tm_sec, c4);

    return _Local_Time;
}
*/



/*
char*  get_localtime_ts(char c1, char c2, char c3, char c4)
{
    struct tm* pt;
    time_t tm;
    char*  local_tm = NULL;

    local_tm = (char*)malloc(64);
    if (local_tm==NULL) return NULL;
    memset(local_tm, 0, 64);

    tm = time(NULL);
    pt = localtime(&tm);

    snprintf(local_tm, 63, "%04d%c%02d%c%02d%c%02d%c%02d%c%02d%c", 
                pt->tm_year+1900, c1, pt->tm_mon+1, c1, pt->tm_mday, c2, 
                pt->tm_hour, c3, pt->tm_min, c3, pt->tm_sec, c4);

    return local_tm;
}
*/


// 要 free
char*  get_local_timestamp(time_t date, const char* format)
{
    char* buf = (char*)malloc(64);

    //struct tm tm = *gmtime(&date);
    struct tm tm = *localtime(&date);
    strftime(buf, 63, format, &tm);

    return buf;
}


// 要 free
char*  get_gmt_timestamp(time_t date, const char* format)
{
    char* buf = (char*)malloc(64);

    struct tm tm = *gmtime(&date);
    //struct tm tm = *localtime(&date);
    strftime(buf, 63, format, &tm);

    return buf;
}








char*  get_line(char* buf, int n)
{
    int   i, j, pos, cnt;
    char* ret = NULL;

    if (buf==NULL) return NULL;

    for(i=0,j=0; j<n-1; j++) {
        while (buf[i]!=CHAR_LF && buf[i]!=CHAR_CR && buf[i]!='\0') i++;
        while (buf[i]==CHAR_LF || buf[i]==CHAR_CR) i++;
    }
    if (buf[i]=='\0') return  NULL;

    pos = i;
    while (buf[i]!=CHAR_LF && buf[i]!=CHAR_CR && buf[i]!='\0') i++;
    cnt = i - pos;

    if (cnt>=0) {  
        ret = (char*)malloc(cnt+1);
        if (ret==NULL) return NULL;

        for(i=0; i<cnt; i++) ret[i] = buf[pos+i];
        ret[cnt] = '\0';
    }
    return  ret;
}



char*  get_seq_data(char* buf, int* ptr)
{
    int   pos, cnt;
    char* ret = NULL;

    if (buf==NULL || buf[*ptr]=='\0') return NULL;

    pos = *ptr;
    while (buf[*ptr]!=CHAR_LF && buf[*ptr]!=CHAR_CR && buf[*ptr]!='\0') (*ptr)++;
    cnt = *ptr - pos;

    if (cnt>=0) {  
        ret = (char*)malloc(cnt+1);
        if (ret==NULL) return NULL;

        int i;
        for(i=0; i<cnt; i++) ret[i] = buf[pos+i];
        ret[cnt] = '\0';
    }

    while (buf[*ptr]==CHAR_LF || buf[*ptr]==CHAR_CR) (*ptr)++;
    return  ret;
}



char*  awk(char* buf, char cc, int n)
{
    int i, j, pos, cnt;
    char*  item = NULL;

    if (buf==NULL) return NULL;

    for(i=0,j=0; j<n-1; j++) {
        while (buf[i]!='\0' && buf[i]!=cc) i++;
        if (buf[i]==cc) i++;
    }
    if (buf[i]=='\0')  return NULL;

    pos = i;
    while (buf[i]!='\0' && buf[i]!=cc) i++;
    cnt = i - pos;

    item = (char*)malloc(cnt+1);
    if (item==NULL) return NULL;

    for (i=0; i<cnt; i++) item[i] = buf[pos+i];
    item[cnt] = '\0';

    return item;
}



char*  cawk(char* buf, char cc, int n)
{
    int i, j, pos, cnt;
    char*  item = NULL;

    if (buf==NULL) return NULL;

    for(i=0,j=0; j<n-1; j++) {
        while (buf[i]!='\0' && buf[i]!=cc) i++;
        while (buf[i]!='\0' && buf[i]==cc) i++;
    }
    if (buf[i]=='\0') return NULL;

    pos = i;
    while (buf[i]!='\0' && buf[i]!=cc) i++;
    cnt = i - pos;

    item = (char*)malloc(cnt+1);
    if (item==NULL) return NULL;

    for (i=0; i<cnt; i++) item[i] = buf[pos+i];
    item[cnt] = '\0';

    return item;
}



int  bincmp(unsigned char* b1, unsigned char* b2, int n) 
{
    int i;

    if (b1==NULL || b2==NULL) return 1;

    for (i=0; i<n; i++) {
        if (b1[i]!=b2[i]) return 1;
    }

    return 0;
}



int  strnrvscmp(const char* s1, const char* s2, int n) 
{
    int j1, j2;
    
    if (s1==NULL || s2==NULL) return 1;

    j1 = (int)strlen(s1) - 1;
    j2 = (int)strlen(s2) - 1;

    while (n>0 && j1>=0 && j2>=0) {
        if (s1[j1--] != s2[j2--]) return 1;
        n--;
    }

    if (n==0) return 0;
    else      return 1;
}



int  strncaservscmp(const char* s1, const char* s2, int n) 
{
    int j1, j2;
    
    if (s1==NULL || s2==NULL) return 1;

    j1 = (int)strlen(s1) - 1;
    j2 = (int)strlen(s2) - 1;

    while (n>0 && j1>=0 && j2>=0) {
        if (toupper(s1[j1--]) != toupper(s2[j2--])) return 1;
        n--;
    }

    if (n==0) return 0;
    else      return 1;
}



char*  strstrcase(const char* buf, const char* nd)
{
    char* pp;
    char* pb;
    char* pn;

    if (buf==NULL || nd==NULL) return NULL;

    pb = (char*)malloc(strlen(buf)+1);
    if (pb==NULL) return NULL;
    memcpy(pb, buf, (int)strlen(buf)+1);

    pn = (char*)malloc(strlen(nd)+1);
    if (pn==NULL) {
        free(pb);
        return NULL;
    }
    memcpy(pn, nd, (int)strlen(nd)+1);

    upper_string(pb);
    upper_string(pn);

    pp = strstr(pb, pn);
    if (pp!=NULL) {
        pp = (pp - pb) + (char*)buf;
    }
    free(pb);
    free(pn);

    return pp;
}



int  ex_strncmp(const char* dat, const char* key, int len) 
{
    if (dat==NULL || key==NULL) return FALSE;

    if (len==0) {
        if (!strcmp(dat, key)) return TRUE;
    }
    else if (len>0) {
        if (!strncmp(dat, key, len)) return TRUE;
    }
    else if (len<0) {
        int sz;
        if (len==-1) sz = (int)strlen(dat);
        else         sz = (int)strlen(key);
        if (!strncmp(dat, key, sz)) return TRUE;
    }
    
    return FALSE;
}



int  ex_strncasecmp(const char* dat, const char* key, int len) 
{
    if (dat==NULL || key==NULL) return FALSE;

    if (len==0) {
        if (!strcasecmp(dat, key)) return TRUE;
    }
    else if (len>0) {
        if (!strncasecmp(dat, key, len)) return TRUE;
    }
    else if (len<0) {
        int sz;
        if (len==-1) sz = (int)strlen(dat);
        else         sz = (int)strlen(key);
        if (!strncasecmp(dat, key, sz)) return TRUE;
    }
    
    return FALSE;
}



int  ex_strnrvscmp(const char* dat, const char* key, int len) 
{
    if (dat==NULL || key==NULL) return FALSE;

    if (len==0) {
        if (!strcmp(dat, key)) return TRUE;
    }
    else if (len>0) {
        if (!strnrvscmp(dat, key, len)) return TRUE;
    }
    else if (len<0) {
        int sz;
        if (len==-1) sz = (int)strlen(dat);
        else         sz = (int)strlen(key);
        if (!strnrvscmp(dat, key, sz)) return TRUE;
    }
    
    return FALSE;
}



int  ex_strncaservscmp(const char* dat, const char* key, int len) 
{
    if (dat==NULL || key==NULL) return FALSE;

    if (len==0) {
        if (!strcasecmp(dat, key)) return TRUE;
    }
    else if (len>0) {
        if (!strncaservscmp(dat, key, len)) return TRUE;
    }
    else if (len<0) {
        int sz;
        if (len==-1) sz = (int)strlen(dat);
        else         sz = (int)strlen(key);
        if (!strncaservscmp(dat, key, sz)) return TRUE;
    }
    
    return FALSE;
}



char*  chomp(char* buf)
{
    int i, len;
    
    if (buf==NULL) return NULL;

    len = (int)strlen(buf);
    for (i=0; i<len; i++) {
        if (buf[i]==CHAR_LF || buf[i]==CHAR_CR) {
            buf[i] = '\0';
            return buf;
        }
    }
    return buf;
}



char*  skip_chars(char* pp, const char* check)
{
    int  n, sqf = 0, dqf = 0;

    n = (int)strlen(check);

    while (*pp!='\0') {
        while (*pp=='\\') pp += 2;
        //
        if (*pp!='\0') {
            if      (!sqf && *pp=='\"') dqf = 1 - dqf;
            else if (!dqf && *pp=='\'') sqf = 1 - sqf;

            else if (!sqf && !dqf) {
                int i;
                for (i=0; i<n; i++) {
                    if (*pp==check[i]) return pp;
                }
            }
            pp++;
        }
    }

    return NULL;
}



char*  skip_char(char* pp, char cc)
{
    int  sqf = 0, dqf = 0;

    while (*pp!='\0') {
        while (*pp=='\\') pp += 2;
        //
        if (*pp!='\0') {
            if      (!sqf && *pp=='\"') dqf = 1 - dqf;
            else if (!dqf && *pp=='\'') sqf = 1 - sqf;
            else if (!sqf && !dqf && *pp==cc) return pp;
            pp++;
        }
    }

    return pp;
}



char*   skip_char_pair(char* pp, char pair, char end)
{
    int cnt = 0, sqf = 0, dqf = 0;

    if (*pp==pair) {
        cnt = 1;
        pp++;
    }

    while (*pp!='\0') {
        while (*pp=='\\') pp += 2;
        //
        if (*pp!='\0') {
            if      (!sqf && *pp=='\"') dqf = 1 - dqf;
            else if (!dqf && *pp=='\'') sqf = 1 - sqf;

            else if (!sqf && !dqf) {
                if      (*pp==end)  cnt--;
                else if (*pp==pair) cnt++;
                if (cnt==0) return pp;
            }
            pp++;
        }
    }

    return pp;
}



char*  skip_string_end(char* pp)
{
    char ch = *pp;

    if (*pp=='\"' || *pp=='\'') {
        pp++;
        //
        while (*pp!='\0') {
            while (*pp=='\\') pp += 2;
            //
            if (*pp!='\0') {
                if (*pp==ch) return pp;
            }
            pp++;
        }
    } 
    return pp;
}



char*  pack_head_tail_char(char* mesg, char cc)
{
    int   sz;
    char* ps;
    char* pe;
    char* pp;

    if (mesg==NULL) return NULL;

    ps = mesg;
    while(*ps==cc || *ps==CHAR_TAB || *ps==CHAR_LF || *ps==CHAR_CR) ps++;
    pe = ps;
    while(*pe!='\0') pe++;
    pe--;
    while(*pe==cc || *pe==CHAR_TAB || *pe==CHAR_LF || *pe==CHAR_CR) pe--;

    sz = (int)(pe - ps) + 1;
    pp = (char*)malloc((size_t)(sz + 1));
    memcpy(pp, ps, sz);
    pp[sz] = '\0';

    return pp;        
}



/*
char*  pack_char(char* mesg, char cc)
{
    return pack_char_len(mesg, cc, -1);
}
*/



char*  pack_char_len(char* mesg, char cc, int len)
{
    int i, j;
    int sf = OFF;    // 連続 cc 用のフラグ
    int ff = ON;     // 先頭の cc を無視するためのフラグ
    char* pp;

    if (mesg==NULL) return NULL;

    if (len==0) return NULL;
    if (len<0)  len = (int)strlen(mesg);
    pp = (char*)malloc(len+1);
    if (pp==NULL) return NULL;

    i = j = 0;
    while(mesg[i]!='\0' && i<len) {
        if (mesg[i]==CHAR_TAB)  mesg[i] = ' ';
        if (mesg[i]!=CHAR_CR && mesg[i]!=CHAR_LF) {        // CR LF を読み飛ばす．
            if (mesg[i]==cc) {
                if (sf==OFF) {
                    sf = ON;
                    if (ff==ON) ff = OFF;
                    else  pp[j++] = mesg[i];
                }
            }
            else {
                sf = ff = OFF;
                pp[j++] = mesg[i];
            }
        }
        i++;
    }
    pp[j] = '\0';

    // 末尾の cc を削除
    i = (int)strlen(pp) - 1;
    while(i>=0) {
        if (pp[i]==cc) i--; 
        else  break;
    }
    pp[i+1] = '\0';

    return pp;
}



char*  change_esc(char* mesg)
{
    int i, j;
    char* pp;

    if (mesg==NULL) return NULL;

    pp = (char*)malloc((strlen(mesg)+1)*2);
    if (pp==NULL) return NULL;

    i = j = 0;
    while(mesg[i]!='\0') {
        if (mesg[i]==CHAR_CR) {
            pp[j++] = '\\';
            pp[j++] = 'r';
        }
        else if (mesg[i]==CHAR_LF) {
            pp[j++] = '\\';
            pp[j++] = 'n';
        }
        else {
            pp[j++] = mesg[i];
        }
        i++;
    }
    pp[j] = '\0';
    
    return pp;
}



char*  replace_str(char* buf, int len, const char* frm, const char* tos)
{
    char* wrk = NULL;
    int i, j, k, slen, flen, tlen;

    if (buf==NULL || frm==NULL || tos==NULL) return NULL;

    wrk = (char*)malloc(len);
    if (wrk==NULL) return NULL;

    slen = (int)strlen(buf);
    flen = (int)strlen(frm);
    tlen = (int)strlen(tos);

    i = j = 0;
    while (i<slen && j<len) {
        if (!strncmp((const char*)(buf+i), frm, flen)){
            for (k=0; k<tlen; k++) {
                wrk[j+k] = tos[k];
            }
            i += flen;
            j += tlen;
        }
        else {
            wrk[j++] = buf[i++];
        }
    }

    //
    if (j>=len) {
        free(wrk);
        return NULL;
    }

    wrk[j] = '\0';
    for (k=0; k<=j; k++) buf[k] = wrk[k];
    free(wrk);

    return buf;
}



char*  cut_str(char* buf, int ls, int le)
{
    int   i, len;
    char* ret;

    if (buf==NULL) return NULL;

    ls  = Max(ls, 0);
    le  = Min(le, (int)strlen((const char*)buf)); 
    len = le - ls + 1;
    if (len<=0) return NULL;

    ret = (char*)malloc(len+1);
    if (ret==NULL) return NULL;
    memset(ret, 0, len+1);

    for (i=0; i<len; i++) ret[i] = buf[i+ls];

    return ret;
}



char*  dup_str(char* buf)
{
    int   len;
    char* ret;

    if (buf==NULL) return NULL;

    len = (int)strlen(buf);
    ret = (char*)malloc(len+1);
    if (ret==NULL) return NULL;

    memcpy(ret, buf, len);
    ret[len] = '\0';

    return ret;
}



static char  _ToSTR[LDATA];        


char*  itostr(int n)
{
    memset(_ToSTR, 0, LDATA);
    snprintf(_ToSTR, LDATA-1, "%d", n);
    return _ToSTR;
}



char*  ltostr(long int n)
{
    memset(_ToSTR, 0, LDATA);
    snprintf(_ToSTR, LDATA-1, "%ld", n);
    return _ToSTR;
}



char*  ultostr(unsigned long int n)
{
    memset(_ToSTR, 0, LDATA);
    snprintf(_ToSTR, LDATA-1, "%lu", n);
    return _ToSTR;
}



char*  lltostr(long long int n)
{
    memset(_ToSTR, 0, LDATA);
    snprintf(_ToSTR, LDATA-1, "%lld", n);
    return _ToSTR;
}



char*  ulltostr(unsigned long long int n)
{
    memset(_ToSTR, 0, LDATA);
    snprintf(_ToSTR, LDATA-1, "%llu", n);
    return _ToSTR;
}



char*  ftostr(float n)
{
    memset(_ToSTR, 0, LDATA);
    snprintf(_ToSTR, LDATA-1, "%f", n);
    return _ToSTR;
}



char*  dtostr(double n)
{
    memset(_ToSTR, 0, LDATA);
    snprintf(_ToSTR, LDATA-1, "%f", n);
    return _ToSTR;
}



char*  itostr_ts(int n)
{
    char* str = NULL;
    str = (char*)malloc(LDATA);
    if (str==NULL) return NULL;

    memset(str, 0, LDATA);
    snprintf(str, LDATA-1, "%d", n);
    return str;
}



char*  ltostr_ts(long int n)
{
    char* str = NULL;
    str = (char*)malloc(LDATA);
    if (str==NULL) return NULL;

    memset(str, 0, LDATA);
    snprintf(str, LDATA-1, "%ld", n);
    return str;
}



char*  ultostr_ts(unsigned long int n)
{
    char* str = NULL;
    str = (char*)malloc(LDATA);
    if (str==NULL) return NULL;

    memset(str, 0, LDATA);
    snprintf(str, LDATA-1, "%lu", n);
    return str;
}



char*  lltostr_ts(long long int n)
{
    char* str = NULL;
    str = (char*)malloc(LDATA);
    if (str==NULL) return NULL;

    memset(str, 0, LDATA);
    snprintf(str, LDATA-1, "%lld", n);
    return str;
}



char*  ulltostr_ts(unsigned long long int n)
{
    char* str = NULL;
    str = (char*)malloc(LDATA);
    if (str==NULL) return NULL;

    memset(str, 0, LDATA);
    snprintf(str, LDATA-1, "%llu", n);
    return str;
}



char*  ftostr_ts(float n)
{
    char* str = NULL;
    str = (char*)malloc(LDATA);
    if (str==NULL) return NULL;

    memset(str, 0, LDATA);
    snprintf(str, LDATA-1, "%f", n);
    return str;
}



char*  dtostr_ts(double n)
{
    char* str = NULL;
    str = (char*)malloc(LDATA);
    if (str==NULL) return NULL;

    memset(str, 0, LDATA);
    snprintf(str, LDATA-1, "%f", n);
    return str;
}



int  count_lines(const char* buf)
{
    int i    = 0;
    int line = 0;
    
    if (buf==NULL) return 0;
    line++;

    while(buf[i]!='\0') {
        if (buf[i]==CHAR_CR) {
            line++;
            if (buf[i+1]==CHAR_LF) i++;
        }
        else if (buf[i]==CHAR_LF) {
            line++;
        }
        i++;
    }

    return line;
}



int hexstr2i(const char* str)
{
    int i, ret = 0;
    if (str==NULL) return ret;

    int len = (int)strlen(str);

    for (i=0; i<len; i++) {
        if (str[i]>='0' && str[i]<='9') {
            ret = ret*16;
            ret += (int)(str[i] - '0');
        }
        else if (str[i]>='A' && str[i]<='F') {
            ret = ret*16;
            ret += (int)(str[i] - 'A') + 10;
        }
        else if (str[i]>='a' && str[i]<='f') {
            ret = ret*16;
            ret += (int)(str[i] - 'a') + 10;
        }
        else if (str[i]!=' ') {
            break;
        }
    }

    return ret;
}


#ifndef WIN32

void  init_rand(void)
{
    FILE* fp;
    unsigned int seed;
    size_t sz;
    UNUSED(sz);

    fp = fopen("/dev/urandom", "rb");
    if (fp==NULL) {
        srand(time(NULL));
        return;
    }
    sz = fread(&seed, sizeof(unsigned int), 1, fp);
    fclose(fp);

    srand(seed);
}

#endif



char*  randstr(int n)
{
    char   base[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
    char*  pass;
    int    i, sz;

    if (n<=0) return NULL;
    pass = (char*)malloc(n+1);
    if (pass==NULL) return pass;

    sz = (int)strlen(base);
    for (i=0; i<n; i++) pass[i] = base[rand()%sz];
    pass[n] = '\0';

    return pass;
}



unsigned char*  randbit(int n)
{
    int   i, sz;
    unsigned char* bin;

    sz = (n+7)/8;
    bin = (unsigned char*)malloc(sz);
    if (bin==NULL) return NULL;

    memset(bin, 0, sz);
    for (i=0; i<n; i++) setBit(bin, i, rand()%2);

    return bin;    
}




//
// 64bit 変換
unsigned long long int ntohull(unsigned long long int s)
{
    if (is_little_endian()) {
        long long int d;
        uByte* src = (uByte*)&s;
        uByte* dst = (uByte*)&d;
        dst[0] = src[7];
        dst[1] = src[6];
        dst[2] = src[5];
        dst[3] = src[4];
        dst[4] = src[3];
        dst[5] = src[2];
        dst[6] = src[1];
        dst[7] = src[0];
        return d;
    }
    return s;
}



void  swap_byte(void* p, int s, int c)
{
    int    i;
    uByte* u = (uByte*)p;
    for (i=0; i<s; i+=c) reverse_str(&u[i], c);
}

 

short  swaps(unsigned short p)
{
    short  r;
    uByte* t;
    uByte* f;
     
    t = (uByte*)&r;
    f = (uByte*)&p;
    t[0] = f[1];
    t[1] = f[0];

    return r;
}



int  swapl(unsigned int p)
{
    int    r;
    uByte* t;
    uByte* f;
     
    t = (uByte*)&r;
    f = (uByte*)&p;
    t[0] = f[3];
    t[1] = f[2];
    t[2] = f[1];
    t[3] = f[0];

    return r;
}



void  reverse_str(uByte* p, int s)
{
    int    i;
    uByte  c;
     
    if (s<=0) s = (int)strlen((const char*)p);

    for (i=0; i<s/2; i++) {
        c        = p[s-1-i];
        p[s-1-i] = p[i];
        p[i]     = c;
    }
}   





int  file_from_to(const char* src, const char* dst, const char* mode)
{
    long int  sz;
    unsigned char* buf;
    FILE*  fp;
    size_t rs;
    UNUSED(rs);

    sz = file_size(src);
    if (sz<0) return JBXL_FILE_EXIST_ERROR;
    buf = (unsigned char*)malloc(sz);
    if (buf==NULL) return JBXL_MALLOC_ERROR;

    fp = fopen(src, "rb");
    if (fp==NULL) {
        free(buf);
        return JBXL_FILE_OPEN_ERROR;
    }
    rs = fread(buf, sz, 1, fp);
    fclose(fp);

    fp = fopen(dst, mode);
    if (fp==NULL) {
        free(buf);
        return JBXL_FILE_DESTOPEN_ERROR;
    }
    fwrite(buf, sz, 1, fp);
    fclose(fp);

    free(buf);
    return sz;
}



int  fp_from_to(FILE* src, FILE* dst, long int sz)
{
    unsigned char* buf;
    size_t rs;
    UNUSED(rs);

    if (sz<=0)     return JBXL_ARGS_ERROR;
    if (src==NULL) return JBXL_FILE_OPEN_ERROR;
    if (dst==NULL) return JBXL_FILE_DESTOPEN_ERROR;

    buf = (unsigned char*)malloc(sz);
    if (buf==NULL) return JBXL_MALLOC_ERROR;

    rs = fread(buf, sz, 1, src);
    sz = (int)fwrite(buf, sz, 1, dst);

    free(buf);
    return sz;
}



char* get_file_name(const char* str)
{
    if (str==NULL) return NULL;

#ifdef WIN32
    char  cc = '\\';
#else
    char  cc = '/';
#endif

    int len = (int)strlen(str);
    int sz  = 0;
    while (sz<len && str[len-1-sz]!=cc) sz++;
    char* fnm = (char*)str + len - sz; 

    return fnm;
}



char* del_file_name(const char* str)
{
    if (str==NULL) return NULL;
    
#ifdef WIN32
    char  cc = '\\';
#else
    char  cc = '/';
#endif

    char* path = (char*)str;
    int len = (int)strlen(str);
    if (len==1) {
        if (path[0]==cc) return path;
        else return NULL;
    }

    int sz = len - 1;
    while (sz>=0 && str[sz]!=cc) sz--;

    if (sz<0) {
        path[0] = '.';
        path[1] = cc;
        path[2] = '\0';
    }
    else {
        path[sz+1] = '\0';
    }

    return path;
}



/*
char* make_file_path(const char* str)
{
    if (str==NULL || str[0]=='\0') return NULL;

    int len = (int)strlen(str);
    char* path = (char*)malloc(len+1);
    memcpy(path, str, len+1);

#ifdef WIN32
    char  cc = '\\';
#else
    char  cc = '/';
#endif

    if (len==1) {
        if (path[0]==cc) return path;
        else {
            free(path);
            return NULL;
        }
    }

    int sz = len - 1;
    while (sz>=0 && path[sz]!=cc) sz--;

    if (sz<0) {
        if (len>=2) {
            path[0] = '.';
            path[1] = cc;
            path[2] = '\0';
        }
        else {
            free(path);
            path = NULL;
        }
    }
    else {
        path[sz+1] = '\0';
    }

    return path;
}
*/



char* get_file_path(const char* str)
{
    if (str==NULL || str[0]=='\0') return NULL;

    int len = (int)strlen(str);
    char* path = (char*)malloc(len+1);
    memcpy(path, str, len+1);

#ifdef WIN32
    char  cc = '\\';
#else
    char  cc = '/';
#endif

    int sz = len - 1;
    while (sz>=0 && path[sz]!=cc) sz--;

    if (sz<0) {
        free(path);
        path = NULL;
    }
    else {
        path[sz+1] = '\0';
    }

    return path;
}


char* get_file_extension(const char* str)
{
    int   sz, len;
    char* ext;

    if (str==NULL) return NULL;

    char  pd = '.';

#ifdef WIN32
    char  cc = '\\';
#else
    char  cc = '/';
#endif

    len = (int)strlen(str);
    sz  = 0;
    while (sz<len && str[len-1-sz]!=cc && str[len-1-sz]!=pd) sz++;

    if (str[len-1-sz]!=pd) return NULL;
    ext = (char*)str + len - sz; 

    return ext;
}



char* del_file_extension(const char* str)
{
    if (str==NULL) return NULL;
    
    char  cc = '.';
    char* path = (char*)str;

    int len = (int)strlen(path);
    int sz = len - 1;
    while (sz>=0 && path[sz]!=cc) sz--;

    if (sz<1) return path;
    path[sz] = '\0';

    return path;
}



char* cut_file_extension(const char* str)
{
    if (str==NULL) return NULL;

    char  cc = '.';
    int len = (int)strlen(str);
    char* path = (char*)malloc(len+1);
    memcpy(path, str, len+1);

    int sz = len - 1;
    while (sz>=0 && path[sz]!=cc) sz--;

    if (sz<1) return path;
    path[sz] = '\0';

    return path;
}



unsigned long int   file_size(const char* fn)                                              
{                                      
    struct stat stbuf;                                               
                                                                   
    stat(fn, &stbuf);

#ifdef WIN32
    return stbuf.st_size;
#else
    if (S_ISREG(stbuf.st_mode)) return stbuf.st_size;
    else                        return 0;
#endif
}



int  file_exist(const char* fn)
{
    FILE* fp;

    if (fn==NULL) return FALSE;

    if ((fp=fopen(fn,"rb"))==NULL) {
        return FALSE;
    }
    fclose(fp);
    return TRUE;
}



FILE*  file_chmod_open(const char* fn, const char* fm, mode_t mode)
{
    FILE* fp;

    if (!file_exist(fn)) {
        if ((fp=fopen(fn,"wb"))==NULL) return NULL;
        fclose(fp);
    }

#ifndef WIN32
    fp = NULL;
    if (chmod(fn, mode)) return fp;
#endif

    fp = fopen(fn, fm);
    return fp;
}



char*  temp_filename(const char* dir, int flen)
{
    FILE* fp;
    int   i, dlen=0;
    char  nostr = '\0';
    char* fname;
    char* fnbin;
    char* fnb64;
    size_t rs;
    UNUSED(rs);

    if (dir==NULL) dir = &nostr;
    dlen = (int)strlen(dir);
    if (flen<=0)   flen = 15;

    fname = (char*)malloc(dlen+flen+1);
    if (fname==NULL) return NULL;
    fnbin = (char*)malloc(flen);
    if (fnbin==NULL) {
        free(fname);
        return NULL;
    }

    fnb64 = NULL;
    fp = fopen("/dev/urandom", "rb");

    do {
        if (fp!=NULL) {
            rs = fread(fnbin, flen, 1, fp);
            fnb64 = (char*)encode_base64((unsigned char*)fnbin, flen);
            if (fnb64!=NULL) fnb64[flen] = '\0';
        }
        if (fnb64==NULL) fnb64 = randstr(flen);

        for (i=0; i<flen; i++) {
            if (fnb64[i]=='/') fnb64[i] = 'x';
            if (fnb64[i]=='+') fnb64[i] = 'X';
        }

        memset (fname, 0, dlen+flen+1);
        strncpy(fname, dir, dlen);
        strncat(fname, fnb64, flen);
        free(fnb64);
    } while(file_exist(fname)); 

    if (fp!=NULL) fclose(fp);
    free(fnbin);
    return fname;
}


unsigned char*  read_file(const char* fname, unsigned long int* size)
{
    size_t rs;
    UNUSED(rs);

    if (size==NULL) return NULL;

    *size = file_size(fname);
    if (*size<=0) return NULL;

    unsigned char* buf = (unsigned char*)malloc(*size);
    if (buf==NULL) return NULL;

    FILE* fp  = fopen(fname, "rb");
    if (fp==NULL) {
        free(buf);
        return NULL;
    }

    rs = fread(buf, *size, 1, fp);
    fclose(fp);

    return buf;
}



long int  write_file(const char* fname, unsigned char* buf, unsigned long int size)
{
    if (size==0) return 0;

    FILE* fp  = fopen(fname, "wb");
    if (fp==NULL) return 0;

    size = (long int)fwrite(buf, size, 1, fp);
    fclose(fp);

    return size;
}



char* double_bs(char* str) 
{
    int  i, j;
    int  len, bsn=0;
    char* buf;

    len = (int)strlen(str);
    for (i=0; i<len; i++) if (str[i]=='\\') bsn++;
    buf = (char*)malloc(len+bsn+1);
    if (buf==NULL) return NULL;

    for (i=0,j=0; i<len; i++) {
        buf[j++] = str[i];
        if (str[i]=='\\') buf[j++] = '\\';
    }
    buf[j] = '\0';

    return buf;
}



char*  numbering_name(const char* fmt, int n)
{
    int    len;
    char   fname[LNAME], *fo;

    memset(fname, 0, LNAME);
    snprintf(fname, LNAME-1, fmt, n);
    len = (int)strlen(fname);

    fo = (char*)malloc(len + 1);
    if (fo==NULL) return NULL;

    memset(fo, 0, len+1);
    strncpy(fo, fname, len);
    return fo;
}





void kanji_convert(unsigned char* mesg)
{
    if (KanjiCode==CODE_SJIS) {
        kanji_convert_euc2sjis(mesg);
    }
}



void kanji_convert_euc2sjis(unsigned char* mesg)
{
    int i = 0;
    while(mesg[i]!='\0' && mesg[i+1]!='\0'){
        if (mesg[i]>=0xa1 && mesg[i]<=0xfe){ // EUC
            euc2sjis(&mesg[i], &mesg[i+1]);
            i = i + 2;
        } 
        else  i++;
    }
}



void kanji_convert_sjis2euc(unsigned char* mesg)
{
    int i = 0;
    while(mesg[i]!='\0' && mesg[i+1]!='\0'){
        // if文が変則的なのは，コンパイラで警告が出るため   (GCC) 3.3.2 20031218 
        if ((mesg[i]>=0x81 && mesg[i]<=0x9f) ||
            (mesg[i]>=0xe0 && mesg[i]<=0xfe) || mesg[i]==0xff) { // SJIS
            sjis2euc(&mesg[i], &mesg[i+1]);
            i = i + 2;
        } 
        else  i++;
    }
}



void  euc2sjis(unsigned char *c1, unsigned char *c2)
{
    if (*c1%2==0) *c2 -= 0x02;
    else{
        *c2 -= 0x61;
        if (*c2>0x7e) (*c2)++;
    }

    if (*c1<0xdf) {
        (*c1)++;
        *c1 /= 2;
        *c1 += 0x30;
    }
    else {
        (*c1)++;
        *c1 /= 2;
        *c1 += 0x70;
    }
}



void  sjis2euc(unsigned char *c1, unsigned char *c2)
{
    if (*c2<0x9f) {
        if (*c1 < 0xa0) {
            *c1 -= 0x81;
            *c1 *= 2;
            *c1 += 0xa1;
        }
            
        else {
            *c1 -= 0xe0;
            *c1 *= 2;
            *c1 += 0xdf;
        }
        if (*c2>0x7f) (*c2)--;
        *c2 += 0x61;
    }
    else {
        if (*c1<0xa0) {
            *c1 -= 0x81;
            *c1 *= 2;
            *c1 += 0xa2;
        }
        else {
            *c1 -= 0xe0;
            *c1 *= 2;
            *c1 += 0xe0;
        }
        *c2 += 2;
     }
}



void  upper_string(char* str)
{
    int  i;
    for (i=0; i<(int)strlen((const char*)str); i++) {
        if (str[i]>='a' && str[i]<='z') str[i] += 'A' - 'a';
    }
}



unsigned char*  decode_base64(unsigned char* buf, int* sz)
{
    int   i, j, cc=0, bas, lt, ln;
    unsigned char* dcd;

    lt = 0;
    ln = (int)strlen((const char*)buf);
    while (buf[lt]!='=' && lt<ln) {
        lt++;
        if (lt==ln) break;
    }

    //len = lt/4*3 + (lt%4)*3/4;
    int len = ((lt+1)*3)/4;
    if (sz!=NULL) *sz = len;

    dcd = (unsigned char*)malloc(len);
    if (dcd==NULL) return NULL;
    memset(dcd, 0, len);

    for (i=0; i<lt; i++) {
        if      (buf[i]>='A' && buf[i]<='Z') cc = buf[i] - 'A';
        else if (buf[i]>='a' && buf[i]<='z') cc = buf[i] - 'a' + 26;
        else if (buf[i]>='0' && buf[i]<='9') cc = buf[i] - '0' + 52;
        else if (buf[i]=='+')                cc = 62;
        else if (buf[i]=='/')                cc = 63;

        if (cc<64) {
            bas = 32;
            for (j=0; j<6; j++) {
                setBit(dcd, i*6+j, cc/bas);
                cc = cc%bas;
                bas = bas/2;
            }
        }
    }

    return dcd;
}



unsigned char*  encode_base64(unsigned char* buf, int sz)
{
    unsigned char  base[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    unsigned char  bas;
    int   i, j, len;
    unsigned char*  ecd;
    
    if (buf==NULL) return NULL;
    if (sz<0) len = (int)strlen((const char*)buf);
    else        len = sz;
    if (len<=0) return NULL;

    sz  = ((len+2)/3)*4;
    ecd = (unsigned char*)malloc(sz+1);
    if (ecd==NULL) return NULL;
    memset(ecd, 0, sz+1);

    for (i=0; i<sz; i++) {
        bas = 0x00;
        if (len*8 > i*6) {
            for (j=0; j<6; j++) {
                if (len*8 > i*6+j) setBit(&bas, j+2, getBit(buf, i*6+j));
                //else               setBit(&bas, j+2, 0);
            }
            ecd[i] = base[(int)bas];
        }
        else {
            ecd[i] = '=';
        }
    }

    return ecd;
}


unsigned char*  decode_base64_filename(unsigned char* buf, int* sz)
{
    int i, len = (int)strlen((char*)buf);
    for (i=0; i<len; i++) {
        if (buf[i]=='$') buf[i] = '/';
    }

    unsigned char* dec = decode_base64(buf, sz);

    return dec;
}


unsigned char*  encode_base64_filename(unsigned char* buf, int sz)
{
    unsigned char* enc = encode_base64(buf, sz);

    int i, len = (int)strlen((char*)enc);
    for (i=0; i<len; i++) {
        if (enc[i]=='/') enc[i] = '$';
    }

    return enc;
}



unsigned char*  decode_urlenc(unsigned char* buf, int* sz)
{
    int i, j, len;
    unsigned char* dec;

    if (buf==NULL) return NULL;

    len = (int)strlen((const char*)buf) + 1;
    dec = (unsigned char*)malloc(len);
    if (dec==NULL) return NULL;
    memset(dec, 0, len);

    i = j = 0;
    while (buf[i]!='\0') {
        if (buf[i]=='%') {
            if (buf[i+1]=='\0') return dec;
            if (buf[i+2]=='\0') return dec;
            dec[j++] = decode_hex(buf[i+1], buf[i+2]);
            i += 2;
        }
        else {
            if (buf[i]=='+') dec[j++] = ' ';
            else             dec[j++] = buf[i];
        }
        i++;
    }

    *sz = j;
    return dec;
}
                


unsigned char*  encode_urlenc(unsigned char* buf, int sz)
{
    int i, j, len;
    unsigned char* enc;

    if (buf==NULL) return NULL;

    if (sz<0) sz = (int)strlen((const char*)buf);
    len = sz*3 + 1;
    enc = (unsigned char*)malloc(len);
    if (enc==NULL) return NULL;
    memset(enc, 0, len);

    for(i=0, j=0; i<sz; i++) {
        if (buf[i]==' ') {                                        // 半角スペース
            enc[j++] = '+';
        }
        else if ((buf[i]>=0x30 && buf[i]<=0x39) ||                // 0-9
                 (buf[i]>=0x41 && buf[i]<=0x5a) ||                // A-Z
                 (buf[i]>=0x61 && buf[i]<=0x7a) ||                // a-z
                  buf[i]=='-' || buf[i]=='.' || buf[i]=='_'){     // - . _
            enc[j++] = buf[i];
        }
        else {
            unsigned char* asc = encode_hex(buf[i]);
            if (asc==NULL) {
                free(enc);
                return NULL;
            }
            enc[j++] = '%';
            enc[j++] = asc[0];
            enc[j++] = asc[1];
            free(asc);
        }
    }

    return enc;
}    



unsigned char*  decode_quoted_printable(unsigned char* buf, int* sz)
{
    int    i, j, len;
    unsigned char*  dec;

    len = (int)strlen((const char*)buf) + 1;
    dec = (unsigned char*)malloc(len);
    if (dec==NULL) return NULL;
    memset(dec, 0, len);

    i = j = 0;
    while (buf[i]!='\0') {
        if (buf[i]=='=') {
            if (buf[i+1]=='\0') return dec;
            if (buf[i+2]=='\0') return dec;
            dec[j++] = decode_hex(buf[i+1], buf[i+2]);
            i += 2;
        }
        else {
            if (buf[i]=='_') dec[j++] = ' ';            // RFC2047
            else             dec[j++] = buf[i];
        }
        i++;
    }

    *sz = j;
    return dec;
}



unsigned char*  encode_quoted_printable(unsigned char* buf, int sz)
{
    int    i, j, len;
    unsigned char*  enc;

    if (sz<0) sz = (int)strlen((const char*)buf);
    len = sz*3 + 1;
    enc = (unsigned char*)malloc(len);
    if (enc==NULL) return NULL;
    memset(enc, 0, len);

    for (i=0, j=0; i<sz; i++) {
        if (buf[i]=='=') {        // 0x3d
            enc[j++] = '=';
            enc[j++] = '3';
            enc[j++] = 'D';
        }
        else if (buf[i]=='_') {        // 0x5f
            enc[j++] = '=';
            enc[j++] = '5';
            enc[j++] = 'F';
        }
        else if (buf[i]==' ') {        // 0x20  RFC2047
            enc[j++] = '_';
        }
        else if (buf[i]<=0x1f || buf[i]>=0x7f) {
            unsigned char* asc = encode_hex(buf[i]);
            if (asc==NULL) {
                free(enc);
                return NULL;
            }
            enc[j++] = '=';
            enc[j++] = asc[0];
            enc[j++] = asc[1];
            free(asc);
        }
        else {
            enc[j++] = buf[i];
        }
    }

    return enc;
}    



unsigned char*  encode_hex(unsigned char cc)
{
    unsigned char* ret;
    unsigned char  pp1, pp2;
    unsigned char  base[] = "0123456789ABCDEF";

    ret = (unsigned char*)malloc(3);
    if (ret==NULL) return NULL;

    pp1 = cc >> 4;
    pp2 = cc & 0x0f;

    ret[0] = base[pp1];
    ret[1] = base[pp2];
    ret[2] = '\0';

    return ret;
}



unsigned char  decode_hex(unsigned char pp1, unsigned char pp2)
{
    unsigned char ret;

    if (pp1>=0x30 && pp1<=0x39)      pp1 -= 0x30;    // 0-9
    else if (pp1>=0x41 && pp1<=0x46) pp1 -= 0x37;    // A-F
    else if (pp1>=0x61 && pp1<=0x66) pp1 -= 0x57;    // a-f
    else                             pp1 =  0x00;

    if (pp2>=0x30 && pp2<=0x39)      pp2 -= 0x30;    // 0-9
    else if (pp2>=0x41 && pp2<=0x46) pp2 -= 0x37;    // A-F
    else if (pp2>=0x41 && pp2<=0x46) pp2 -= 0x57;    // a-f
    else                             pp1 =  0x00;

    ret = (pp1<<4) + pp2;
    return ret;
}




//  バイト型 リングバッファ
//

ringBuffer*  new_ringBuffer(int sz)
{
    ringBuffer* rb;
    
    rb = (ringBuffer*)malloc(sizeof(ringBuffer));
    if (rb==NULL) return NULL;
    memset(rb, 0, sizeof(ringBuffer));
    rb->state = JBXL_NORMAL;
    
    if (sz>0) {
        rb->buf = (unsigned char*)malloc(sz);
        if (rb->buf==NULL) return rb;
        memset(rb->buf, 0, sz);
        rb->bufsz = sz;
    }
    return rb;
}



void  del_ringBuffer(ringBuffer** rb)
{
    if (rb!=NULL && *rb!=NULL) {
        freeNull((*rb)->buf);
        free(*rb);
        *rb = NULL;
    }
}



ringBuffer  init_ringBuffer()
{
    ringBuffer  rb;

    memset(&rb, 0, sizeof(ringBuffer));
    rb.state = JBXL_NORMAL;

    return rb;
}



ringBuffer  make_ringBuffer(int sz)
{
    ringBuffer  rb;

    memset(&rb, 0, sizeof(ringBuffer));
    
    if (sz>0) {
        rb.buf = (unsigned char*)malloc(sz);
        if (rb.buf==NULL) return rb;
        memset(rb.buf, 0, sz);
        rb.bufsz = sz;
        rb.state = JBXL_NORMAL;
    }

    return rb;
}



void  free_ringBuffer(ringBuffer* rb)
{
    if (rb!=NULL) {
        freeNull(rb->buf);
        memset(rb, 0, sizeof(ringBuffer));
        rb->state = JBXL_NORMAL;
    }
}



void   clear_ringBuffer(ringBuffer* rb)
{
    if (rb!=NULL) {
        int sz = rb->bufsz;
        unsigned char* ptr = rb->buf;
        memset(rb->buf, 0, rb->bufsz);
        memset(rb, 0, sizeof(ringBuffer));
        rb->buf   = ptr;
        rb->state = JBXL_NORMAL;
        rb->bufsz = sz;
    }
}



int  put_ringBuffer(ringBuffer* rb, unsigned char* pp, int sz)
{
    if (rb==NULL) return JBXL_ARGS_ERROR;
    rb->state = JBXL_NORMAL;

    if (pp==NULL)      return JBXL_ARGS_ERROR;
    if (rb->buf==NULL) return JBXL_TOOLS_BUF_ERROR;
    if (rb->datasz+sz>rb->bufsz) {
        rb->state = JBXL_ERROR;
        return JBXL_TOOLS_BUFSZ_ERROR;
    }

    if (rb->epoint+sz<=rb->bufsz) {
        memcpy(&(rb->buf[rb->epoint]), pp, sz);
        rb->epoint = rb->epoint + sz;
        if (rb->epoint==rb->bufsz) rb->epoint = 0;
    }
    else {
        memcpy(&(rb->buf[rb->epoint]), pp, rb->bufsz-rb->epoint);
        memcpy(rb->buf, &(pp[rb->bufsz-rb->epoint]), sz-(rb->bufsz-rb->epoint));
        rb->epoint = rb->epoint + sz - rb->bufsz; 
    }

    rb->datasz += sz;
    return sz;
}    



unsigned char*  get_ringBuffer(ringBuffer* rb, int sz)
{
    unsigned char* pp;

    if (rb==NULL) return NULL;
    if (rb->buf==NULL) return NULL;
    if (sz>rb->datasz) return NULL;

    pp = (unsigned char*)malloc(sz + 1);
    if (pp==NULL)  return NULL;
    memset(pp, 0, sz + 1);

    if (rb->spoint+sz<=rb->bufsz) {
        memcpy(pp, &(rb->buf[rb->spoint]), sz);
        rb->spoint = rb->spoint + sz;
        if (rb->spoint==rb->bufsz) rb->spoint = 0;
    }
    else {
        memcpy(pp, &(rb->buf[rb->spoint]), rb->bufsz-rb->spoint);
        memcpy(&(pp[rb->bufsz-rb->spoint]), rb->buf, sz-(rb->bufsz-rb->spoint));
        rb->spoint = rb->spoint + sz - rb->bufsz; 
    }

    rb->datasz -= sz;
    return pp;
}    



int  seek_ringBuffer(ringBuffer* rb, int sz)
{
    if (rb==NULL) return FALSE;
    if (rb->buf==NULL) return FALSE;
    if (sz>rb->datasz) return FALSE;

    if  (rb->spoint+sz>=rb->bufsz) {
        rb->spoint = rb->spoint + sz - rb->bufsz;
    }
    else if (rb->spoint+sz<0) {
        rb->spoint = rb->bufsz + rb->spoint + sz;
    }
    else  {
        rb->spoint = rb->spoint + sz;
    }

    rb->datasz -= sz;
    return TRUE;
}    



unsigned char*  ref_ringBuffer(ringBuffer* rb, int pos)
{
    unsigned char* pp;

    if (rb==NULL) return NULL;
    if (rb->buf==NULL) return NULL;
    if (pos>rb->datasz) return NULL;

    int sz = rb->spoint + pos;
    pp = rb->buf + sz;
    if (sz >= rb->bufsz) pp -= rb->bufsz;

    return pp;
}    




// バイト型 メッセージストリームバッファ
//

int  put_mstream(mstream* sb, unsigned char* mesg)
{
    int  i, n, m, cc, np=0, len;

    if (sb==NULL)   return JBXL_ARGS_ERROR;
    sb->state = JBXL_NORMAL;
    if (mesg==NULL) return JBXL_ARGS_ERROR;
    if (sb->buf==NULL) return JBXL_TOOLS_BUF_ERROR;

    len = (int)strlen((const char*)mesg);
    for (i=0, n=0, m=0; i<len; i++) {
        if (mesg[i]==CHAR_LF || (mesg[i]==CHAR_CR && mesg[i+1]!=CHAR_LF)) {
            if (m==0) m = i;
            n++;
        }
    }
    if (sb->datano==0 && n>=1) np = (sb->epoint + m + 1) % sb->bufsz;

    cc = put_ringBuffer(sb, mesg, len);
    if (cc>=0) {
        if (sb->datano==0 && n>=1) sb->npoint = np;
        sb->datano += n;
    }

    if (cc<0) sb->state = JBXL_ERROR;
    return cc;
}



unsigned char*  get_mstream(mstream* sb)
{
    int  n, len;
    unsigned char* pp;

    if (sb==NULL) return NULL;
    sb->state = JBXL_NORMAL;
    if (sb->buf==NULL) return NULL;
    if (sb->datano==0) return NULL;

    len = sb->npoint - sb->spoint;
    if (len==0) return NULL;
    else if (len<0) len += sb->bufsz;

    pp = get_ringBuffer(sb, len);
    if (pp==NULL) {
        sb->state = JBXL_ERROR;
        return NULL;
    }
    chomp((char*)pp);

    sb->datano += -1;
    sb->spoint = sb->npoint;

    if (sb->datano>=1) {
        int m;
        n = sb->spoint;
        while (n!=sb->epoint) {
            m = (n + 1) % sb->bufsz;
            if (sb->buf[n]==CHAR_LF || (sb->buf[n]==CHAR_CR && sb->buf[m]!=CHAR_LF)) {
                sb->npoint = m;
                break;
            }
            n = m;
        }
    }

    return pp;
}



unsigned char*  fgets_mstream(unsigned char* mesg, mstream* sb)
{
    int state = JBXL_NORMAL;
    unsigned char* pp;

    if (sb==NULL) return NULL;
    if (sb->buf==NULL) {
        *sb = make_mstream(RECVBUFSZ);
        if (sb->buf==NULL) return NULL;
    }

    if (mesg!=NULL) put_mstream(sb, mesg);
    if (sb->state<0) state = sb->state;

    if (sb->datano==0) {
        sb->state = JBXL_NODATA;
        return NULL;
    }
    pp = get_mstream(sb);
    
    if (sb->state>=0 && state<0) sb->state = state;
    return pp;
}




//

unsigned char*  uuid2guid(unsigned char* p)
{
    unsigned char* guid;

    if (p==NULL) return NULL;

    guid = (unsigned char*)malloc(LGUID);    // 40 = 32+4+1(\0) + α
    if (guid==NULL) return NULL;

    snprintf((char*)guid, 37, "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
                    p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7],p[8],p[9],p[10],p[11],p[12],p[13],p[14],p[15]);

    return guid;
}



unsigned char*  guid2uuid(unsigned char* p)
{
    int   i, j;
    unsigned char* uuid;

    if (p==NULL) return NULL;

    uuid = (unsigned char*)malloc(16);
    if (uuid==NULL) return NULL;

    i = j = 0;
    while (p[i]!='\0' && j<16) {
        if (p[i]!='-' && p[i+1]!='\0') {
            unsigned char hb, lb;

            if      (p[i]>='0' && p[i]<='9')     hb = p[i] - '0';
            else if (p[i]>='a' && p[i]<='f')     hb = p[i] - 'a' + 10;
            else if (p[i]>='A' && p[i]<='F')     hb = p[i] - 'A' + 10;
            else hb = '\0';

            if      (p[i+1]>='0' && p[i+1]<='9') lb = p[i+1] - '0';
            else if (p[i+1]>='a' && p[i+1]<='f') lb = p[i+1] - 'a' + 10;
            else if (p[i+1]>='A' && p[i+1]<='F') lb = p[i+1] - 'A' + 10;
            else lb = '\0';
            
            uuid[j] = (hb<<4) + lb;
            i++;
            j++;
        }
        i++;
    }

    return uuid;
}




//

#ifndef WIN32

unsigned long int get_used_memory(void)
{
    struct sysinfo info;
    sysinfo(&info);

    // キャッシュサイズが引けていない．
    unsigned long int mem = info.totalram - info.freeram - info.bufferram - info.sharedram;
    return mem*info.mem_unit/1024;
}


unsigned long int get_free_memory(void)
{
    struct sysinfo info;
    sysinfo(&info);

    unsigned long int mem = info.freeram;
    return mem*info.mem_unit/1024;
}

#endif




// シグナル処理
//
#ifndef WIN32

#ifdef SIGCHLD

void  set_sigterm_child(void (*handler)(int))
{    
    struct sigaction sa;

    memset(&sa, 0, sizeof(sa));
    if (handler!=NULL) sa.sa_handler = handler;
    else               sa.sa_handler = sigterm_child;

    sa.sa_flags = SA_NOCLDSTOP | SA_RESTART; 
    sigemptyset(&sa.sa_mask);
    sigaddset(&sa.sa_mask, SIGINT);     // SIGCHLD 処理中は SIGINT  をブロック
    sigaddset(&sa.sa_mask, SIGHUP);     // SIGCHLD 処理中は SIGHUP  をブロック
    sigaddset(&sa.sa_mask, SIGTERM);    // SIGCHLD 処理中は SIGTERM をブロック
    sigaction(SIGCHLD, &sa, NULL);
}



void  sigterm_child(int signal)
{
    UNUSED(signal);

    pid_t pid = 0;
    int ret;

    //DEBUG_MODE PRINT_MESG("%d is waiting for children. signal = %d\n", getpid(), signal);
    //signal = 0;        // dummy for warning of compiler

    do {    // チャイルドプロセスの終了を待つ    
        pid = waitpid(-1, &ret, WNOHANG);
    } while(pid>0);
}


void  ignore_sigterm_child()
{    
    struct sigaction sa;

    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = SIG_IGN;
    sa.sa_flags   = 0; 
    sigemptyset(&sa.sa_mask);
    sigaction(SIGCHLD, &sa, NULL);
}



void  set_sigsegv_handler(void (*handler)(int))
{
    struct sigaction sa;

    memset(&sa, 0, sizeof(sa));
    if (handler!=NULL) sa.sa_handler = handler;
    else               sa.sa_handler = trap_segmentation_falt;
    
    sa.sa_flags = 0;
    sigemptyset(&sa.sa_mask);
    sigaction(SIGSEGV, &sa, NULL);
}



void  trap_segmentation_falt(int signal)
{
    PRINT_MESG("****************************************************************\n");
    PRINT_MESG("* Segmentation Falt in [%d] !!!!!\n", getpid());
    PRINT_MESG("****************************************************************\n");

    exit(signal);
}


#endif        // SIGCHLD

#endif        // NOT WIN32



// for MS Windows
//

#ifdef WIN32

/* see common.h

void  bzero(char* p, unsigned int n)
{
    for (unsigned int i=0; i<n; i++) *(p++) = 0x00;
}


void  bcopy(char* f, char* t, unsigned int n)
{
    for (unsigned int i=0; i<n; i++) *(t++) = *(f++);
}
*/

#endif   // WIN32




// 入出力＆DEBUG
//

FILE*  FP_LogFile = NULL;
FILE*  FP_ErrFile = NULL;


void  open_logfile(void)
{
    if (FP_LogFile!=NULL) return;

    FP_LogFile = fopen(JBXL_LOG_FILE, "a");
    return;
}



void  close_logfile(void)
{
    if (FP_LogFile==NULL) return;

    fclose(FP_LogFile);
    FP_LogFile = NULL;

    return;
}



void  print_logfile(const char* fmt, ...)
{
    char*  nfmt;
    int    len;
    int    slfopn = FALSE;

    //
    if (FP_LogFile==NULL) {
        FP_LogFile = fopen(JBXL_LOG_FILE, "a");
        if (FP_LogFile==NULL) return;
        slfopn = TRUE;
    }

    va_list  args;
    va_start(args, fmt);

    len  = (int)strlen(fmt);    
    nfmt = (char*)malloc(len + 2);
    if (nfmt==NULL) return;

    strncpy(nfmt, fmt, len);
    nfmt[len]   = '\n';
    nfmt[len+1] = '\0';

    vfprintf(FP_LogFile, nfmt, args); 
    fflush(FP_LogFile);
    free(nfmt);

    va_end(args);

    //
    if (slfopn && FP_LogFile!=NULL) {
        fclose(FP_LogFile);
        FP_LogFile = NULL;
    }

    return;
}



void  open_errfile(void)
{
    if (FP_ErrFile!=NULL) return;

    FP_LogFile = fopen(JBXL_ERR_FILE, "a");
    return;
}



void  close_errfile(void)
{
    if (FP_ErrFile==NULL) return;

    fclose(FP_ErrFile);
    FP_ErrFile = NULL;

    return;
}



void  print_errfile(const char* fmt, ...)
{
    char*  nfmt;
    int    len;
    int    slfopn = FALSE;

    //
    if (FP_ErrFile==NULL) {
        FP_ErrFile = fopen(JBXL_ERR_FILE, "a");
        if (FP_ErrFile==NULL) return;
        slfopn = TRUE;
    }

    va_list  args;
    va_start(args, fmt);

    len  = (int)strlen(fmt);    
    nfmt = (char*)malloc(len + 2);
    if (nfmt==NULL) return;

    strncpy(nfmt, fmt, len);
    nfmt[len]   = '\n';
    nfmt[len+1] = '\0';

    vfprintf(FP_ErrFile, nfmt, args); 
    fflush(FP_ErrFile);
    free(nfmt);

    va_end(args);

    //
    if (slfopn && FP_ErrFile!=NULL) {
        fclose(FP_ErrFile);
        FP_ErrFile = NULL;
    }

    return;
}


void  print_message(const char* fmt, ...)
{
    char*  nfmt;
    int    len;

    va_list  args;
    va_start(args, fmt);

    len  = (int)strlen(fmt);    
    nfmt = (char*)malloc(len + 1);
    if (nfmt==NULL) return;

    strncpy(nfmt, fmt, len);
    nfmt[len] = '\0';

    vfprintf(stderr, nfmt, args); 
    fflush(stderr);
    free(nfmt);

    va_end(args);

    return;
}



void  fprint_message(FILE* fp, const char* fmt, ...)
{
    char*  nfmt;
    int    len;

    va_list  args;
    va_start(args, fmt);

    len  = (int)strlen(fmt);    
    nfmt = (char*)malloc(len + 1);
    if (nfmt==NULL) return;

    strncpy(nfmt, fmt, len);
    nfmt[len] = '\0';

    vfprintf(fp, nfmt, args); 
    fflush(fp);
    free(nfmt);

    va_end(args);

    return;
}



void  print_escape(const char* fmt, char* mesg)
{
    char* pp;

    if (fmt==NULL || mesg==NULL) return;
    
    pp = change_esc(mesg);
    if (pp==NULL) return;

    PRINT_MESG(fmt, pp);
    free(pp);
}



void  fprint_escape(FILE* fp, char* fmt, char* mesg)
{
    char* pp;

    if (fmt==NULL || mesg==NULL) return;
    
    pp = change_esc(mesg);
    if (pp==NULL) return;

    fprint_message(fp, fmt, pp);
    free(pp);
}



void  fdump(FILE* fp, unsigned char* mesg, int n)
{
    int  i, j, mod, len;
    char ascii[16];

    if (fp==NULL) fp = stderr;

    if (mesg==NULL) {
        fprintf(fp, "(Dump Data is NULL)\n");
        return;
    }

    if (n<0) len = (int)strlen((const char*)mesg);
    else     len = n;

    memset(ascii, 0x2e, 16);
    for (i=0, j=0; i<len; i++) {
        fprintf(fp, "%02x ", mesg[i]);
        if (mesg[i]>=0x20 && mesg[i]<=0x7e) ascii[j] = mesg[i];
        j++;
        if (j==16) {
            fprintf(fp, "   ");
            for (j=0; j<16; j++) {
                fprintf(fp, "%c ", ascii[j]);
            }
            fprintf(fp, "\n");
            memset(ascii, 0x2e, 16);
            j = 0;
        }
    }
                
    mod = len%16;
    if (mod>0) {                           
        for (i=0; i<17-mod; i++) fprintf(fp, "   ");
        for (i=0; i<mod; i++)    fprintf(fp, "%c ", ascii[i]);
    }                    
    fprintf(fp, "\n");
}



void  print_16x(FILE* fp, unsigned char* mesg, int n)
{
    int  i, len;

    if (fp==NULL) fp = stderr;

    if (n<0) len = (int)strlen((const char*)mesg);
    else     len = n;

    for (i=0; i<len; i++) {
        fprintf(fp, "%02x", mesg[i]);
    }
    fprintf(fp, "\n");
}

---