Return to hstring.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / hping2

Annotation of embedaddon/hping2/hstring.c, revision 1.1.1.1

1.1       misho       1: /* hstring.c - Random string-related functions for hping.
                      2:  * Copyright(C) 2003 Salvatore Sanfilippo
                      3:  * All rights reserved */
                      4: 
                      5: #include <sys/types.h>
                      6: #include <string.h>
                      7: #include <ctype.h>
                      8: 
                      9: /* return 1 if the string looks like an integer number
                     10:  * otherwise 0 is returned.
                     11:  *
                     12:  * this function is equivalent to this regexp:
                     13:  *             [:space:]*-{0,1}[0-9]+[:space:]*
                     14:  * in english:
                     15:  *  (0-inf spaces)(zero or one -)(1-inf digits)(0-inf spaces)
                     16:  */
                     17: int strisnum(char *s)
                     18: {
                     19:        int digits = 0; /* used to return false if there aren't digits */
                     20: 
                     21:        while(isspace(*s))
                     22:                s++; /* skip initial spaces */
                     23:        if (*s == '-') /* negative number? */
                     24:                s++;
                     25:        while(*s) {
                     26:                if (isspace(*s)) { /* skip spaces in the tail */
                     27:                        while(isspace(*s))
                     28:                                s++;
                     29:                        if (*s) return 0; /* but don't allow other tail chars */
                     30:                        return digits ? 1 : 0;
                     31:                }
                     32:                if (!isdigit(*s))
                     33:                        return 0;
                     34:                s++;
                     35:                digits++;
                     36:        }
                     37:        return digits ? 1 : 0;
                     38: }
                     39: 
                     40: /* function similar to strtok() more convenient when we know the
                     41:  * max number of tokens, to tokenize with a single call.
                     42:  * Unlike strtok(), strftok() is thread safe.
                     43:  *
                     44:  * ARGS:
                     45:  *   'sep' is a string that contains all the delimiter characters
                     46:  *   'str' is the string to tokenize, that will be modified
                     47:  *   'tptrs' is an array of char* poiters that will contain the token pointers
                     48:  *   'nptrs' is the length of the 'tptrs' array.
                     49:  *
                     50:  * RETURN VALUE:
                     51:  *   The number of extracted tokens is returned.
                     52:  */
                     53: size_t strftok(char *sep, char *str, char **tptrs, size_t nptrs)
                     54: {
                     55:        size_t seplen = strlen(sep);
                     56:        size_t i, j = 0;
                     57:        int inside = 0;
                     58: 
                     59:        while(*str) {
                     60:                for(i = 0; i < seplen; i++) {
                     61:                        if (sep[i] == *str)
                     62:                                break;
                     63:                }
                     64:                if (i == seplen) { /* no match */
                     65:                        if (!inside) {
                     66:                                tptrs[j++] = str;
                     67:                                inside = 1;
                     68:                        }
                     69:                } else { /* match */
                     70:                        if (inside) {
                     71:                                *str = '\0';
                     72:                                if (j == nptrs)
                     73:                                        return j;
                     74:                                inside = 0;
                     75:                        }
                     76:                }
                     77:                str++;
                     78:        }
                     79:        return j;
                     80: }