00001
00017 #include "xtools.h"
00018
00019
00020
00022
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
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
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199
00201
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
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
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
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
00849 item1 = awk_Buffer(url, '/', 1);
00850 item2 = awk_Buffer(url, '/', 3);
00851 if (protocol!=NULL) {
00852 *protocol = dup_Buffer(item1);
00853 protocol->buf[protocol->vldsz-1] = '\0';
00854 protocol->vldsz--;
00855 }
00856 }
00857 else {
00858
00859 item2 = awk_Buffer(url, '/', 1);
00860 }
00861
00862 if (item2.buf!=NULL) {
00863 item3 = awk_Buffer(item2, ':', 1);
00864 if (item3.buf==NULL) {
00865 free_Buffer(&item1);
00866 free_Buffer(&item2);
00867 return FALSE;
00868 }
00869 item4 = awk_Buffer(item2, ':', 2);
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
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
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
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
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
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
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;
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
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
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
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 {
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 {
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
01843
01844
01856 tList* get_dir_files(const char* dirn)
01857 {
01858 tList* lp = NULL;
01859 tList* ln = NULL;
01860
01861 #ifdef WIN32
01862
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
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
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(<);
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
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
