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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
util.c
资源名称：pvpgn-1.6.2.rar　[点击查看]
上传用户：tany51
上传日期：2013-06-12
资源大小：1397k
文件大小：13k
源码类别：

MySQL数据库

开发平台：

Visual C++

util.c：源码内容
  1. /*
  2.  * Copyright (C) 1998  Mark Baysinger (mbaysing@ucsd.edu)
  3.  * Copyright (C) 1998,1999,2000,2001  Ross Combs (rocombs@cs.nmsu.edu)
  4.  *
  5.  * This program is free software; you can redistribute it and/or
  6.  * modify it under the terms of the GNU General Public License
  7.  * as published by the Free Software Foundation; either version 2
  8.  * of the License, or (at your option) any later version.
  9.  *
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18.  */
  19. #include "common/setup_before.h"
  20. #include <stdio.h>
  21. #ifdef HAVE_STDDEF_H
  22. # include <stddef.h>
  23. #else
  24. # ifndef NULL
  25. #  define NULL ((void *)0)
  26. # endif
  27. #endif
  28. #ifdef STDC_HEADERS
  29. # include <stdlib.h>
  30. #else
  31. # ifdef HAVE_MALLOC_H
  32. #  include <malloc.h>
  33. # endif
  34. #endif
  35. #include "compat/strtoul.h"
  36. #ifdef HAVE_STRING_H
  37. # include <string.h>
  38. #else
  39. # ifdef HAVE_STRINGS_H
  40. #  include <strings.h>
  41. # endif
  42. #endif
  43. #include "compat/strcasecmp.h"
  44. #include "compat/strncasecmp.h"
  45. #include <ctype.h>
  46. #include "common/util.h"
  47. #include "common/setup_after.h"
  50. extern int strstart(char const * full, char const * part)
  51. {
  52.     size_t strlen_full, strlen_part;
  53.     if (!full || !part)
  54. return 1;
  55.     strlen_full = strlen(full);
  56.     strlen_part = strlen(part);
  57.     if (strlen_full<strlen_part)
  58. return 1;
  59.     /* If there is more than the command, make sure it is separated */
  60.     if (strlen_full>strlen_part && full[strlen_part]!=' ' && full[strlen_part]!='')
  61.         return 1;
  62.     return strncasecmp(full,part,strlen_part);
  63. }
  66. #define DEF_LEN 64
  67. #define INC_LEN 16
  69. extern char * file_get_line(FILE * fp)
  70. {
  71.     char *       line;
  72.     char *       newline;
  73.     unsigned int len=DEF_LEN;
  74.     unsigned int pos=0;
  75.     int          prev_char,curr_char;
  76.     
  77.     if (!(line = malloc(DEF_LEN)))
  78. return NULL;
  79.     
  80.     prev_char = '';
  81.     while ((curr_char = fgetc(fp))!=EOF)
  82.     {
  83. if (((char)curr_char)=='r')
  84.     continue; /* make DOS line endings look Unix-like */
  85. if (((char)curr_char)=='n')
  86. {
  87.     if (pos<1 || ((char)prev_char)!='\')
  88. break;
  89.     pos--; /* throw away the backslash */
  90.     prev_char = '';
  91.     continue;
  92. }
  93. prev_char = curr_char;
  95. line[pos++] = (char)curr_char;
  96. if ((pos+1)>=len)
  97. {
  98.     len += INC_LEN;
  99.     if (!(newline = realloc(line,len)))
  100.     {
  101. free(line);
  102. return NULL;
  103.     }
  104.     line = newline;
  105. }
  106.     }
  107.     
  108.     if (curr_char==EOF && pos<1) /* not even an empty line */
  109.     {
  110. free(line);
  111. return NULL;
  112.     }
  113.     
  114.     if (pos+1<len)
  115. if ((newline = realloc(line,pos+1))) /* bump the size back down to what we need */
  116.     line = newline; /* if it fails just ignore it */
  117.     
  118.     line[pos] = '';
  119.     
  120.     return line;
  121. }
  124. extern char * strreverse(char * str)
  125. {
  126.     unsigned int i;
  127.     unsigned int len;
  128.     char         temp;
  129.     
  130.     if (!str)
  131. return NULL;
  132.     
  133.     len = strlen(str);
  134.     
  135.     /* swap leftmost and rightmost chars until we hit center */
  136.     for (i=0; i<len/2; i++)
  137.     {
  138. temp         = str[i];
  139. str[i]       = str[len-1-i];
  140. str[len-1-i] = temp;
  141.     }
  142.     
  143.     return str;
  144. }
  147. extern int str_to_uint(char const * str, unsigned int * num)
  148. {
  149.     unsigned int pos;
  150.     unsigned int i;
  151.     unsigned int val;
  152.     unsigned int pval;
  153.     
  154.     if (!str || !num)
  155.         return -1;
  156.     for (pos=0; str[pos]==' ' || str[pos]=='t'; pos++);
  157.     if (str[pos]=='+')
  158.         pos++;
  159.     
  160.     val = 0;
  161.     for (i=pos; str[i]!=''; i++)
  162.     {
  163. pval = val;
  164.         val *= 10;
  165. if (val/10!=pval) /* check for overflow */
  166.     return -1;
  168. pval = val;
  169. switch (str[i])
  170. {
  171. case '0':
  172.     break;
  173. case '1':
  174.     val += 1;
  175.     break;
  176. case '2':
  177.     val += 2;
  178.     break;
  179. case '3':
  180.     val += 3;
  181.     break;
  182. case '4':
  183.     val += 4;
  184.     break;
  185. case '5':
  186.     val += 5;
  187.     break;
  188. case '6':
  189.     val += 6;
  190.     break;
  191. case '7':
  192.     val += 7;
  193.     break;
  194. case '8':
  195.     val += 8;
  196.     break;
  197. case '9':
  198.     val += 9;
  199.     break;
  200. default:
  201.     return -1;
  202. }
  203. if (val<pval) /* check for overflow */
  204.     return -1;
  205.     }
  206.     
  207.     *num = val;
  208.     return 0;
  209. }
  212. extern int str_to_ushort(char const * str, unsigned short * num)
  213. {
  214.     unsigned int   pos;
  215.     unsigned int   i;
  216.     unsigned short val;
  217.     unsigned short pval;
  218.     
  219.     if (!str || !num)
  220.         return -1;
  221.     for (pos=0; str[pos]==' ' || str[pos]=='t'; pos++);
  222.     if (str[pos]=='+')
  223.         pos++;
  224.     
  225.     val = 0;
  226.     for (i=pos; str[i]!=''; i++)
  227.     {
  228. pval = val;
  229.         val *= 10;
  230. if (val/10!=pval) /* check for overflow */
  231.     return -1;
  233. pval = val;
  234. switch (str[i])
  235. {
  236. case '0':
  237.     break;
  238. case '1':
  239.     val += 1;
  240.     break;
  241. case '2':
  242.     val += 2;
  243.     break;
  244. case '3':
  245.     val += 3;
  246.     break;
  247. case '4':
  248.     val += 4;
  249.     break;
  250. case '5':
  251.     val += 5;
  252.     break;
  253. case '6':
  254.     val += 6;
  255.     break;
  256. case '7':
  257.     val += 7;
  258.     break;
  259. case '8':
  260.     val += 8;
  261.     break;
  262. case '9':
  263.     val += 9;
  264.     break;
  265. default:
  266.     return -1;
  267. }
  268. if (val<pval) /* check for overflow */
  269.     return -1;
  270.     }
  271.     
  272.     *num = val;
  273.     return 0;
  274. }
  277. /* This routine assumes ASCII like control chars.
  278.    If len is zero, it will print all characters up to the first NUL,
  279.    otherwise it will print exactly that many characters. */
  280. int str_print_term(FILE * fp, char const * str, unsigned int len, int allow_nl)
  281. {
  282.     unsigned int i;
  283.     
  284.     if (!fp)
  285. return -1;
  286.     if (!str)
  287. return -1;
  288.     
  289.     if (len==0)
  290. len = strlen(str);
  291.     for (i=0; i<len; i++)
  292. if ((str[i]=='177' || (str[i]>='00' && str[i]<'40')) &&
  293.     (!allow_nl || (str[i]!='r' && str[i]!='n')))
  294.     fprintf(fp,"^%c",str[i]+64);
  295. else
  296.     fputc((int)str[i],fp);
  297.     
  298.     return 0;
  299. }
  302. extern int str_get_bool(char const * str)
  303. {
  304.     if (!str)
  305. return -1;
  306.     
  307.     if (strcasecmp(str,"true")==0 ||
  308. strcasecmp(str,"yes")==0 ||
  309. strcasecmp(str,"on")==0 ||
  310. strcmp(str,"1")==0)
  311. return 1;
  312.     
  313.     if (strcasecmp(str,"false")==0 ||
  314. strcasecmp(str,"no")==0 ||
  315. strcasecmp(str,"off")==0 ||
  316. strcmp(str,"0")==0)
  317. return 0;
  318.     
  319.     return -1;
  320. }
  323. extern char const * seconds_to_timestr(unsigned int totsecs)
  324. {
  325.     static char temp[256];
  326.     int         days;
  327.     int         hours;
  328.     int         minutes;
  329.     int         seconds;
  330.     
  331.     days    = totsecs/(24*60*60);
  332.     hours   = totsecs/(60*60) - days*24;
  333.     minutes = totsecs/60 - days*24*60 - hours*60;
  334.     seconds = totsecs - days*24*60*60 - hours*60*60 - minutes*60;
  335.     
  336.     if (days>0)
  337. sprintf(temp,"%d day%s %d hour%s %d minute%s %d second%s",
  338.                 days,days==1 ? "" : "s",
  339.                 hours,hours==1 ? "" : "s",
  340.                 minutes,minutes==1 ? "" : "s",
  341.                 seconds,seconds==1 ? "" : "s");
  342.     else if (hours>0)
  343. sprintf(temp,"%d hour%s %d minute%s %d second%s",
  344.                 hours,hours==1 ? "" : "s",
  345.                 minutes,minutes==1 ? "" : "s",
  346.                 seconds,seconds==1 ? "" : "s");
  347.     else if (minutes>0)
  348. sprintf(temp,"%d minute%s %d second%s",
  349.                 minutes,minutes==1 ? "" : "s",
  350.                 seconds,seconds==1 ? "" : "s");
  351.     else
  352. sprintf(temp,"%d second%s.",
  353.                 seconds,seconds==1 ? "" : "s");
  354.     
  355.     return temp;
  356. }
  359. extern int clockstr_to_seconds(char const * clockstr, unsigned int * totsecs)
  360. {
  361.     unsigned int i,j;
  362.     unsigned int temp;
  363.     
  364.     if (!clockstr)
  365. return -1;
  366.     if (!totsecs)
  367. return -1;
  368.     
  369.     for (i=j=temp=0; j<strlen(clockstr); j++)
  370.     {
  371. switch (clockstr[j])
  372. {
  373. case ':':
  374.     temp *= 60;
  375.     temp += strtoul(&clockstr[i],NULL,10);
  376.     i = j+1;
  377.     break;
  378. case '0':
  379. case '1':
  380. case '2':
  381. case '3':
  382. case '4':
  383. case '5':
  384. case '6':
  385. case '7':
  386. case '8':
  387. case '9':
  388.     break;
  389. default:
  390.     return -1;
  391. }
  392.     }
  393.     if (i<j)
  394.     {
  395. temp *= 60;
  396. temp += strtoul(&clockstr[i],NULL,10);
  397.     }
  398.     
  399.     *totsecs = temp;
  400.     return 0;
  401. }
  404. extern char * escape_fs_chars(char const * in, unsigned int len)
  405. {
  406.     char *       out;
  407.     unsigned int inpos;
  408.     unsigned int outpos;
  409.     
  410.     if (!in)
  411. return NULL;
  412.     if (!(out = malloc(len*3+1))) /* if all turn into %XX */
  413. return NULL;
  414.     
  415.     for (inpos=0,outpos=0; inpos<len; inpos++)
  416.     {
  417. if (in[inpos]=='' || in[inpos]=='%' || in[inpos]=='/' ||
  418.             in[inpos]=='\' || in[inpos]==':') /* FIXME: what other characters does Windows not allow? */
  419. {
  420.     out[outpos++] = '%';
  421.     /* always 00 through FF hex */
  422.     sprintf(&out[outpos],"%02X",(unsigned int)(unsigned char)in[inpos]);
  423.     outpos += 2;
  424. }
  425. else
  426.     out[outpos++] = in[inpos];
  427.     }
  428. /*  if outpos >= len*3+1 then the buffer was overflowed */
  429.     out[outpos] = '';
  430.     
  431.     return out;
  432. }
  435. extern char * escape_chars(char const * in, unsigned int len)
  436. {
  437.     char *       out;
  438.     unsigned int inpos;
  439.     unsigned int outpos;
  440.     
  441.     if (!in)
  442. return NULL;
  443.     if (!(out = malloc(len*4+1))) /* if all turn into xxx */
  444. return NULL;
  445.     
  446.     for (inpos=0,outpos=0; inpos<len; inpos++)
  447.     {
  448. if (in[inpos]=='\')
  449. {
  450.     out[outpos++] = '\';
  451.     out[outpos++] = '\';
  452. }
  453. else if (in[inpos]=='"')
  454. {
  455.     out[outpos++] = '\';
  456.     out[outpos++] = '"';
  457. }
  458.         else if (isascii((int)in[inpos]) && isprint((int)in[inpos]))
  459.     out[outpos++] = in[inpos];
  460.         else if (in[inpos]=='a')
  461. {
  462.     out[outpos++] = '\';
  463.     out[outpos++] = 'a';
  464. }
  465.         else if (in[inpos]=='b')
  466. {
  467.     out[outpos++] = '\';
  468.     out[outpos++] = 'b';
  469. }
  470.         else if (in[inpos]=='t')
  471. {
  472.     out[outpos++] = '\';
  473.     out[outpos++] = 't';
  474. }
  475.         else if (in[inpos]=='n')
  476. {
  477.     out[outpos++] = '\';
  478.     out[outpos++] = 'n';
  479. }
  480.         else if (in[inpos]=='v')
  481. {
  482.     out[outpos++] = '\';
  483.     out[outpos++] = 'v';
  484. }
  485.         else if (in[inpos]=='f')
  486. {
  487.     out[outpos++] = '\';
  488.     out[outpos++] = 'f';
  489. }
  490.         else if (in[inpos]=='r')
  491. {
  492.     out[outpos++] = '\';
  493.     out[outpos++] = 'r';
  494. }
  495. else
  496. {
  497.     out[outpos++] = '\';
  498.     /* always 001 through 377 octal */
  499.     sprintf(&out[outpos],"%03o",(unsigned int)(unsigned char)in[inpos]);
  500.     outpos += 3;
  501. }
  502.     }
  503. /*  if outpos >= len*4+1 then the buffer was overflowed */
  504.     out[outpos] = '';
  505.     
  506.     return out;
  507. }
  510. extern char * unescape_chars(char const * in)
  511. {
  512.     char *       out;
  513.     unsigned int inpos;
  514.     unsigned int outpos;
  515.     
  516.     if (!in)
  517. return NULL;
  518.     if (!(out = malloc(strlen(in)+1)))
  519. return NULL;
  520.     
  521.     for (inpos=0,outpos=0; inpos<strlen(in); inpos++)
  522.     {
  523.         if (in[inpos]!='\')
  524.     out[outpos++] = in[inpos];
  525.         else
  526.     switch (in[++inpos])
  527.     {
  528.     case '\':
  529. out[outpos++] = '\';
  530. break;
  531.     case '"':
  532. out[outpos++] = '"';
  533. break;
  534.     case 'a':
  535. out[outpos++] = 'a';
  536. break;
  537.     case 'b':
  538. out[outpos++] = 'b';
  539. break;
  540.     case 't':
  541. out[outpos++] = 't';
  542. break;
  543.     case 'n':
  544. out[outpos++] = 'n';
  545. break;
  546.     case 'v':
  547. out[outpos++] = 'v';
  548. break;
  549.     case 'f':
  550. out[outpos++] = 'f';
  551. break;
  552.     case 'r':
  553. out[outpos++] = 'r';
  554. break;
  555.     default:
  556.     {
  557. char         temp[4];
  558. unsigned int i;
  559. unsigned int num;
  561. for (i=0; i<3; i++)
  562. {
  563.     if (in[inpos]!='0' &&
  564.         in[inpos]!='1' &&
  565.         in[inpos]!='2' &&
  566.         in[inpos]!='3' &&
  567.         in[inpos]!='4' &&
  568.         in[inpos]!='5' &&
  569.         in[inpos]!='6' &&
  570.         in[inpos]!='7')
  571. break;
  572.     temp[i] = in[inpos++];
  573. }
  574. temp[i] = '';
  575. inpos--;
  577. num = strtoul(temp,NULL,8);
  578. if (i<3 || num<1 || num>255) /* bad escape (including 00), leave it as-is */
  579. {
  580.     out[outpos++] = '\';
  581.     strcpy(&out[outpos],temp);
  582.     outpos += strlen(temp);
  583. }
  584. else
  585.     out[outpos++] = (unsigned char)num;
  586.     }
  587. }
  588.     }
  589.     out[outpos] = '';
  590.     
  591.     return out;
  592. }
  595. extern void str_to_hex(char * target, char * data, int datalen)
  596. {
  597.     unsigned char c;
  598.     int  i;
  599.     for (i = 0; i < datalen; i++)
  600.     {
  601.         c = (data[i]) & 0xff;
  603. sprintf(target + i*3, "%02X    ", c);
  604. target[i*3+3] = '';
  606. /* fprintf(stderr, "str_to_hex %d | '%02x' '%s'n", i, c, target); */
  607.     }
  608. }
  611. extern int hex_to_str(char const * source, char * data, int datalen)
  612. {
  613.    /*
  614.     * TODO: We really need a more robust function here,
  615.     *       for now, I'll just use this hack for a quick evaluation
  616.     */
  617.     char byte;
  618.     char c;
  619.     int  i;
  620.   
  621.     for (i = 0; i < datalen; i++)
  622.     {
  623. byte  = 0;
  624.     
  625. /* fprintf(stderr, "hex_to_str %d | '%02x'", i, byte); */
  627. c = source [i*3 + 0];
  628. byte += 16 * ( c > '9' ? (c - 'A' + 10) : (c - '0'));
  630. /* fprintf(stderr, " | '%c' '%02x'", c, byte); */
  632. c = source [i*3 + 1];
  633. byte +=  1 * ( c > '9' ? (c - 'A' + 10) : (c - '0'));
  635. /* fprintf(stderr, " | '%c' '%02x'", c, byte); */
  637. /* fprintf(stderr, "n"); */
  639. data[i] = byte;
  640.     }
  641.     
  642.     /* fprintf(stderr, "finished, returning %d from '%s'n", i, source);  */
  643.     
  644.     return i;
  645. }