开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
util.c
资源名称：saac.tar.gz　[点击查看]
上传用户：qys8201
上传日期：2021-12-11
资源大小：978k
文件大小：14k
源码类别：

模拟服务器

开发平台：

C/C++

util.c：源码内容
  1. #define _UTIL_C_
  3. #include <sys/types.h>
  4. #include <sys/socket.h>
  5. #include <sys/time.h>
  6. #include <sys/stat.h>
  8. #include <netinet/in.h>
  9. #include <arpa/inet.h>
  11. #include <stdio.h>
  12. #include <string.h>
  13. #include <stdlib.h>
  14. #include <unistd.h>
  15. #include <dirent.h>
  16. #include <netdb.h>
  17. #include <errno.h>
  18. #include <ctype.h>
  20. #include "main.h"
  21. #include "util.h"
  23. #define min( x,y ) ({typeof(x) __x=(x),__y=(y);(__x < __y) ? __x : __y; })
  24. #define max( x,y ) ({typeof(x) __x=(x),__y=(y);(__x < __y) ? __y : __x; })
  25. #define IS_2BYTEWORD( _a_ ) ( (char)(0x80) <= (_a_) && (_a_) <= (char)(0xFF) )
  26. #define PRIME 211
  27. int hashpjw ( char* s )
  28. {
  29.     char *p;
  30.     unsigned int h= 0 ,g;
  31.     for( p = s ; *p ; p ++ ){
  32.         h = ( h<< 4 ) + (*p);
  33.         if( (g = h & 0xf0000000) != 0){
  34.             h = h ^ (g>>24);
  35.             h = h ^ g;
  36.         }
  37.     }
  38.     return h % PRIME;
  39. }
  41. int getHash ( char* s )
  42. {
  43.     int i;
  44.     int h=0;
  46.     for(i=0;; i++){
  47.         if( s[i] == 0 ){
  48.             break;
  49.         }
  50.         h += s[i];
  51.     }
  52.     return h;
  53. }
  55. void easyGetTokenFromString( char *src,int count,char*output,int len )
  56. {
  57.     int i;
  58.     int counter = 0;
  60.     if( len <= 0 )return;
  62. #define ISSPACETAB( c )   ( (c) == ' ' || (c) == 't' )
  64.     for(i=0;;i++){
  65.         if( src[i]==''){
  66.             output[0] = '';
  67.             return;
  68.         }
  69.         if( i > 0 && ! ISSPACETAB( src[i-1] ) &&
  70.             ! ISSPACETAB(  src[i] ) ){
  71.             continue;
  72.         }
  74.         if( ! ISSPACETAB( src[i]) ){
  75.             counter++;
  76.             if( counter == count){
  77.                 int j;
  78.                 for(j=0;j<len-1;j++){
  79.                     if( src[i+j] == '' ||
  80.                         ISSPACETAB( src[i+j] ) ){
  81.                         break;
  82.                     }
  83.                     output[j]=src[i+j];
  84.                 }
  85.                 output[j]='';
  86.                 return;
  88.             }
  89.         }
  91.     }
  92. }
  94. void prepareDirectories(char *base)
  95. {
  96.     int i;
  97.     char dname[1024];
  99.     for(i=0;i<256;i++){
  100.         int ret;
  101.         snprintf( dname , sizeof( dname ) , "%s/0x%x", base , i );
  102.         ret = mkdir( dname , 0755 );
  103.         if( ret <0 && errno != EEXIST ){
  104.             log( "mkdir error:%d %s: %sn", ret ,strerror(errno), dname );
  105.         }
  106.         if( ret == 0 ) log(".");
  107.     }
  108. }
  110. void remove_r( char *s )
  111. {
  112.     int i;
  113.     for(i=0;;i++){
  114.         if(s[i]=='r')s[i] =0;
  115.         if( s[i]==0)break;
  116.     }
  117. }
  119. void makeDirFilename( char *out , int outlen ,
  120.                   char *base , int dirchar , char *child )
  121. {
  122.     snprintf( out , outlen ,
  123.               "%s/0x%x/%s" , base ,
  124.               dirchar & 0xff , child );
  125. }
  127. int isFile( char *fn )
  128. {
  129.     FILE*fp=fopen(fn,"r");
  130.     if( fp){
  131.         fclose(fp);
  132.         return 1;
  133.     }
  134.     return 0;
  135. }
  137. int createFile( char *fn , char *line )
  138. {
  139.     FILE *fp = fopen( fn , "w" );
  140.     if( fp== NULL ){
  141.         return -1;
  142.     } else {
  143.         fprintf( fp , "%s" , line );
  144.         fclose(fp);
  145.         return 0;
  146.     }
  147. }
  149. #define BOOL int
  150. #define FALSE 0
  151. #define TRUE  1
  153. typedef struct tagEscapeChar
  154. {
  155.     char     escapechar;
  156.     char     escapedchar;
  157. }EscapeChar;
  158. static EscapeChar   escapeChar[]=
  159. {
  160.     { 'n',   'n' },
  161.     { ',',    'c' },
  162.     { '|',    'z' },
  163.     { '\',   'y' },
  164. };
  166. char*   makeStringFromEscaped( char* src )
  167. {
  168.     int     i;
  169.     int     srclen = strlen( src );
  170.     int     searchindex=0;
  172.     for( i = 0 ; i < srclen ; i ++ ){
  173.      // for 2Byte Word
  174.      if( IS_2BYTEWORD( src[i] ) ){
  175.             src[searchindex++] = src[i++];
  176.             src[searchindex++] = src[i];
  177.      }else{
  178.         if( src[i] == '\' ){
  179.             int j;
  181.             /*  戚及  侬卞垫仁  */
  182.             i++;
  183.             for( j = 0; j<sizeof(escapeChar)/sizeof(escapeChar[0]); j++){
  184.                 if( escapeChar[j].escapedchar == src[i] ){
  185.                     /*  戚互巨旦弗□皿平乓仿分  */
  186.                     src[searchindex++] = escapeChar[j].escapechar;
  187.                     break;
  188.                 }
  189.             }
  190.             /*  巨仿□支仃升公及引引戊疋□仄化云仁  */
  191.             if(escapeChar[j].escapedchar != src[i])
  192.              src[searchindex++] = src[i];
  193.         }else{
  194.             src[searchindex++] = src[i];
  195.         }
  196.       }
  197.     }
  198.     src[searchindex] = '';
  199.     return src;
  200. }
  202. char *   makeEscapeString( char* src , char* dest, int sizeofdest)
  203. {
  204.     int         i;
  205.     int     srclen = strlen( src );
  206.     int     destindex=0;
  208.     for( i = 0 ; i < srclen ; i ++ ){
  209.         BOOL dirty=FALSE;
  210.         int     j;
  211.         char    escapechar='';
  212.         if( destindex + 1 >= sizeofdest ) break;
  213. if( IS_2BYTEWORD( src[i] ) ){
  214.         if( destindex + 2 >= sizeofdest ) break;
  215.             dest[destindex] = src[i];
  216.             dest[destindex+1] = src[i+1];
  217.             destindex += 2;
  218.             i ++;
  219.             continue;
  220. }
  222.         for( j = 0; j<sizeof(escapeChar)/sizeof(escapeChar[0]); j++){
  223.             if( src[i] == escapeChar[j].escapechar ){
  224.                 dirty=TRUE;
  225.                 escapechar= escapeChar[j].escapedchar;
  226.                 break;
  227.             }
  228. }
  229. if( dirty == TRUE ){
  230. if( destindex + 2 < sizeofdest ){
  231. dest[destindex] = '\';
  232. dest[destindex+1] = escapechar;
  233. destindex+=2;
  234. dirty=TRUE;
  235. continue;       /*  戚及  侬卞褡戈  */
  236. }else{
  237. dest[destindex] = '';
  238. return dest;
  239. }
  240. }else{
  241. dest[destindex] = src[i];
  242. destindex++;
  243. }
  244. }
  246.     dest[destindex] = '';
  247.     return dest;
  248. }
  250. char *   makeEscapeString1( char* src , char* dest, int sizeofdest)
  251. {
  252.     int         i;
  253.     int     srclen = strlen( src );
  254.     int     destindex=0;
  256.     for( i = 0 ; i < srclen ; i ++ ){
  257.         BOOL dirty=FALSE;
  258.         int     j;
  259.         char    escapechar='';
  260.         if( destindex + 1 >= sizeofdest )
  261.             /*  ''坌互箫曰卅中及匹仇仇匹蔽曰   */
  262.             break;
  264. /* // 蝈剩及ㄠ田奶玄  井升丹井毛民尼永弁
  265. if( IS_2BYTEWORD( src[i] ) ){
  266. // 蝈剩分［公及桦宁反ㄠ田奶玄芴坌卞褡引六月［
  267. // 凶分仄ㄠ田奶玄仄井卅中桦宁反公丹仄卅中
  268. // 公及引引ㄡ田奶玄鳖霜
  269.         if( destindex + 2 >= sizeofdest )break;
  271.             dest[destindex] = src[i];
  272.             dest[destindex+1] = src[i+1];
  273.             destindex += 2;
  274.             i ++;
  275.             continue;
  276. }
  277. */
  278.         for( j = 0; j<sizeof(escapeChar)/sizeof(escapeChar[0]); j++)
  279.             if( src[i] == escapeChar[j].escapechar ){
  280.                 dirty=TRUE;
  281.                 escapechar= escapeChar[j].escapedchar;
  282.                 break;
  283.             }
  285.         if( dirty == TRUE ){
  286.             /*  巨旦弗□皿允月  侬分    */
  287.             if( destindex + 2 < sizeofdest ){
  288.                 /*  +2 午中丹及反｝ '\' 午 'n'及仪分   */
  289.                 /*  酸曰  侬反蜗坌分    */
  290.                 dest[destindex] = '\';
  291.                 dest[destindex+1] = escapechar;
  292.                 destindex+=2;
  293.                 dirty=TRUE;
  294.                 continue;       /*  戚及  侬卞褡戈  */
  295.             }else{
  296.                 /*  酸曰田永白央互尕箫仄化中月  */
  297.                 dest[destindex] = '';
  298.                 return dest;
  299.             }
  300.         }else{
  301.             dest[destindex] = src[i];
  302.             destindex++;
  303.         }
  305.     }
  306.     dest[destindex] = '';
  307.     return dest;
  308. }
  309. #undef BOOL
  310. #undef FALSE
  311. #undef TRUE
  315. /* 赞中strcatsafe［田永白央互丐孔木月桦宁反窒手仄卅中［ */
  316. int
  317. strcatsafe( char *dest, int destlen , char *append )
  318. {
  319.     int dl = strlen( dest);
  320.     int al = strlen(append);
  322.     if( (dl + al) >= destlen ){
  323.         return -1;
  324.     } else {
  325.         strcat( dest, append );
  326.     }
  327. return 0;
  328. }
  330. char *chop( char *s )
  331. {
  332.     int l = strlen(s);
  333.     if( l >= 1 ){
  334.         s[l-1]=0;
  335.     }
  336.     return s;
  337. }
  339. // CoolFish: Family 2001/5/30
  341. /*void easyGetTokenFromBuf(char *src, char delim, int count, char *output, int len)
  342. {
  343.     int  i;
  344.     int  counter = 0;
  345.     int  wordflag = 0;
  346.     
  347.     if( len <= 0 ) return;
  348.     
  349.     #define ISSEPARATE( c )   ((c) == delim)
  350.     
  351.     for( i=0; ; i++){
  352.      if( src[i] == '' ){
  353.      output[0] = '';
  354.      return;
  355.      }
  356.      if(IS_2BYTEWORD(src[i])){
  357.      if( i>0 && wordflag == 1 ){
  358.      i++;
  359.      wordflag = 1;
  360.      continue;
  361.      }
  362.      if( i>0 && !ISSEPARATE(src[i-1]) && !ISSEPARATE(src[i])){
  363.      i++;
  364.      wordflag = 1;
  365.      continue;
  366.      }
  367.      wordflag = 1;
  368.      }else{
  369.      if( i>0 && wordflag ){
  370.      wordflag = 0;
  371.      continue;
  372.      }
  373.      if( i>0 && !ISSEPARATE(src[i-1]) && !ISSEPARATE(src[i])){
  374.      wordflag = 0; 
  375.      continue;
  376.      }
  377.      wordflag = 0;
  378.      }
  379.         if( !ISSEPARATE(src[i]) ){
  380.          counter++;
  381.          if( counter == count ){
  382.          int j;
  383.          for ( j=0; j<len-1; j++){
  384.          if( IS_2BYTEWORD( src[i+j] ) ){
  385.          output[j] = src[i+(j++)];
  386.          output[j] = src[i+j];
  387.          }else{
  388.          if( src[i+j]=='' || ISSEPARATE(src[i+j])){
  389.          break;
  390.          }
  391.          output[j] = src[i+j];
  392.          }
  393.         }
  394.         output[j] = '';
  395.         return;
  396. }
  397. if( wordflag )
  398. i++;
  399. if ( i==0)
  400. {
  401. if( IS_2BYTEWORD(src[i]) ){
  402. wordflag = 1;
  403. i++;
  404. }
  405. else
  406. {
  407. wordflag = 0;
  408. }
  409. }
  410. }
  411.     }
  412. }
  413. */
  415. char* strncpy2( char* dest, const char* src, size_t n )
  416. {
  417.     if( n > 0 ){
  418.         char*   d = dest;
  419.         const char*   s = src;
  420.         int i;
  421.         for( i=0; i<n ; i++ ){
  422.             if( *(s+i) == 0 ){
  423.                 /*  戊疋□仄云歹匀凶日 NULL   侬毛  木月   */
  424.                 *(d+i) = '';
  425.                 return dest;
  426.             }
  427.             if( *(s+i) & 0x80 ){
  428.                 *(d+i)  = *(s+i);
  429.                 i++;
  430.                 if( i>=n ){
  431.                     *(d+i-1)='';
  432.                     break;
  433.                 }
  434.                 *(d+i)  = *(s+i);
  435.             }else
  436.                 *(d+i) = *(s+i);
  437.         }
  438.     }
  439.     return dest;
  440. }
  442. void strncpysafe( char* dest , const size_t n ,
  443.                   const char* src ,const int length )
  444. {
  445.     /*
  446.      * src 井日 dest 卞 length 戊疋□允月
  447.      * strcpy, strncpy 匹反 dest 方曰 戊疋□允月汹互
  448.      *   五中凛卞裟少午,丢乒伉陆失弁本旦互粟月.
  449.      * 仇及楮醒匹反｝strlen( src ) 午 length 及凝今中幻丹
  450.      * (  端卞戊疋□允月汹) 午 dest 及扔奶术毛  屯化｝
  451.      * strcpysafe 午  元仪毛允月［
  452.      */
  454.     int Short;
  455.     Short = min( strlen( src ) , length );
  457.     /* NULL  侬 毛哔  仄凶  胜 */
  458.     if( n < Short + 1 ){
  459.         /*
  460.          * 田永白央互箫曰卅中及匹 n - 1(NULL  侬)
  461.          * 匹 strncpy 毛裟少
  462.          */
  463.         strncpy2( dest , src , n-1 );
  464.         dest[n-1]='';
  466.     }else if( n <= 0 ){
  467.         return;
  468.     }else{
  469.         /*
  470.          * 田永白央反蜗坌卞丐月及匹 Short 匹strncpy毛裟少
  471.          * 卅云 src 卞反 Short 及赢今  卞 NULL 互卅中及匹｝
  472.          * dest 卞反 馨笛仄化云仁［
  473.          */
  475.         strncpy2( dest , src , Short );
  476.         dest[Short]= '';
  478.     }
  479. }
  481. void strcpysafe( char* dest ,size_t n ,const char* src )
  482. {
  483.     /*
  484.      * src 井日 dest 尺戊疋□允月.
  485.      * strcpy, strncpy 匹反 dest 方曰 戊疋□允月汹互
  486.      *   五中凛卞裟少午,丢乒伉陆失弁本旦互粟月.
  487.      * 仇木毛  什啃卞, strncpy 互丐月互 strlen( src ) 互 n 方曰
  488.      *   五中凛卞反, dest 及    互 NULL   侬午反卅日卅中.
  489.      *
  490.      * 仄凶互匀化 dest 及  五今方曰 src 及幻丹互赢中凛卞反
  491.      * n-1 匹 strncpy 毛允月. 凝今中凛反公及引引戊疋□允月
  492.      *
  493.      * n 互  及凛反云井仄仁卅月及匹  及凛反 窒手仄卅中［
  494.      *
  495.      */
  496.     // Nuke +1 (08/25): Danger if src=0
  497.     if (!src) {
  498.         *dest = '';
  499.         return;
  500.     }
  501.     if( n <= 0 )        /* 窒手仄卅中   */
  502.         return;
  504.     /*  仇及凛鳔匹｝ n >= 1 动晓互瑁烂  */
  505.     /*  NULL  侬毛哔  仄化  胜允月  */
  506.     else if( n < strlen( src ) + 1 ){
  507.         /*
  508.          * 田永白央互箫曰卅中及匹 n - 1(NULL  侬)
  509.          * 匹 strncpy 毛裟少
  510.          */
  511.         strncpy2( dest , src , n-1 );
  512.         dest[n-1]='';
  513.     }else
  514.         strcpy( dest , src );
  516. }
  518. char * ScanOneByte( char *src, char delim )
  519. {
  520. // Nuke
  521. if (!src) return NULL;
  523.         //   侬  互卅仁卅月引匹腹绸
  524.         for( ;src[0] != ''; src ++ ){
  525.           if( IS_2BYTEWORD( src[0] ) ){
  526.               // 蝈剩分［公及桦宁反ㄠ田奶玄芴坌卞褡引六月［
  527.               // 凶分仄ㄠ田奶玄仄井卅中桦宁反公丹仄卅中
  528.               if( src[1] != 0 ){
  529.                   src ++;
  530.               }
  531.               continue;
  532.           }
  533.           //   剩分匀凶［仇仇匹覆擂及  侬午  胜
  534.           if( src[0] == delim ){
  535.               return src;
  536.           }
  537.         }
  538.         // 伙□皿  仃凶日苇勾井日卅井匀凶［
  539.         return NULL;
  540. }
  542. int easyGetTokenFromBuf( char* src ,char* delim ,int count, char* output , int len )
  543. {//ttom this function all change,copy from the second
  544.     int i;          /* 伙□皿  醒 */
  545.     int length =0;  /* 潸曰请仄凶  侬  及赢今 */
  546.     int addlen=0;   /* 箫今木月赢今 */
  547.     int oneByteMode = 0; /* ㄠ田奶玄乒□玉井＂ */
  549.     if( strlen( delim ) == 1 ){ // 腹绸互ㄠ田奶玄卅日ㄠ田奶玄乒□玉卞允月
  550.         oneByteMode = 1;// 公及端ㄡ田奶玄  侬反民尼永弁仄卅中
  551.     }
  552.     for( i =  0 ; i < count ; i ++ ){
  553.          char* last;
  554.          src += addlen;/* 心勾井匀凶赢今毛箫允 */
  555.       
  556.          if( oneByteMode ){
  557.              // ㄠ田奶玄乒□玉分匀凶日仇切日匹腹绸
  558.              last = ScanOneByte( src, delim[0] );
  559.          }else{
  560.                  last  = strstr( src , delim );  /* 苇尥仃月 */
  561.          }
  562.          if( last == NULL ){
  563.             /*
  564.              * 心勾井日卅井匀凶及匹允屯化戊疋□仄化 return［
  565.             */
  566.             strcpysafe( output , len, src );
  568.             if( i == count - 1 )
  569.                 /*切斤丹升心勾井匀凶*/
  570.                 return 1;
  571.                                                                                                            
  572.                 /*心勾井日卅井匀凶*/
  573.              return 0;
  574.           }
  575.           
  576.           /*
  577.            * 心勾井匀凶赭午  赓及匏  及犒毛菲户月
  578.            * 勾引曰嗉濠日木化中月  侬  及赢今
  579.           */
  580.           length = last - src;
  581.                                            
  582.           /*
  583.            * 戚及伙□皿及啃卞心勾井匀凶赢今午 delim 及赢今毛箫仄化云仁
  584.           */
  585.           addlen= length + strlen( delim );
  586.        }
  587.        strncpysafe( output, len , src,length );
  589.        return 1;
  590. }