Beispiel #1
0
/*****************************************************************************
*   CkBracketType:
*	checks /citation=([1],[3])
*     May be we should check for only single value here like
*	/citation=[digit]
*                                                          -Tatiana 1/28/95
******************************************************************************/
NLM_EXTERN CharPtr CkBracketType(CharPtr str)
{	
	if (str == NULL)
		return "NULL value";
	if (*str == '[') {
		str++;
		if (!IS_DIGIT(*str)) {
			return str;
		} else {
			while (IS_DIGIT(*str)) {
				str++;
			}
			if (*str != ']') {
				return str;
			}
			str++;
			if (*str != '\0') {
				return str;
			}  
			return NULL;
		}
	} else {
		return str;
	}
}
Beispiel #2
0
static int cmp(const void *a, const void *b) {
	char *da = NULL;
	char *db = NULL;
	const char *ca = r_str_trim_ro (a);
	const char *cb = r_str_trim_ro (b);
	if (!a || !b) {
		return (int) (size_t) ((char*) a - (char*) b);
	}
	if (sorted_column > 0) {
		da = strdup (ca);
		db = strdup (cb);
		int colsa = r_str_word_set0 (da);
		int colsb = r_str_word_set0 (db);
		ca = (colsa > sorted_column)? r_str_word_get0 (da, sorted_column): "";
		cb = (colsb > sorted_column)? r_str_word_get0 (db, sorted_column): "";
	}
	if (IS_DIGIT (*ca) && IS_DIGIT (*cb)) {
		ut64 na = r_num_get (NULL, ca);
		ut64 nb = r_num_get (NULL, cb);
		int ret = na > nb;
		free (da);
		free (db);
		return ret;
	}
	if (da && db) {
		int ret = strcmp (ca, cb);
		free (da);
		free (db);
		return ret;
	}
	free (da);
	free (db);
	return strcmp (a, b);
}
Beispiel #3
0
static bool check_number(const char* str, size_t len)
{
  char num_type = 0;
  int stat = 0;
  for (size_t i = 0; i < len; i++) {
    if ('<' == str[i] || '>' == str[i]) {
      if (0 != stat)
        return false;
      stat = '<';
    } else if ('$' == str[i] || 'O' == str[i] || '%' == str[i]) {
      if ('$' == stat || '0' == stat)
        return false;
      num_type = str[i];
      stat = '$';
    } else if (IS_DIGIT(str[i])) {
      if (('%' == num_type) && ('0' != str[i] && '1' != str[i]))
        return false;
      else if (('O' == num_type) && !IS_DIGIT(str[i]))
        return false;
      stat = '0';
    } else if ('A' <= str[i] && 'F' >= str[i]) {
      if ('$' != num_type)
        return false;
      stat = '0';
    } else {
      break;
    }
  }
  return '0' == stat;    
}
Beispiel #4
0
int fast_atoi(const std::string & src)
{
    if (src.empty())
        return 0;
    const char * p = &src[0];
    const char * end = p + src.size();
    int value = 0;
    int sign = 1;

    while (IS_WHITESPACE(*p) || *p == '0') {
        INCREMENT_PTR();
    }

    switch (*p) {
        case '-':
            sign = -1;
            INCREMENT_PTR();
            break;
        case '+':
            INCREMENT_PTR();
            break;
        default:
            break;
    }

    while (IS_DIGIT(*p)) {
        value = value * 10 + (*p - '0');
        INCREMENT_PTR();
    }

parse_end:
    return value * sign;
}
Beispiel #5
0
// convert hexadecimal string to unsigned integer
char *hatoui(char *first, char *last, unsigned int *out)
{
	unsigned int result = 0;
	for (; first != last; ++first)
	{
		int digit;
		if (IS_DIGIT(*first))
		{
			digit = *first - '0';
		}
		else if (*first >= 'a' && *first <= 'f')
		{
			digit = *first - 'a' + 10;
		}
		else if (*first >= 'A' && *first <= 'F')
		{
			digit = *first - 'A' + 10;
		}
		else
		{
			break;
		}
		result = 16 * result + digit;
	}
	*out = result;

	return first;
}
Beispiel #6
0
static bool is_valid_project_name(const char *name) {
	int i;
	if (r_str_endswith (name, ".zip")) {
		return false;
	}
	for (i = 0; name[i]; i++) {
		switch (name[i]) {
		case '\\': // for w32
		case '.':
		case '_':
		case ':':
		case '-':
			continue;
		}
		if (name[i] >= 'a' && name[i] <= 'z') {
			continue;
		}
		if (name[i] >= 'A' && name[i] <= 'Z') {
			continue;
		}
		if (IS_DIGIT (name[i])) {
			continue;
		}
		return false;
	}
	return true;
}
Beispiel #7
0
static char * dir_ConvertDescriptionToPrefName(DIR_Server * server)
{
#define MAX_PREF_NAME_SIZE 25
  char * fileName = nsnull;
  char fileNameBuf[MAX_PREF_NAME_SIZE];
  PRInt32 srcIndex = 0;
  PRInt32 destIndex = 0;
  PRInt32 numSrcBytes = 0;
  const char * descr = nsnull;
  if (server && server->description)
  {
    descr = server->description;
    numSrcBytes = PL_strlen(descr);
    while (srcIndex < numSrcBytes && destIndex < MAX_PREF_NAME_SIZE-1)
    {
      if (IS_DIGIT(descr[srcIndex]) || IS_ALPHA(descr[srcIndex]))
      {
        fileNameBuf[destIndex] = descr[srcIndex];
        destIndex++;
      }

      srcIndex++;
    }

    fileNameBuf[destIndex] = '\0'; /* zero out the last character */
  }

  if (destIndex) /* have at least one character in the file name? */
  fileName = strdup(fileNameBuf);

  return fileName;
}
Beispiel #8
0
util::number::parse_result util::number::parse(const void* buf, size_t len, uint32_t& n, uint32_t min, uint32_t max)
{
	if (len == 0) {
		return PARSE_ERROR;
	}

	const unsigned char* ptr = (const unsigned char*) buf;
	const unsigned char* end = ptr + len;

	n = 0;

	while (ptr < end) {
		unsigned char c = *ptr++;
		if (!IS_DIGIT(c)) {
			return PARSE_ERROR;
		}

		uint32_t tmp = (n * 10) + (c - '0');

		// Overflow?
		if (tmp < n) {
			return PARSE_ERROR;
		}

		n = tmp;
	}

	if (n < min) {
		return PARSE_UNDERFLOW;
	} else if (n > max) {
		return PARSE_OVERFLOW;
	}

	return PARSE_SUCCEEDED;
}
Beispiel #9
0
/***************************************************************************
*   CkQualEcnum:
*   -- Ec_num has text format,
*      but the text only allow digits, period, and hyphen (-)
*                                                                12-10-93
****************************************************************************/
NLM_EXTERN int CkQualEcnum( GBQualPtr PNTR head_gbqp, GBQualPtr gbqp, 
   GBQualPtr preq,
   Boolean error_msgs, Boolean perform_corrections )
{
   CharPtr  str;
   int retval = GB_FEAT_ERR_NONE;
		

   retval = CkQualText(head_gbqp, gbqp, preq, NULL, FALSE, 
        error_msgs, perform_corrections);
		if (retval == GB_FEAT_ERR_NONE){
   
      str = gbqp->val;
                                                       /* open double quote */
      while (*str != '\0' && (*str == ' ' || *str == '\"'))
          str++;
   
      for (; *str != '\0' && *str != '\"'; str++)
          if (!IS_DIGIT(*str) && *str != '.' && *str != '-') {
            if (error_msgs){ 
               ErrPostEx(SEV_ERROR, ERR_QUALIFIER_BadECnum,
                 "At <%c>(%d) /%s=%s",
                 *str, (int) *str, gbqp->qual,gbqp->val); 
             }
             retval = GB_FEAT_ERR_DROP;
             if (perform_corrections){
                DeleteGBQualFromList(head_gbqp, gbqp, preq);
             }
           break;
      }
   }

   return retval;

} /* CkQualEcnum */
Beispiel #10
0
// convert string to integer
char *atoi(char *first, char *last, int *out)
{
	int sign = 1;
	if (first != last)
	{
		if (*first == '-')
		{
			sign = -1;
			++first;
		}
		else if (*first == '+')
		{
			++first;
		}
	}

	int result = 0;
	for (; first != last && IS_DIGIT(*first); ++first)
	{
		result = 10 * result + (*first - '0');
	}
	*out = result * sign;

	return first;
}
Beispiel #11
0
number::parse_result_t number::parse_size_t(const char* string, size_t len, size_t& n, size_t min, size_t max)
{
	if (len == 0) {
		return PARSE_ERROR;
	}

	const char* end = string + len;

	n = 0;

	while (string < end) {
		unsigned char c = (unsigned char) *string++;
		if (!IS_DIGIT(c)) {
			return PARSE_ERROR;
		}

		size_t tmp = (n * 10) + (c - '0');

		// Overflow?
		if (tmp < n) {
			return PARSE_ERROR;
		}

		n = tmp;
	}

	if (n < min) {
		return PARSE_UNDERFLOW;
	} else if (n > max) {
		return PARSE_OVERFLOW;
	}

	return PARSE_SUCCEEDED;
}
Beispiel #12
0
static int cin_get_num(RNum *num, RNumCalc *nc, RNumCalcValue *n) {
	double d;
	char str[R_NUMCALC_STRSZ]; // TODO: move into the heap?
	int i = 0;
	char c;
	str[0] = 0;
	while (cin_get (num, nc, &c)) {
		if (c != '_' && c!=':' && c!='.' && !isalnum ((ut8)c)) {
			cin_putback (num, nc, c);
			break;
		}
		if (i < R_NUMCALC_STRSZ) {
			str[i++] = c;
		}
	}
	str[i] = 0;
	*n = Nset (r_num_get (num, str));
	if (IS_DIGIT (*str) && strchr (str, '.')) {
		if (sscanf (str, "%lf", &d) < 1) {
			return 0;
		}
		if (n->n < d) {
			*n = Nsetf (d);
		}
		n->d = d;
	}
	return 1;
}
Beispiel #13
0
R_API char *r_hex_from_py_array(char *out, const char *code) {
	const char abc[] = "0123456789abcdef";
	if (*code != '[' || !strchr (code, ']')) {
		return NULL;
	}
	code++;
	for (; *code; code++) {
		char *comma = strchr (code, ',');
		if (!comma) {
			comma = strchr (code, ']');
		}
		if (!comma) {
			break;
		}
		char * _word = r_str_ndup (code, comma - code);
		const char *word = _word;
		while (*word == ' ' || *word == '\t' || *word == '\n') {
			word++;
			word = skip_comment_py (word);
		}
		if (IS_DIGIT (*word)) {
			ut8 n = (ut8)r_num_math (NULL, word);
			*out++ = abc[(n >> 4) & 0xf];
			*out++ = abc[n & 0xf];
		}
		free (_word);
		code = comma;
		if (*code == ']') {
			break;
		}
	}
Beispiel #14
0
int myatoi(const char *str)
{
	int integer = 0;
	const char * p = str;
	int flag = 1;

	switch (*p) {
	case '+':
		p ++;
		break;
	case '-':
		flag = -1;
		p ++;
		break;
	default:
		break;
	}

	for (; '\0' != *p && IS_DIGIT(*p); p ++) {
		integer *= 10;
		integer += *p - '0';
	}
	
	return flag > 0 ? integer : -integer;
}
Beispiel #15
0
char *
chxj_url_encode(apr_pool_t *pool, const char *src)
{
  char *dst;
  register char *sp = (char *)src;
  int len;
  register int pos;

  if (! src) return apr_pstrdup(pool, "\0");

  len = strlen(src) * 3 + 1;
  dst = apr_palloc(pool, len);
  memset(dst, 0, len);
  pos = 0;

  while(*sp) {
    if (IS_ALPHA_UPPER(*sp) || IS_ALPHA_LOWER(*sp) || IS_DIGIT(*sp)) {
      dst[pos++] = *sp++;
      continue;
    }
    if (*sp == ' ') {
      dst[pos++] = '+';
      sp++;
      continue;
    }

    dst[pos++] = '%';
    dst[pos++] = TO_HEXSTRING((*sp >> 4) & 0x0f);
    dst[pos++] = TO_HEXSTRING((*sp & 0x0f));
    sp++;
  }
  return dst;
}
static xmlChar *
xmlPatScanNCName(xmlPatParserContextPtr ctxt) {
    const xmlChar *q, *cur;
    xmlChar *ret = NULL;
    int val, len;

    SKIP_BLANKS;

    cur = q = CUR_PTR;
    val = xmlStringCurrentChar(NULL, cur, &len);
    if (!IS_LETTER(val) && (val != '_'))
	return(NULL);

    while ((IS_LETTER(val)) || (IS_DIGIT(val)) ||
           (val == '.') || (val == '-') ||
	   (val == '_') ||
	   (IS_COMBINING(val)) ||
	   (IS_EXTENDER(val))) {
	cur += len;
	val = xmlStringCurrentChar(NULL, cur, &len);
    }
    ret = xmlStrndup(q, cur - q);
    CUR_PTR = cur;
    return(ret);
}
Beispiel #17
0
/*---------------------------------------------------------------------------*/
int getHostAddress (struct sockaddr_in *sin, const char *hostName, short port)
{
	struct hostent * hostent;

	sin->sin_family = AF_INET;
	sin->sin_port   = htons(port);
	
	// first try the name as a numbered IP address 
	if (IS_DIGIT(hostName[0]))
	{
		char testStr[16];

		webc_str_to_ip((unsigned char *) &sin->sin_addr, hostName);
		
		// do a check to make sure we translated an IP address
		webc_ip_to_str(testStr, (unsigned char *) &sin->sin_addr);
		if (!strcmp(hostName, testStr))
		{
			// if we go from string to ip addr and back, without
			//  changing the host name, this is success.
			return(0);
		}
	}
	
	// try looking up the name via DNS
	if ((hostent = gethostbyname(hostName)))
	{
		memcpy((unsigned char *) &sin->sin_addr, (unsigned char *) hostent->h_addr, 4);
		return(0);
	}
	
	return (-1);
}
Beispiel #18
0
Datei: xskip.c Projekt: mrmt/enma
/*
 * [RFC5234]
 * DIGIT =  %x30-39
 *               ; 0-9
 */
int
XSkip_digitBlock(const char *head, const char *tail, const char **nextp)
{
    const char *p;
    for (p = head; p < tail && IS_DIGIT(*p); ++p);
    *nextp = p;
    return *nextp - head;
}   // end function : XSkip_digitBlock
Beispiel #19
0
/*****************************************************************************
*   CkLabelType:
*	checks /label=,feature_label> or /label=<base_range>
*                                                          -Tatiana 1/28/95
******************************************************************************/
NLM_EXTERN CharPtr CkLabelType(CharPtr str)
{
	Boolean range = TRUE, label = TRUE;
	CharPtr		bptr;
	
	if (IS_DIGIT(*str)) {
		for (; IS_DIGIT(*str); str++)
			continue;
		if (*str == '.' && *(str+1) == '.') {
			str += 2;
			if (!IS_DIGIT(*str)) {
				range = FALSE;
			} else {
				while (IS_DIGIT(*str)) {
					str++;
				}
			}
			if (*str != '\0') {
				range = FALSE;
			}
		} else {
			range = FALSE;
		}
		
	} 
	if (!range) {
		bptr = str;
		for (;  *str != '\0' && !IS_ALPHA(*str); str++)
			continue;
		if (*str == '\0') {
			label = FALSE;    /* must be at least one letter */
		}
		for (str = bptr; *str != '\0' && IS_ALPHA(*str) || IS_DIGIT(*str) 
			|| *str == '-' || *str == '_' || *str == '\'' || *str == '*';
			str++)
			continue;
		if (*str != '\0') {
			label = FALSE;
		}
	}
	if (range || label) {
		return NULL;
	} else {
		return str;
	}
}
Beispiel #20
0
static Nlm_Uint8 s_StringToUint8(const char *str, const char **endptr, int *sgn)
{
    int sign = 0;  /* actual sign */
    Nlm_Uint8 limdiv, limoff, result;
    const char *s, *save;
    char c;

    /* assume error */
    *endptr = 0;
    if (!str)
        return 0;

    s = str;
    while (IS_WHITESP(*s))
        s++;
    /* empty string - error */
    if (*s == '\0')
        return 0;

    if (*sgn == 1) {
        if (*s == '-') {
            sign = 1;
            s++;
        } else if (*s == '+') {
            s++;
        }        
    }
    save = s;

    limdiv = UINT8_MAX / 10;
    limoff = UINT8_MAX % 10;
    result = 0;
    
    for (c = *s; c; c = *++s) {
        if (!IS_DIGIT(c)) {
            break;
        }
        c -= '0';
        if (result > limdiv || (result == limdiv && c > limoff)) {
            /* overflow */
            return 0;
        }
        result *= 10;
        result += c;
    }

    /* there was no conversion - error */
    if (save == s)
        return 0;

    *sgn = sign;
    *endptr = s;
    return result;
}
Beispiel #21
0
/* int c; ret = hex_to_byte(&c, 'c'); */
R_API int r_hex_to_byte(ut8 *val, ut8 c) {
	if (IS_DIGIT(c)) {
		*val = (ut8)(*val) * 16 + (c - '0');
	} else if (c >= 'A' && c <= 'F') {
		*val = (ut8)(*val) * 16 + (c - 'A' + 10);
	} else if (c >= 'a' && c <= 'f') {
		*val = (ut8)(*val) * 16 + (c - 'a' + 10);
	} else {
		return 1;
	}
	return 0;
}
Beispiel #22
0
static t_bool	is_nbr(const char *str)
{
  int		idx;

  if (!(str))
    return (FALSE);
  str += (*str == SIGN_CHAR) ? (1) : (0);
  idx = 0;
  while (str[idx] && IS_DIGIT(str[idx]))
    ++idx;
  return (((idx == NULL_VALUE) || (str[idx])) ? (FALSE) : (TRUE));
}
Beispiel #23
0
static struct portlist *
make_portlist(Str port)
{
    struct portlist *first = NULL, *pl;
    char *p;
    Str tmp = Strnew();

    p = port->ptr;
    while (*p) {
	while (*p && !IS_DIGIT(*p))
	    p++;
	Strclear(tmp);
	while (*p && IS_DIGIT(*p))
	    Strcat_char(tmp, *(p++));
	if (tmp->length == 0)
	    break;
	pl = New(struct portlist);
	pl->port = atoi(tmp->ptr);
	pl->next = first;
	first = pl;
    }
    return first;
}
Beispiel #24
0
static int
toLength(char *oval, int *len)
{
    int w;
    if (!IS_DIGIT(oval[0]))
	return 0;
    w = atoi(oval);
    if (w < 0)
	return 0;
    if (w == 0)
	w = 1;
    if (oval[strlen(oval) - 1] == '%')
	*len = -w;
    else
	*len = w;
    return 1;
}
Beispiel #25
0
/*
 * Convert a string into a valid C identifier by replacing invalid
 * characters with '_'.  Also makes sure the string is nul-terminated
 * and takes up at most n bytes.
 */
void
strident_canon(char *s, size_t n)
{
	char c;
	char *end = s + n - 1;

	if ((c = *s) == 0)
		return;

	if (!IS_ALPHA(c) && c != '_')
		*s = '_';

	while (s < end && ((c = *(++s)) != 0)) {
		if (!IS_ALPHA(c) && !IS_DIGIT(c) && c != '_')
			*s = '_';
	}
	*s = 0;
}
Beispiel #26
0
static int
is_valid_ident(const char *s, const char *e, int allowdot)
{
	char c;

	if (s >= e)
		return (0);		/* name is empty */

	c = *s++;
	if (!IS_ALPHA(c))
		return (0);		/* does not start with letter */

	while (s < e && (c = *s++) != 0) {
		if (IS_ALPHA(c) || IS_DIGIT(c) || c == '-' || c == '_' ||
		    (allowdot && c == '.'))
			continue;
		return (0);		/* invalid character */
	}
	return (1);
}
Beispiel #27
0
Datei: xskip.c Projekt: mrmt/enma
/*
 * [RFC2821]
 * address-literal = "[" IPv4-address-literal /
 *                       IPv6-address-literal /
 *                       General-address-literal "]"
 * IPv4-address-literal = Snum 3("." Snum)
 * IPv6-address-literal = "IPv6:" IPv6-addr
 * General-address-literal = Standardized-tag ":" 1*dcontent
 * Standardized-tag = Ldh-str
 *       ; MUST be specified in a standards-track RFC
 *       ; and registered with IANA
 *
 * Snum = 1*3DIGIT  ; representing a decimal integer
 *       ; value in the range 0 through 255
 * Let-dig = ALPHA / DIGIT
 * Ldh-str = *( ALPHA / DIGIT / "-" ) Let-dig
 *
 * IPv6-addr = IPv6-full / IPv6-comp / IPv6v4-full / IPv6v4-comp
 * IPv6-hex  = 1*4HEXDIG
 * IPv6-full = IPv6-hex 7(":" IPv6-hex)
 * IPv6-comp = [IPv6-hex *5(":" IPv6-hex)] "::" [IPv6-hex *5(":"
 *            IPv6-hex)]
 *       ; The "::" represents at least 2 16-bit groups of zeros
 *       ; No more than 6 groups in addition to the "::" may be
 *       ; present
 * IPv6v4-full = IPv6-hex 5(":" IPv6-hex) ":" IPv4-address-literal
 * IPv6v4-comp = [IPv6-hex *3(":" IPv6-hex)] "::"
 *              [IPv6-hex *3(":" IPv6-hex) ":"] IPv4-address-literal
 *       ; The "::" represents at least 2 16-bit groups of zeros
 *       ; No more than 4 groups in addition to the "::" and
 *       ; IPv4-address-literal may be present
 */
static int
XSkip_addressLiteral(const char *head, const char *tail, const char **nextp)
{
    const char *p = head;

    *nextp = p; // 全体がマッチしない限りマッチしない

    if (tail <= p || *p != '[') {
        return *nextp - head;
    }   // end if

    // NOTE: 文字種のチェックしかおこなっていない
    for (++p; p < tail && (IS_DIGIT(*p) || *p == ':' || *p == '.'); ++p);

    if (tail <= p || *p != ']') {
        return *nextp - head;
    }   // end if

    *nextp = p + 1;
    return *nextp - head;
}   // end function : XSkip_addressLiteral
Beispiel #28
0
static Str
ftp_command(FTP ftp, char *cmd, char *arg, int *status)
{
    Str tmp;

    if (!ftp->host)
        return NULL;
    if (cmd) {
        if (arg)
            tmp = Sprintf("%s %s\r\n", cmd, arg);
        else
            tmp = Sprintf("%s\r\n", cmd);
        fwrite(tmp->ptr, sizeof(char), tmp->length, ftp->wf);
        fflush(ftp->wf);
    }
    if (!status)
        return NULL;
    *status = -1;		/* error */
    tmp = StrISgets(ftp->rf);
    if (IS_DIGIT(tmp->ptr[0]) && IS_DIGIT(tmp->ptr[1]) &&
            IS_DIGIT(tmp->ptr[2]) && tmp->ptr[3] == ' ')
        sscanf(tmp->ptr, "%d", status);

    if (tmp->ptr[3] != '-')
        return tmp;
    /* RFC959 4.2 FTP REPLIES */
    /* multi-line response start */
    /*
     * Thus the format for multi-line replies is that the
     * first line will begin with the exact required reply
     * code, followed immediately by a Hyphen, "-" (also known
     * as Minus), followed by text.  The last line will begin
     * with the same code, followed immediately by Space <SP>,
     * optionally some text, and the Telnet end-of-line code. */
    while (1) {
        tmp = StrISgets(ftp->rf);
        if (IS_DIGIT(tmp->ptr[0]) && IS_DIGIT(tmp->ptr[1]) &&
                IS_DIGIT(tmp->ptr[2]) && tmp->ptr[3] == ' ') {
            sscanf(tmp->ptr, "%d", status);
            break;
        }
    }
    return tmp;
}
Beispiel #29
0
int myatoi(char *s)
{
   int x;      /* the number */
   int base;   /* number base */
   int neg = FALSE;

   #define IS_DIGIT(c)  (((c >= '0') && (c <= ((base==8) ? '7' : '9'))) || \
			 ((base==16) && (c >= 'a') && (c <= 'f')))

   if (*s=='-') {
      neg = TRUE;
      s++;
   }

   if (*s=='0') {
      s++;
      if (*s=='x') {    /* 0x<hex number> */
	 s++;
	 base = 16;
      }
      else
	 base = 8;      /* 0<octal number> */
   }
   else
      base = 10;        /* <decimal number> */

   x = 0;

   while (IS_DIGIT(tolower(*s))) {      /* work through the string */
      x *= base;
      x += VALUE(tolower(*s));
      s++;
   }

   return neg ? -x : x;
}
Beispiel #30
0
unsigned char * webc_str_to_ip(unsigned char * ipaddr, const char * ipstr)
{
int n, i;

	tc_memset(ipaddr, 0, 4);

	for (n=0, i=0; ipstr[n] && i<4; n++)
	{
		if (IS_DIGIT(ipstr[n]))
		{
			ipaddr[i] = (ipaddr[i] * 10) + (ipstr[n] - '0');
		}
		else if (ipstr[n] == '.')
		{
			i++;
		}
		else
		{
			break;
		}
	}
	
	return (ipaddr);
}