JunkBox_Lib++ (for Windows): BasicLib/Lib/xtools.cpp Source File

00001 
00017 #include "xtools.h"
00018 
00019 
00020 
00022 // Networks for IPv4 互換用
00023 //
00024 
00041 int  udp_recv_Buffer_sockaddr_in(int sock, Buffer* str, struct sockaddr_in* sv_addr)
00042 {
00043     int cc, cadlen;
00044 
00045     if (sv_addr==NULL) return JBXL_ARGS_ERROR;
00046 
00047     cadlen = sizeof(*sv_addr);
00048     memset(str->buf, 0, str->bufsz);
00049     str->vldsz = 0;
00050     str->state = JBXL_NORMAL;
00051     cc = recvfrom(sock, (char*)str->buf, str->bufsz, 0, (struct sockaddr*)sv_addr, (socklen_t*)&cadlen);
00052 
00053     if (cc>=0) str->vldsz = cc;
00054     else       str->state = cc = JBXL_NET_RECV_ERROR;
00055 
00056     return cc;
00057 }
00058 
00059 
00060 
00076 int  udp_send_Buffer_sockaddr_in(int sock, Buffer* str, struct sockaddr_in* sv_addr)
00077 {
00078     int cc;
00079 
00080     if (sv_addr==NULL) return JBXL_ARGS_ERROR;
00081     
00082     if (str->vldsz<0) str->vldsz = (int)strlen((const char*)str->buf);
00083     cc = sendto(sock, (char*)str->buf, str->vldsz, 0, (struct sockaddr*)sv_addr, sizeof(*sv_addr));
00084 
00085     if (cc<0) cc = JBXL_NET_SEND_ERROR;
00086     return cc;
00087 }
00088 
00089 
00090 
00104 int  udp_send_sBuffer_sockaddr_in(int sock, Buffer* str, struct sockaddr_in* sv_addr)
00105 {
00106     int cc;
00107 
00108     if (sv_addr==NULL) return JBXL_ARGS_ERROR;
00109     
00110     cc = sendto(sock, (char*)str->buf, (int)strlen((const char*)str->buf), 0, (struct sockaddr*)sv_addr, sizeof(*sv_addr));
00111     if (cc<0) cc = JBXL_NET_SEND_ERROR;
00112 
00113     return cc;
00114 }
00115 
00116 
00135 int  udp_recv_Buffer_wait_sockaddr_in(int sock, Buffer* str, struct sockaddr_in* sv_addr, int tm)
00136 {
00137     int cc;
00138 
00139     if (sv_addr==NULL) return JBXL_ARGS_ERROR;
00140 
00141     //memset(str->buf, 0, str->bufsz);
00142     str->vldsz = 0;
00143     cc = udp_recv_wait_sockaddr_in(sock, (char*)str->buf, str->bufsz, sv_addr, tm);
00144     if (cc>=0) str->vldsz = cc;
00145 
00146     return cc;
00147 }
00148 
00149 
00150 
00162 struct sockaddr_in  get_sockaddr_in_Buffer(Buffer buf)
00163 {
00164     int i, port = 0;
00165     struct sockaddr_in  addr;
00166     memset(&addr, 0, sizeof(struct sockaddr_in));
00167 
00168     if (buf.buf==NULL) return addr;
00169     
00170     i = 0;
00171     while (buf.buf[i]!='\0' && buf.buf[i]!=':') i++;
00172     buf.buf[i] = '\0';
00173 
00174     port = atoi((char*)&buf.buf[i+1]);
00175     addr = get_sockaddr_in((char*)buf.buf, port);
00176 
00177     return addr;
00178 }
00179 
00180 
00181 
00182 /*
00183 Buffer get_hostport_sockaddr_in(struct sockaddr_in addr)
00184 {
00185     Buffer buf;
00186     char  hostport[LBUF];
00187     char* ip = get_ipaddr_ipv4(addr.sin_addr);
00188     unsigned short port = ntohs(addr.sin_port);
00189 
00190     snprintf(hostport, LBUF, "%s:%d", ip, port);
00191     
00192     buf = make_Buffer_bystr(hostport);
00193     return buf;
00194 }
00195 */
00196 
00197 
00198 
00199 
00201 // Networks for IPv4/IPv6 
00202 //
00203 
00204 
00221 int  udp_recv_Buffer(int sock, Buffer* str, struct addrinfo* sv_addr)
00222 {
00223     int cc;
00224     socklen_t cadlen;
00225 
00226     if (str==NULL || str->buf==NULL) return JBXL_ARGS_ERROR;
00227     if (sv_addr==NULL) return JBXL_ARGS_ERROR;
00228 
00229     cadlen = (int)sv_addr->ai_addrlen;
00230     memset(str->buf, 0, str->bufsz);
00231     str->vldsz = 0;
00232     str->state = JBXL_NORMAL;
00233     cc = recvfrom(sock, (char*)str->buf, str->bufsz, 0, sv_addr->ai_addr, &cadlen);
00234 
00235     if (cc>=0) str->vldsz = cc;
00236     else       str->state = cc = JBXL_NET_RECV_ERROR;
00237 
00238     return cc;
00239 }
00240 
00241 
00242 
00258 int  udp_send_Buffer(int sock, Buffer* str, struct addrinfo* sv_addr)
00259 {
00260     int cc;
00261 
00262     if (str==NULL || str->buf==NULL) return JBXL_ARGS_ERROR;
00263     if (sv_addr==NULL) return JBXL_ARGS_ERROR;
00264     
00265     if (str->vldsz<0) str->vldsz = (int)strlen((const char*)str->buf);
00266     cc = sendto(sock, (char*)str->buf, str->vldsz, 0, sv_addr->ai_addr, (int)sv_addr->ai_addrlen);
00267 
00268     if (cc<0) cc = JBXL_NET_SEND_ERROR;
00269 
00270     return cc;
00271 }
00272 
00273 
00274 
00287 int  tcp_recv_Buffer(int sock, Buffer* str)
00288 {
00289     int cc;
00290 
00291     if (str==NULL || str->buf==NULL) return JBXL_ARGS_ERROR;
00292 
00293     memset(str->buf, 0, str->bufsz);
00294     str->vldsz = 0;
00295     str->state = JBXL_NORMAL;
00296     cc = recv(sock, (char*)str->buf, str->bufsz, 0);
00297 
00298     if (cc>=0) str->vldsz = cc;
00299     else       str->state = cc = JBXL_NET_RECV_ERROR;
00300 
00301     return cc;
00302 }
00303 
00304 
00305 
00317 int  tcp_send_Buffer(int sock, Buffer* str)
00318 {
00319     int cc;
00320 
00321     if (str==NULL || str->buf==NULL) return JBXL_ARGS_ERROR;
00322 
00323     if (str->vldsz<0) str->vldsz = (int)strlen((const char*)str->buf);
00324     cc = send(sock, (char*)str->buf, str->vldsz, 0);
00325 
00326     if (cc<0) cc = JBXL_NET_SEND_ERROR;
00327     return cc;
00328 }
00329 
00330 
00331 
00350 int  udp_recv_Buffer_wait(int sock, Buffer* str, struct addrinfo* sv_addr, int tm)
00351 {
00352     int cc;
00353 
00354     if (str==NULL || str->buf==NULL) return JBXL_ARGS_ERROR;
00355     if (sv_addr==NULL) return JBXL_ARGS_ERROR;
00356 
00357     //memset(str->buf, 0, str->bufsz);
00358     str->vldsz = 0;
00359     cc = udp_recv_wait(sock, (char*)str->buf, str->bufsz, sv_addr, tm);
00360     if (cc>=0) str->vldsz = cc;
00361 
00362     return cc;
00363 }
00364 
00365 
00366 
00384 int  tcp_recv_Buffer_wait(int sock, Buffer* str, int tm)
00385 {
00386     int cc;
00387 
00388     if (str==NULL || str->buf==NULL) return JBXL_ARGS_ERROR;
00389 
00390     //memset(str->buf, 0, str->bufsz);
00391     str->vldsz = 0;
00392     cc = tcp_recv_wait(sock, (char*)str->buf, str->bufsz, tm);
00393     if (cc>=0) str->vldsz = cc;
00394 
00395     return cc;
00396 }
00397 
00398 
00399 
00415 int  tcp_recv_Buffer_tosize(int sock, Buffer* str, Buffer* mod, int size)
00416 {
00417     int cc, sz;
00418     int modon = FALSE;
00419 
00420     if (str==NULL || str->buf==NULL) return JBXL_ARGS_ERROR;
00421     if (mod!=NULL && mod->buf!=NULL) modon = TRUE;
00422 
00423     if (modon) memset(mod->buf, 0, mod->vldsz);
00424     Buffer buf = make_Buffer(RECVBUFSZ);
00425 
00426     sz = str->vldsz;
00427     while (sz<size) {
00428         cc = tcp_recv_Buffer(sock, &buf);
00429         if (cc>0) {
00430             cat_Buffer(&buf, str);
00431             sz += cc;
00432         }
00433         else {
00434             if (cc<0) sz = cc;
00435             break;
00436         }
00437     }
00438     free_Buffer(&buf);
00439 
00440     if (sz>size && modon) {
00441         copy_b2Buffer((void*)(str->buf+size), mod, sz-size);
00442         str->vldsz = size;
00443     }
00444     return sz;
00445 }
00446 
00447 
00448 
00469 int  tcp_recv_Buffer_tosize_wait(int sock, Buffer* str, Buffer* mod, int size, int tm)
00470 {
00471     int cc, sz;
00472     int modon = FALSE;
00473 
00474     if (str==NULL || str->buf==NULL) return JBXL_ARGS_ERROR;
00475     if (mod!=NULL && mod->buf!=NULL) modon = TRUE;
00476 
00477     if (modon) memset(mod->buf, 0, mod->vldsz);
00478     Buffer buf = make_Buffer(RECVBUFSZ);
00479 
00480     sz = str->vldsz;
00481     while (sz<size) {
00482         cc = tcp_recv_Buffer_wait(sock, &buf, tm);
00483         if (cc>0) {
00484             cat_Buffer(&buf, str);
00485             sz += cc;
00486         }
00487         else {
00488             if (cc<0) sz = cc;
00489             break;
00490         }
00491     }
00492     free_Buffer(&buf);
00493 
00494     if (sz>size && modon) {
00495         copy_b2Buffer((void*)(str->buf+size), mod, sz-size);
00496         str->vldsz = size;
00497     }
00498     return sz;
00499 }
00500 
00501 
00502 
00516 int  udp_send_sBuffer(int sock, Buffer* str, struct addrinfo* sv_addr)
00517 {
00518     int cc;
00519 
00520     if (str==NULL || str->buf==NULL) return JBXL_ARGS_ERROR;
00521     if (sv_addr==NULL) return JBXL_ARGS_ERROR;
00522     
00523     cc = sendto(sock, (char*)str->buf, (int)strlen((const char*)str->buf), 0, sv_addr->ai_addr, (int)sv_addr->ai_addrlen);
00524     if (cc<0) cc = JBXL_NET_SEND_ERROR;
00525 
00526     return cc;
00527 }
00528 
00529 
00530 
00542 int  tcp_send_sBuffer(int sock, Buffer* str)
00543 {
00544     int cc;
00545 
00546     if (str==NULL || str->buf==NULL) return JBXL_ARGS_ERROR;
00547 
00548     cc = send(sock, (char*)str->buf, (int)strlen((const char*)str->buf), 0);
00549     return cc;
00550 }
00551 
00552 
00553 
00565 int  tcp_send_sBufferln(int sock, Buffer* str)
00566 {
00567     int   cc;
00568     Buffer buf;
00569 
00570     if (str==NULL || str->buf==NULL) return JBXL_ARGS_ERROR;
00571 
00572     buf = dup_Buffer(*str);
00573     cat_s2Buffer("\r\n", &buf);
00574     cc = send(sock, (char*)buf.buf, (int)strlen((const char*)buf.buf), 0);
00575     free_Buffer(&buf);
00576 
00577     return cc;
00578 }
00579 
00580 
00581 
00612 int  tcp_recv_mstream_Buffer(int sock, Buffer* mesg, mstream* sb, int tm)
00613 {
00614     int    cc;
00615     unsigned char* pp;
00616 
00617     if (mesg==NULL || sb==NULL) return JBXL_ARGS_ERROR;
00618     *mesg = make_Buffer(LBUF);
00619 
00620     if (sb->buf==NULL) {
00621         *sb = make_mstream(RECVBUFSZ);
00622         if (sb->buf==NULL) return JBXL_MALLOC_ERROR;
00623     }
00624 
00625     while (sb->datano==0) {
00626         cc = tcp_recv_Buffer_wait(sock, mesg, tm);
00627         if (cc<=0) {
00628             free_Buffer(mesg);
00629             return cc;
00630         }
00631         put_mstream(sb, mesg->buf);
00632         clear_Buffer(mesg);
00633     }
00634 
00635     pp = get_mstream(sb);
00636     if (pp==NULL) return JBXL_NET_BUF_ERROR;
00637     copy_s2Buffer((char*)pp, mesg);
00638     free(pp);
00639 
00640     return mesg->vldsz;
00641 }
00642 
00643 
00644 
00667 int  tcp_recv_lines_Buffer(int sock, Buffer* mesg, int tm)
00668 {
00669     int    cc;
00670     Buffer buf;
00671 
00672     if (mesg==NULL) return JBXL_ARGS_ERROR;
00673     buf = make_Buffer(LBUF);
00674 
00675     cc = tcp_recv_Buffer_wait(sock, &buf, tm);
00676     while (cc>0) {
00677         cat_Buffer(&buf, mesg);
00678         if (buf.buf[cc-1]==CHAR_LF) break;
00679         clear_Buffer(&buf);
00680         cc = tcp_recv_Buffer_wait(sock, &buf, tm);
00681     }
00682     free_Buffer(&buf);
00683         
00684     if (cc<=0) {
00685         free_Buffer(mesg);
00686         return cc;
00687     }
00688 
00689     return mesg->vldsz;
00690 }
00691 
00692 
00693 
00695 // for URL
00696 //
00697 
00708 Buffer  comp_hostport(char* host, unsigned short port)
00709 {
00710     Buffer buf;
00711     char   hostport[LBUF];
00712 
00713     hostport[0] = '\0';
00714 
00715     if (host!=NULL) {
00716         if (port!=0) snprintf(hostport, LBUF-1, "%s:%d", host, port);
00717         else         snprintf(hostport, LBUF-1, "%s", host);
00718     }
00719     else {
00720         if (port!=0) snprintf(hostport, LBUF-1, "%d", port);
00721     }
00722 
00723     buf = make_Buffer_bystr(hostport);
00724 
00725     return buf;
00726 }
00727 
00728 
00729 
00742 int  decomp_hostport(Buffer buf, Buffer* host, unsigned short* port)
00743 {
00744     if (buf.buf==NULL) return FALSE;
00745 
00746     if (port!=NULL) {
00747         int i = 0;
00748         while (buf.buf[i]!='\0' && buf.buf[i]!=':') i++;
00749         if (buf.buf[i]!='\0') *port = (unsigned short)atoi((char*)&buf.buf[i+1]);
00750         else *port = 0;
00751     }
00752 
00753     if (host!=NULL) {
00754         Buffer hostport = dup_Buffer(buf);
00755     
00756         int i = 0;
00757         while (hostport.buf[i]!='\0' && hostport.buf[i]!=':') i++;
00758         hostport.buf[i] = '\0';
00759         hostport.vldsz  = (int)strlen((char*)hostport.buf);
00760         *host = hostport;
00761     }
00762 
00763     return TRUE;
00764 }
00765 
00766 
00767 
00780 Buffer  comp_url(char* protocol, char* host, unsigned short port, char* dir)
00781 {
00782     Buffer url;
00783     char   num[20];
00784 
00785     url = make_Buffer(LNAME);
00786 
00787     if (protocol!=NULL) {
00788         copy_s2Buffer(protocol, &url);
00789         cat_s2Buffer("://", &url);
00790     }
00791 
00792     cat_s2Buffer(host, &url);
00793 
00794     if (port!=0) {
00795         snprintf(num, 10, ":%d", port);
00796         cat_s2Buffer(num, &url);
00797     }
00798 
00799     if (dir!=NULL) {
00800         if (dir[0]!='/') cat_s2Buffer("/", &url);
00801         cat_s2Buffer(dir, &url);
00802     }
00803 
00804     return url;
00805 }
00806 
00807 
00808 
00831 int  decomp_url(Buffer url, Buffer* srvurl, Buffer* protocol, Buffer* srvfqdn, unsigned short* sport, Buffer* srvdir)
00832 {
00833     Buffer item1, item2, item3, item4, wrk;
00834 
00835     if (srvurl  !=NULL) *srvurl   = init_Buffer();
00836     if (protocol!=NULL) *protocol = init_Buffer();
00837     if (srvfqdn !=NULL) *srvfqdn  = init_Buffer();
00838     if (srvdir  !=NULL) *srvdir   = init_Buffer();
00839     if (sport   !=NULL) *sport    = 0;
00840     if (url.buf ==NULL) return FALSE;
00841 
00842     item1 = init_Buffer();
00843     item2 = init_Buffer();
00844     item3 = init_Buffer();
00845     item4 = init_Buffer();
00846      
00847     if (strstr((char*)url.buf, "://")!=NULL) {
00848         // http(s)://www.tuis.ac.jp:8100/..... 
00849         item1 = awk_Buffer(url, '/', 1);    // http(s):
00850         item2 = awk_Buffer(url, '/', 3);    // www.tuis.ac.jp:8100
00851         if (protocol!=NULL) {
00852             *protocol = dup_Buffer(item1);
00853             protocol->buf[protocol->vldsz-1] = '\0';
00854             protocol->vldsz--;
00855         }
00856     }
00857     else {
00858         // www.tuis.ac.jp:8100/..... 
00859         item2 = awk_Buffer(url, '/', 1);    // www.tuis.ac.jp:8100
00860     }
00861 
00862     if (item2.buf!=NULL) {
00863         item3 = awk_Buffer(item2, ':', 1);  // www.tuis.ac.jp
00864         if (item3.buf==NULL) {
00865             free_Buffer(&item1);
00866             free_Buffer(&item2);
00867             return FALSE;
00868         }
00869         item4 = awk_Buffer(item2, ':', 2);  // 8100
00870     }
00871     else {
00872         free_Buffer(&item1);
00873         return FALSE;
00874     }
00875 
00876     if (item4.buf!=NULL && sport!=NULL) {
00877         *sport = (unsigned short)atoi((char*)item4.buf);
00878     }
00879      
00880     wrk = make_Buffer(LBUF);
00881     if (item1.buf!=NULL) {
00882         copy_Buffer(&item1, &wrk);
00883         cat_s2Buffer("//",  &wrk);
00884     }
00885     cat_Buffer(&item2,  &wrk);
00886 
00887     if (item3.buf!=NULL) {
00888         if (srvfqdn!=NULL) *srvfqdn = item3;
00889         else free_Buffer(&item3);
00890     }
00891      
00892     if (srvdir!=NULL) {
00893         *srvdir = make_Buffer_bystr((char*)(url.buf+strlen((char*)(wrk.buf))));
00894         if ((srvdir->buf)[0]=='\0') copy_s2Buffer("/", srvdir);
00895     }
00896 
00897     if (srvurl!=NULL) *srvurl = wrk;
00898     else free_Buffer(&wrk);
00899 
00900     free_Buffer(&item1);
00901     free_Buffer(&item2);
00902     free_Buffer(&item4);
00903      
00904     return TRUE;
00905 }                                           
00906 
00907 
00908 Buffer  make_form_urlenc(const char* key, const char* val)
00909 {
00910     Buffer buf = init_Buffer();
00911     if (key==NULL) return buf;
00912 
00913     buf = make_Buffer_str(key);
00914     cat_s2Buffer("=", &buf);
00915 
00916     if (val!=NULL) {
00917         unsigned char* val_enc = encode_urlenc((unsigned char*)val, -1);
00918         if (val_enc!=NULL) {
00919             cat_s2Buffer(val_enc, &buf);
00920             free(val_enc);
00921         }
00922     }
00923     
00924     return buf;
00925 }
00926 
00927 
00928 void   add_form_urlenc(Buffer* buf, const char* key, const char* val)
00929 {
00930     if (buf==NULL || key==NULL) return;
00931 
00932     cat_s2Buffer("&", buf);
00933     cat_s2Buffer(key, buf);
00934     cat_s2Buffer("=", buf);
00935 
00936     if (val!=NULL) {
00937         unsigned char* val_enc = encode_urlenc((unsigned char*)val, -1);
00938         if (val_enc!=NULL) {
00939             cat_s2Buffer(val_enc, buf);
00940             free(val_enc);
00941         }
00942     }
00943 
00944     return;
00945 }
00946 
00947 
00948 
00950 // File I/O 
00951 //
00952 
00980 int   save_tagged_Buffer(Buffer buf, FILE* fp, unsigned int mode, int prfm)
00981 {    
00982     int     cc;
00983     Buffer  tag, enc;
00984 
00985     tag = make_Buffer(2);
00986     if (tag.buf==NULL) return FALSE;
00987     tag.buf[0] = mode & 0x0f;            // データの種別
00988     tag.buf[1] = mode & 0xf0;            // データの形式
00989 
00990     // JBXL_FIO_ORIGINAL, JBXL_FIO_BASE64 以外は未サポート
00991     if (tag.buf[1]==JBXL_FIO_ORIGINAL || !prfm) {
00992         enc = dup_Buffer(buf);
00993     }
00994     else if (tag.buf[1]==JBXL_FIO_BASE64) {
00995         enc = encode_base64_Buffer(buf);
00996     }
00997     else {                            
00998         enc = dup_Buffer(buf);
00999     }
01000 
01001     tag.vldsz = 2;
01002     cc = save_Buffer2_fp(tag, enc, fp); 
01003     free_Buffer(&enc);
01004     free_Buffer(&tag);
01005 
01006     if (!cc) return FALSE;
01007     return  TRUE;
01008 }
01009 
01010 
01011 
01038 Buffer  read_tagged_Buffer(FILE* fp, unsigned int* mode)
01039 {    
01040     unsigned char mthd, kind;
01041     Buffer   tmp, tag, enc, buf;
01042 
01043     buf = init_Buffer();
01044     if (mode==NULL) return buf;
01045 
01046     if (!read_Buffer2_fp(&tag, &enc, fp)) return buf;
01047 
01048     kind = *mode & 0x0f;                // データの種別
01049     mthd = *mode & 0xf0;                // データの形式
01050     if (kind!=tag.buf[0] && kind!=JBXL_FIO_ANY) {
01051         free_Buffer(&enc);
01052         free_Buffer(&tag);
01053         return buf;
01054     }
01055 
01056     // JBXL_FIO_ORIGINAL, JBXL_FIO_BASE64 以外は未サポート
01057     if (mthd==tag.buf[1]) {                // 保存形式と呼び出し形式は同じ
01058         buf = dup_Buffer(enc);
01059     }
01060     else {
01061         // 保存データをオリジナルへ
01062         if (tag.buf[1]==JBXL_FIO_BASE64) {
01063             tmp = decode_base64_Buffer(enc);
01064         }
01065         else {
01066             tmp = dup_Buffer(enc);
01067         }
01068 
01069         // オリジナルを呼び出し形式へ
01070         if (mthd==JBXL_FIO_BASE64) {
01071             buf = encode_base64_Buffer(tmp);
01072         }
01073         else {
01074             buf = dup_Buffer(tmp);
01075         }
01076         free_Buffer(&tmp);
01077     }
01078 
01079     *mode = (unsigned int)tag.buf[0];    // データ種別
01080     free_Buffer(&enc);
01081     free_Buffer(&tag);
01082 
01083     return  buf;
01084 }
01085 
01086 
01087 
01106 Buffer  fgets_mstream_Buffer(Buffer buf, mstream* sb)
01107 {
01108     Buffer   ret;
01109     unsigned char* pp;
01110 
01111     ret = init_Buffer();
01112 
01113     pp = fgets_mstream(buf.buf, sb);
01114     if (pp!=NULL) {
01115         ret = make_Buffer(LBUF);
01116         copy_s2Buffer((char*)pp, &ret);
01117         free(pp);
01118     }
01119     return ret;
01120 }
01121 
01122 
01123 
01124 
01126 // Run Length
01127 //
01128 
01143 int  get_runlength_byte(unsigned char* buf, int len, int pos)
01144 {
01145     int i, sz;
01146 
01147     sz = -1;
01148     for (i=0; i<len; i++) {
01149         if (buf[i]==0x00) {
01150             if (i+1>=len) return JBXL_XTOOLS_RUNLEN_ERROR;
01151             if (buf[i+1]==0x00) return JBXL_XTOOLS_RUNLEN2_ERROR;
01152             sz += buf[i+1];
01153             if (sz>=pos) return i;
01154             i++;
01155         }
01156         else sz++;
01157 
01158         if (sz>=pos) return i;
01159     }
01160 
01161     return JBXL_ERROR;
01162 }
01163 
01164 
01165 
01177 Buffer  decode_runlength(unsigned char* buf, int len, int sz)
01178 {
01179     int    i, j, k;
01180     Buffer ret = init_Buffer();
01181 
01182     // 長さを数える
01183     i = j = 0;
01184     if (sz<=0) {
01185         while (j<len) {
01186             if (buf[j]==0x00) {
01187                 if (j+1<len) {
01188                     if (buf[j+1]==0x00) return ret;
01189                     i += (int)buf[j+1];
01190                     j += 2;
01191                 }
01192                 else break;
01193             }
01194             else {
01195                 i++;
01196                 j++;
01197             }
01198         }
01199 
01200         if (j==len) sz = i;
01201         else return ret;
01202     }
01203         
01204     ret = make_Buffer(sz);
01205     if (ret.buf==NULL) return ret;
01206 
01207     i = j = 0;
01208     while (i<sz && j<len) {
01209         if (buf[j]==0x00) {
01210             if (j+1<len) {
01211                 for (k=0; k<(int)buf[j+1]; k++) ret.buf[i++] = 0x00;
01212                 j += 2;
01213             }
01214             else break;
01215         }    
01216         else ret.buf[i++] = buf[j++];
01217     }
01218 
01219     if (i==sz) ret.vldsz = sz;
01220     else free_Buffer(&ret);
01221 
01222     return ret;
01223 }
01224 
01225 
01226 Buffer  encode_runlength(unsigned char* buf, int len)
01227 {
01228     int    i, j, k;
01229     Buffer ret = init_Buffer();
01230 
01231     ret = make_Buffer(2*len);
01232     if (ret.buf==NULL) return ret;
01233 
01234     i = j = 0;
01235     while (j<len) {
01236         ret.buf[i] = buf[j];
01237 
01238         if (buf[j]==0x00) {
01239             k = 0;
01240             while (buf[j]==0x00 && j<len) {
01241                 k++;
01242                 j++;
01243             }
01244             ret.buf[i+1] = (unsigned char)k;
01245             i += 2;
01246         }
01247         else {
01248             i++;
01249             j++;
01250         }
01251     }
01252 
01253     ret.vldsz = i;
01254     return ret;
01255 }
01256 
01257 
01258 
01260 // Ring Buffer
01261 // 
01262 
01277 int  put_Buffer_ringBuffer(ringBuffer* rb, Buffer* buf)
01278 {
01279     if (rb==NULL) return JBXL_ARGS_ERROR;
01280     rb->state = JBXL_NORMAL;
01281 
01282     if (buf==NULL)     return JBXL_ARGS_ERROR;
01283     if (rb->buf==NULL) return JBXL_TOOLS_BUF_ERROR;
01284     if (rb->datasz + buf->vldsz > rb->bufsz) {
01285         rb->state = JBXL_ERROR;
01286         return JBXL_TOOLS_BUFSZ_ERROR;
01287     }
01288 
01289     if (rb->epoint + buf->vldsz <= rb->bufsz) {
01290         memcpy(&(rb->buf[rb->epoint]), buf->buf, buf->vldsz);
01291         rb->epoint = rb->epoint + buf->vldsz;
01292         if (rb->epoint==rb->bufsz) rb->epoint = 0;
01293     }
01294     else {
01295         memcpy(&(rb->buf[rb->epoint]), buf->buf, rb->bufsz - rb->epoint);
01296         memcpy(rb->buf, &(buf->buf[rb->bufsz - rb->epoint]), buf->vldsz - (rb->bufsz - rb->epoint));
01297         rb->epoint = rb->epoint + buf->vldsz - rb->bufsz;
01298     }
01299 
01300     rb->datasz += buf->vldsz;
01301     return buf->vldsz;
01302 }
01303 
01304 
01305 
01319 Buffer*  get_Buffer_ringBuffer(ringBuffer* rb, int sz)
01320 {
01321     if (rb==NULL) return NULL;
01322     if (rb->buf==NULL) return NULL;
01323     if (sz>rb->datasz) return NULL;
01324 
01325     Buffer* buf = new_Buffer(sz);
01326 
01327     if (rb->spoint + sz <= rb->bufsz) {
01328         copy_b2Buffer(&(rb->buf[rb->spoint]), buf, sz);
01329         rb->spoint = rb->spoint + sz;
01330         if (rb->spoint==rb->bufsz) rb->spoint = 0;
01331     }
01332     else {
01333         copy_b2Buffer(&(rb->buf[rb->spoint]), buf, rb->bufsz - rb->spoint);
01334         cat_b2Buffer(rb->buf, buf, sz - (rb->bufsz - rb->spoint));
01335         rb->spoint = rb->spoint + sz - rb->bufsz;
01336     }
01337 
01338     rb->datasz -= sz;
01339     return buf;
01340 }
01341 
01342 
01343 
01344 
01346 //  Buffer 配列
01347 // 
01348 
01360 Buffer*  get_Buffer_dim_tList(tList* lp)
01361 {
01362     int     nn, mx;
01363     tList*  lt;
01364     Buffer* buf;
01365     Buffer* ret;
01366 
01367     if (lp==NULL) return NULL;
01368 
01369     // リスト中のノードの数を数える．
01370     lt = lp;
01371     nn = 0;
01372     while(lt!=NULL && lt->ldat.key.buf!=NULL) {
01373         nn++;
01374         lt = lt->next;
01375     }
01376     if (nn==0) return NULL;
01377 
01378     mx = nn;
01379     buf = ret = (Buffer*)malloc(sizeof(Buffer)*mx);
01380     if (ret==NULL) return NULL;
01381     
01382     nn = 0;
01383     while(lp!=NULL && lp->ldat.key.buf!=NULL) {
01384         *buf = dup_Buffer(lp->ldat.key);
01385         buf->state = mx - nn;
01386         nn++;
01387         buf++;
01388         lp = lp->next;
01389     }
01390         
01391     return ret;
01392 }
01393 
01394 
01395 
01407 Buffer*  get_Buffer_dim_tList_value(tList* lp)
01408 {
01409     int     nn, mx;
01410     tList*  lt;
01411     Buffer* buf;
01412     Buffer* ret;
01413 
01414     if (lp==NULL) return NULL;
01415 
01416     lt = lp;
01417     nn = 0;
01418     while(lt!=NULL && lt->ldat.val.buf!=NULL) {
01419         nn++;
01420         lt = lt->next;
01421     }
01422     if (nn==0) return NULL;
01423 
01424     mx = nn;
01425     buf = ret = (Buffer*)malloc(sizeof(Buffer)*mx);
01426     if (ret==NULL) return NULL;
01427     
01428     nn = 0;
01429     while(lp!=NULL && lp->ldat.val.buf!=NULL) {
01430         *buf = dup_Buffer(lp->ldat.val);
01431         buf->state = mx - nn;
01432         nn++;
01433         buf++;
01434         lp = lp->next;
01435     }
01436         
01437     return ret;
01438 }
01439 
01440 
01441 
01456 Buffer*  awk_Buffer_dim(Buffer buf, char cc)
01457 {
01458     Buffer* bf = NULL;
01459 
01460     tList*  lp = awk_Buffer_tList(buf, cc);
01461     if (lp!=NULL) bf = get_Buffer_dim_tList(lp);
01462     del_all_tList(&lp);
01463     
01464     return  bf;
01465 }
01466 
01467 
01468 
01484 Buffer*  cawk_Buffer_dim(Buffer buf, char cc)
01485 {
01486     Buffer* bf = NULL;
01487 
01488     tList*  lp = cawk_Buffer_tList(buf, cc);
01489     if (lp!=NULL) bf = get_Buffer_dim_tList(lp);
01490     del_all_tList(&lp);
01491     
01492     return  bf;
01493 }
01494 
01495 
01496 
01511 Buffer*  decompline_Buffer_dim(Buffer buf, int mode)
01512 {
01513     Buffer* dim;
01514     int i, n, m;
01515 
01516     if (buf.buf==NULL) return NULL;
01517 
01518     n = i = 0;
01519     while(buf.buf[i]!='\0' && i<buf.vldsz) {
01520         if (buf.buf[i]==CHAR_CR) {
01521             n++;
01522             if (i+1<buf.vldsz && buf.buf[i+1]==CHAR_LF) i++;
01523         }
01524         else if (buf.buf[i]==CHAR_LF) n++;
01525         else if (i+1<buf.vldsz  && buf.buf[i+1]=='\0') n++;
01526         else if (i+1==buf.vldsz || buf.buf[i+1]=='\0') n++;
01527         i++;
01528     }
01529     if (n==0) n = 1;            // buf.buf[0]=='\0' の場合
01530 
01531     dim = (Buffer*)malloc(sizeof(Buffer)*n);
01532     if (dim==NULL) return NULL;
01533 
01534     int nxt = 0;
01535     for (m=0; m<n-1; m++) {
01536         int cnt = 0;
01537         int fwd = 0;
01538         while (buf.buf[nxt+cnt]!=CHAR_CR && buf.buf[nxt+cnt]!=CHAR_LF && nxt+cnt<buf.vldsz)  cnt++;
01539 
01540         if (buf.buf[nxt+cnt]==CHAR_CR || buf.buf[nxt+cnt]==CHAR_LF) fwd++;
01541         if (buf.buf[nxt+cnt]==CHAR_CR && nxt+cnt+1<buf.vldsz && buf.buf[nxt+cnt+1]==CHAR_LF) fwd++;
01542         if (mode==ON) cnt += fwd;
01543 
01544         dim[m] = make_Buffer(cnt);
01545         for (i=0; i<cnt; i++) {
01546             dim[m].buf[i] = buf.buf[nxt+i];
01547         }
01548         dim[m].vldsz = cnt;
01549         dim[m].state = n;
01550 
01551         if (mode==ON) nxt += cnt;
01552         else          nxt += cnt + fwd;
01553     }
01554 
01555     // m == n-1  一番最後の領域
01556     dim[n-1] = make_Buffer(buf.vldsz-nxt);
01557     for (i=0; i<buf.vldsz-nxt; i++) {
01558         dim[n-1].buf[i] = buf.buf[nxt+i];
01559     }
01560     dim[n-1].vldsz = buf.vldsz - nxt;
01561     dim[n-1].state = n;
01562 
01563     return dim;
01564 }
01565 
01566 
01567 
01573 Buffer  join_Buffer_dim(Buffer* dim, const char* deli)
01574 {
01575     int    i, nn;
01576     Buffer buf;
01577 
01578     buf = init_Buffer();
01579     if (dim==NULL) return buf;
01580 
01581     buf = make_Buffer(LBUF);
01582     nn  = dim->state;
01583 
01584     for (i=0; i<nn; i++) {
01585         cat_Buffer(dim, &buf);
01586         if (deli!=NULL && i!=nn-1) cat_s2Buffer(deli, &buf);
01587         dim++;
01588     }
01589 
01590     return buf;
01591 }
01592 
01593 
01594 
01600 void  del_Buffer_dim(Buffer** dim)
01601 {
01602     int  i, nn;
01603     Buffer* buf;
01604 
01605     if (dim==NULL || *dim==NULL) return;
01606     buf = *dim;
01607     
01608     nn = buf->state;
01609     if (nn<=0) free_Buffer(buf);
01610 
01611     for (i=0; i<nn; i++) {
01612         free_Buffer(buf);
01613         buf++;
01614     }
01615 
01616     free(*dim);
01617     *dim = NULL;
01618     return;
01619 }
01620 
01621 
01622 
01623 
01625 //  リスト Buffer 
01626 // 
01627 
01637 tList*  get_tList_line_Buffer(Buffer buf, int n)
01638 {
01639     if (buf.buf==NULL || n<=0) return NULL;
01640 
01641     Buffer line = get_line_Buffer(buf, n);
01642     if (line.buf==NULL) return NULL;
01643 
01644     char*  packline = pack_char((char*)line.buf, ' ');
01645     free_Buffer(&line);
01646     if (packline==NULL) return NULL;
01647 
01648     tList* list = awk_tList(packline, ' ');
01649     free(packline);
01650 
01651     return list;
01652 }
01653 
01654 
01655 
01663 tList*  get_tList_seq_data_Buffer(Buffer buf, int* ptr)
01664 {
01665     if (buf.buf==NULL || *ptr<0) return NULL;
01666     if (*ptr>=buf.vldsz) return NULL;
01667 
01668     Buffer line = get_seq_data_Buffer(buf, ptr);
01669     if (line.buf==NULL) return NULL;
01670 
01671     char*  packline = pack_char((char*)line.buf, ' ');
01672     free_Buffer(&line);
01673     if (packline==NULL) return NULL;
01674 
01675     tList* list = awk_tList(packline, ' ');
01676     free(packline);
01677 
01678     return list;
01679 }
01680 
01681 
01682 
01683 
01685 // Extend tList
01686 //
01687 
01704 int  set_item_tList(tList* list, char* key, int no, char deli, int nm, char* value)
01705 {
01706     int    cn = 0;
01707     tList* lp;
01708 
01709     if (list==NULL || key==NULL || value==NULL) return JBXL_ARGS_ERROR;
01710 
01711     if (no>0) {
01712         lp = strncasecmp_tList(list, key, 0, no);
01713         if (lp!=NULL) {
01714             int rep = set_item_tList_node(lp, deli, nm, value);
01715             if (rep) cn = 1;
01716         }
01717     }   
01718     else {      // no<=0
01719         int nn = 1;
01720         cn = 0;
01721         lp = strncasecmp_tList(list, key, 0, nn);
01722         while (lp!=NULL) {
01723             int rep = set_item_tList_node(lp, deli, nm, value);
01724             if (rep) cn++;
01725             lp = strncasecmp_tList(list, key, 0, ++nn);
01726         }
01727     }
01728 
01729     return cn;
01730 }
01731 
01732 
01733 int  set_item_tList_node(tList* lp, char deli, int nm, char* value)
01734 {
01735     int  rep = FALSE;
01736     char dl[2] = " ";
01737     Buffer* bp;
01738 
01739     if (lp==NULL || value==NULL) return FALSE;
01740 
01741     dl[0] = deli;
01742 
01743     bp = cawk_Buffer_dim(lp->ldat.val, deli);
01744     if (bp!=NULL && bp->state>=nm) {
01745         Buffer buf = make_Buffer_bystr(value);
01746         free_Buffer(&bp[nm-1]);
01747         bp[nm-1] = buf;
01748 
01749         free_Buffer(&lp->ldat.val);
01750         lp->ldat.val = join_Buffer_dim(bp, dl);
01751         rep = TRUE;
01752     }
01753     del_Buffer_dim(&bp);
01754 
01755     return rep;
01756 }
01757 
01758 
01759 
01777 int  replace_item_tList(tList* list, char* key, int no, char deli, int nm, char* srcval, char* value)
01778 {
01779     int    cn = 0;
01780     tList* lp;
01781 
01782     if (list==NULL || key==NULL || value==NULL) return JBXL_ARGS_ERROR;
01783     if (srcval==NULL) {
01784         return     set_item_tList(list, key, no, deli, nm, value);
01785     }
01786 
01787     if (no>0) {
01788         lp = strncasecmp_tList(list, key, 0, no);
01789         if (lp!=NULL) {
01790             int rep = replace_item_tList_node(lp, deli, nm, srcval, value);
01791             if (rep) cn = 1;
01792         }
01793     }   
01794     else {      // no<=0
01795         int nn = 1;
01796         cn = 0;
01797         lp = strncasecmp_tList(list, key, 0, nn);
01798         while (lp!=NULL) {
01799             int rep = replace_item_tList_node(lp, deli, nm, srcval, value);
01800             if (rep) cn++;
01801             lp = strncasecmp_tList(list, key, 0, ++nn);
01802         }
01803     }
01804 
01805     return cn;
01806 }
01807 
01808 
01809 int  replace_item_tList_node(tList* lp, char deli, int nm, char* srcval, char* value)
01810 {
01811     int  rep = FALSE;
01812     char dl[2] = " ";
01813     Buffer* bp;
01814     Buffer  buf;
01815 
01816     if (lp==NULL || value==NULL) return FALSE;
01817     if (nm<=0) nm = 1;
01818     if (srcval==NULL) {
01819         return set_item_tList_node(lp, deli, nm, value);
01820     }
01821 
01822     dl[0] = deli;
01823 
01824     bp = cawk_Buffer_dim(lp->ldat.val, deli);
01825     if (bp!=NULL && bp->state>=nm) {
01826            buf = replace_sBuffer(bp[nm-1], srcval, value);
01827         free_Buffer(&bp[nm-1]);
01828         bp[nm-1] = buf;
01829         free_Buffer(&lp->ldat.val);
01830         lp->ldat.val = join_Buffer_dim(bp, dl);
01831         rep = TRUE;
01832     }
01833     del_Buffer_dim(&bp);
01834 
01835     return rep;
01836 }
01837 
01838 
01839 
01840 
01842 // File/Directory Tools
01843 //
01844 
01856 tList*  get_dir_files(const char* dirn)
01857 {
01858     tList* lp = NULL;
01859     tList* ln = NULL;
01860 
01861 #ifdef WIN32
01862 //    WIN32_FIND_DATA  FindFileData;
01863     WIN32_FIND_DATAA FindFileData;
01864     HANDLE hFind;
01865 
01866     Buffer pth = make_Buffer_bystr(dirn);
01867     if (pth.buf[strlen((char*)pth.buf)-1]!='\\') cat_s2Buffer("\\", &pth);
01868     Buffer buf = dup_Buffer(pth);
01869     cat_s2Buffer("*", &buf);
01870 
01871 //    hFind = FindFirstFile((LPCTSTR)(buf.buf), &FindFileData);
01872     hFind = FindFirstFileA((LPCSTR)(buf.buf), &FindFileData);
01873     if (hFind!=INVALID_HANDLE_VALUE) {
01874         Buffer tmp;    
01875         do {
01876             if (strcmp(".", FindFileData.cFileName) && strcmp("..", FindFileData.cFileName)) { 
01877                 tmp = dup_Buffer(pth);
01878                 cat_s2Buffer(FindFileData.cFileName, &tmp);
01879                 ln = add_tList_node_str(ln, NULL, tmp.buf);
01880                 if (lp==NULL) lp = ln;
01881                 free_Buffer(&tmp);
01882             }
01883         } while (FindNextFileA(hFind, &FindFileData));
01884 
01885         FindClose(hFind);
01886     }
01887     free_Buffer(&buf);
01888     free_Buffer(&pth);
01889 
01890 #else
01891 
01892     DIR *dp;
01893     struct dirent *dir;
01894     
01895     Buffer pth = make_Buffer_bystr(dirn);
01896     if (pth.buf[strlen((char*)pth.buf)-1]!='/') cat_s2Buffer("/", &pth);
01897 
01898     dp = opendir(dirn);
01899     if (dp!=NULL ){
01900         Buffer tmp;
01901         dir = readdir(dp);
01902         while (dir != NULL ){
01903             if (strcmp(".", dir->d_name) && strcmp("..", dir->d_name)) { 
01904                 tmp = dup_Buffer(pth);
01905                 cat_s2Buffer(dir->d_name, &tmp);
01906                 ln = add_tList_node_str(ln, NULL, (char*)tmp.buf);
01907                 if (lp==NULL) lp = ln;
01908                 free_Buffer(&tmp);
01909             }
01910             dir = readdir(dp);
01911         }
01912 
01913         closedir(dp);
01914     }
01915     free_Buffer(&pth);
01916 
01917 #endif
01918 
01919     // sort
01920     ln = lp;
01921     while (ln!=NULL) {
01922         tList* lo = ln->next;
01923         while (lo!=NULL) {
01924             if (strcmp((char*)ln->ldat.val.buf, (char*)lo->ldat.val.buf)>0) {
01925                 swap_tList_node(ln, lo);
01926             }
01927             lo = lo->next;
01928         }
01929         ln = ln->next;
01930     }
01931 
01932     return lp;
01933 }
01934 
01935 
01936 tList*  get_dir_files_rcsv(const char* dirn)
01937 {
01938     tList* lp = get_dir_files(dirn);
01939     if (lp==NULL) return NULL;
01940 
01941     tList* lt = dup_tList(lp);
01942     while (lt!=NULL) {
01943         tList* lc = get_dir_files_rcsv((char*)lt->ldat.val.buf);
01944         if (lc!=NULL) add_tList_end(lp, lc);
01945         lt = lt->next;
01946     }
01947     del_tList(&lt);
01948 
01949     return lp;
01950 }
01951 
01952 
01953 void  del_file_extension_Buffer(Buffer* path)
01954 {
01955     if (path==NULL) return;
01956 
01957     int count = path->vldsz - 1;
01958     while (count>=0) {
01959         if (path->buf[count]=='.') {
01960             path->buf[count] = '\0';
01961             path->vldsz = (int)strlen((char*)path->buf);
01962             break;
01963         }
01964         count--;
01965     }
01966 }
01967 
01968 
01969 
01973 void  change_file_extension_Buffer(Buffer* path, const char* ext)
01974 {
01975     if (path==NULL) return;
01976 
01977     int count = path->vldsz - 1;
01978     while (count>=0) {
01979         if (path->buf[count]=='.') {
01980             path->buf[count] = '\0';
01981             path->vldsz = (int)strlen((char*)path->buf);
01982             if (ext[0]!='.') cat_s2Buffer(".", path);
01983             cat_s2Buffer(ext, path);
01984             break;
01985         }
01986         else if (path->buf[count]=='/' || path->buf[count]=='\\') {
01987             count = -1;
01988             break;
01989         }
01990         count--;
01991     }
01992     //
01993     if (count<0) {
01994         if (ext[0]!='.') cat_s2Buffer(".", path);
01995         cat_s2Buffer(ext, path);
01996     }
01997 }
01998 
01999 
02000 
02001 
02003 //
02004 
02012 char*  get_resource_path(char* name, tList* lp)
02013 {
02014     if (name==NULL) return NULL;
02015 
02016     while (lp!=NULL) {
02017         if (!strcasecmp((char*)lp->ldat.key.buf, name)) {
02018             return (char*)lp->ldat.val.buf;
02019         }
02020         lp = lp->next;
02021     }
02022 
02023     return NULL;
02024 }
02025 
02026 
02027 
02038 tList*  add_resource_list(const char* path, int keylen, tList* list, tList* extn)
02039 {
02040     if (path==NULL) return list;
02041 
02042     tList* lp = get_dir_files(path);
02043     tList* pp = find_tList_end(list);
02044 
02045     // Generate Key. ファイル名の先頭 keylen文字をキーにする．
02046     while (lp!=NULL) {
02047         Buffer fn = make_Buffer_bystr(get_file_name((char*)lp->ldat.val.buf));
02048         char* ext = get_file_extension((char*)fn.buf);
02049         //
02050         if (extn==NULL || strncasecmp_tList(extn, ext, 0, 1)==NULL) {
02051             if (keylen<=0) {
02052                 lp->ldat.key = make_Buffer_bystr((char*)fn.buf);
02053                 pp = add_tList_node_bydata(pp, lp->ldat);
02054             }
02055             else if (fn.vldsz>=keylen) {
02056                 fn.buf[keylen] = '\0';
02057                 fn.vldsz = keylen;
02058                 lp->ldat.key = make_Buffer_bystr((char*)fn.buf);
02059                 pp = add_tList_node_bydata(pp, lp->ldat);
02060             }
02061         }
02062 
02063         if (list==NULL) list = pp;
02064         lp = lp->next;
02065         free_Buffer(&fn);
02066     }
02067 
02068     return list;
02069 }
02070 
02071 
02072