Ejemplo n.º 1
0
/*
 * Converts ascii lat/lon to unsigned encoded 32-bit number
 */
static DWORD latlon2ul (char **latlonstrptr, int *which)
{
  DWORD retval;
  char *cp   = *latlonstrptr;
  int   deg  = 0;
  int   min  = 0;
  int   secs = 0;
  int   secsfrac = 0;

  while (isdigit(*cp))
     deg = deg * 10 + (*cp++ - '0');

  while (isspace(*cp))
     cp++;

  if (!(isdigit(*cp)))
     goto fndhemi;

  while (isdigit(*cp))
     min = min * 10 + (*cp++ - '0');

  while (isspace(*cp))
     cp++;

  if (!(isdigit(*cp)))
     goto fndhemi;

  while (isdigit(*cp))
     secs = secs * 10 + (*cp++ - '0');

  if (*cp == '.')            /* decimal seconds */
  {
    cp++;
    if (isdigit(*cp))
    {
      secsfrac = (*cp++ - '0') * 100;
      if (isdigit(*cp))
      {
        secsfrac += (*cp++ - '0') * 10;
        if (isdigit(*cp))
           secsfrac += (*cp++ - '0');
      }
    }
  }

  while (!isspace(*cp))   /* if any trailing garbage */
     cp++;

  while (isspace(*cp))
     cp++;

fndhemi:

  switch (toupper(*cp))
  {
    case 'N':
    case 'E':
         retval = (1UL << 31UL)
                + (((((deg * 60UL) + min) * 60UL) + secs) * 1000UL)
                + secsfrac;
         break;
    case 'S':
    case 'W':
         retval = (1UL << 31UL)
                - (((((deg * 60UL) + min) * 60UL) + secs) * 1000UL)
                - secsfrac;
         break;
    default:
         retval = 0;     /* invalid value -- indicates error */
         break;
  }

  switch (toupper(*cp))
  {
    case 'N':
    case 'S':
         *which = 1;      /* latitude */
         break;
    case 'E':
    case 'W':
         *which = 2;      /* longitude */
         break;
    default:
         *which = 0;      /* error */
         break;
  }

  cp++;                   /* skip the hemisphere */

  while (!isspace(*cp))   /* if any trailing garbage */
     cp++;

  while (isspace(*cp))    /* move to next field */
     cp++;

  *latlonstrptr = cp;
  return (retval);
}
Ejemplo n.º 2
0
static int skipWhite (int c)
{
	while (isspace (c))
		c = vGetc ();
	return c;
}
t_token nextToken(void){
    tokenString = "";
    hasTokenSecundario = false;
    // loop do estado inicial para pular os separadores
    while(isspace(nextChar)){
        nextChar = readChar();
    }
    
    if(nextChar == EOF){
        token = ENDFILE;
        return token;
    }
    
    if( isalpha(nextChar) ){
        do {
            tokenString = tokenString + nextChar;
            nextChar = readChar();
        } while( isalnum(nextChar) || nextChar == '_' );
        token = searchKeyWord(tokenString);
        //std::cout << "Read:" << text << ", Token: " << token;
        if(token == IDT){
            tokenSecundario = searchName(tokenString);
            hasTokenSecundario = true;
            //std::cout << ", Token Secundario IDT " << tokenSecundario << std::endl;
        }
        else{
            //std::cout << std::endl;
        }
    }
    else if( isdigit(nextChar) ){
        char numeral[MAX_NUM_LEN+1];
        int i = 0;
        //std::cout << "Read: ";
        do{
            tokenString = tokenString + nextChar;
            numeral[i++] = nextChar;
            //std::cout << nextChar;
            nextChar = readChar();
        }while( isdigit(nextChar) );
        numeral[i] = '\0';
        token = NUMERAL;
        //std::cout << ", Token: " << token;
        tokenSecundario = addIntConst(atoi(numeral));
        hasTokenSecundario = true;
        //std::cout << ", Token Secundario Const: " << tokenSecundario << std::endl;
    } else if( nextChar == '"' ){
        tokenString = "";
        nextChar = readChar();
        while(nextChar != '"'){
            tokenString += nextChar;
            nextChar = readChar();
        }
        token = STRINGVAL;
        char* cstr = new char[tokenString.size()+1];
        memcpy(cstr, tokenString.c_str(), tokenString.size()+1);
        tokenSecundario = addStringConst(cstr);
        hasTokenSecundario = true;
        nextChar = readChar();
        //std::cout << "Read: " << tokenString << ", Token: " << token << ", Token Secundario Const: " << tokenSecundario << std::endl;
    }else if( nextChar == '\''){
        nextChar = readChar();
        tokenString = nextChar;
        token = CHARACTER;
        tokenSecundario = addCharConst(nextChar);
        hasTokenSecundario = true;
        //std::cout << "Read: " << '\'' << nextChar << '\'' << ", Token: " << token << ", Token Secundario Const: " << tokenSecundario << std::endl;
        nextChar = readChar(); //pular o '
        nextChar = readChar();
    }
    else{ //SIMBOLOS
        //std::cout << "Read: " << nextChar;
        tokenString = nextChar;
        switch(nextChar){
            case ':':
                nextChar = readChar();
                token = COLON;
                break;
            case ';':
                nextChar = readChar();
                token = SEMI_COLON;
                break;
            case ',':
                nextChar = readChar();
                token = COMMA;
                break;
            case '[':
                nextChar = readChar();
                token = LEFT_SQUARE;
                break;
            case ']':
                nextChar = readChar();
                token = RIGHT_SQUARE;
                break;
            case '{':
                nextChar = readChar();
                token = LEFT_BRACES;
                break;
            case '}':
                nextChar = readChar();
                token = RIGHT_BRACES;
                break;
            case '(':
                nextChar = readChar();
                token = LEFT_PARENTHESIS;
                break;
            case ')':
                nextChar = readChar();
                token = RIGHT_PARENTHESIS;
                break;
            case '&':
                nextChar = readChar();
                if(nextChar == '&'){
                    tokenString += nextChar;
                    token = AND;
                    nextChar = readChar();
                }
                else{
                    token = UNKNOWN;
                }
                break;
            case '|':
                nextChar = readChar();
                if(nextChar == '|'){
                    tokenString += nextChar;
                    token = OR;
                    nextChar = readChar();
                }
                else{
                    token = UNKNOWN;
                }
                break;
            case '=':
                nextChar = readChar();
                if( nextChar == '=' )
                {
                    tokenString += nextChar;
                    token = EQUAL_EQUAL;
                    nextChar = readChar();
                } else {
                    token = EQUALS;
                } break;
            case '<':
                nextChar = readChar();
                if( nextChar == '=' )
                {
                    tokenString += nextChar;
                    token = LESS_OR_EQUAL;
                    nextChar = readChar();
                } else {
                    token = LESS_THAN;
                } break;
            case '>':
                nextChar = readChar();
                if( nextChar == '=' )
                {
                    tokenString += nextChar;
                    token = GREATER_OR_EQUAL;
                    nextChar = readChar();
                } else {
                    token = GREATER_THAN;
                } break;
            case '!':
                nextChar = readChar();
                if( nextChar == '=' )
                {
                    tokenString += nextChar;
                    token = NOT_EQUAL;
                    nextChar = readChar();
                } else {
                    token = NOT;
                } break;
            case '+':
                nextChar = readChar();
                if( nextChar == '+' )
                {
                    tokenString += nextChar;
                    token = PLUS_PLUS;
                    nextChar = readChar();
                } else {
                    token = PLUS;
                } break;
            case '-':
                nextChar = readChar();
                if( nextChar == '-' )
                {
                    tokenString += nextChar;
                    token = MINUS_MINUS;
                    nextChar = readChar();
                } else {
                    token = MINUS;
                } break;
            case '*':
                nextChar = readChar();
                token = TIMES;
                break;
            case '/':
                nextChar = readChar();
                token = DIVIDE;
                break;
            case '.':
                nextChar = readChar();
                token = DOT;
                break;
            default:
                token = UNKNOWN;
        }
        //std::cout << ", Token: " << token << std::endl;
    }
    
    return token;
}
Ejemplo n.º 4
0
char * skip_whitespace (const char *p) {
    while (isspace((unsigned char)*p)) p++;
    return (char *)p;
}
Ejemplo n.º 5
0
int tokenize (Basrec_type *node, char *text, int casemode, int colmode)
{
	int tex = 0, j, k, eol, len, found, quantity, curr_list = 0, search;
	char casetext [MAXLINE];
	unsigned char byte;
	static unsigned int prev_line = 0, line_num = 0;
	static int cont = FALSE, comment = FALSE, quote = FALSE;
	static int tok = 0;
	Keyword_type *kw;

	if (node == BASREC_NULL)
	{
		prev_line = 0;
		tok = 0; quote = FALSE; comment = FALSE;
		return FALSE;
	}

	eol = strlen (text);

	if (colmode)
		if (isdigit (text [0]))
		{
			cont = FALSE;

			if (quote)
				fprintf (stderr, "\n%s: missing close quote on line %u\n",
				program, line_num);
		}
		else
		{
			cont = TRUE;
			if (tex < eol) tex ++;

			if (text [0] && ! isspace (text [0]))
				fprintf (stderr, "\n%s: invalid char in col 1 on line %u\n",
				program, line_num);
		}

		if (cont)
		{
			cont = FALSE;

			if (colmode && tok < MAXTOKENLINE - 1)
				node -> tokenline [tok ++] = ' ';
		}
		else
		{
			if (sscanf (text, "%d", &line_num) != 1)
				return FALSE;

			if (prev_line && line_num <= prev_line)
			{
				fprintf (stderr, "\n%s: line numbers not sorted.", program);
				fprintf (stderr, " Previous = %u, Current = %u.\n", prev_line,
					line_num);
				fprintf (stderr, "Do you need the \"%s\" or the \"%s\" option?\n",
					cmds [MULT].command, cmds [COL].command);
				exit (EXITBAD);
			}

			tok = 0; quote = FALSE; comment = FALSE;
			prev_line = line_num;
			node -> line_num.whole_addy = line_num;
			while (tex < eol && isspace (text [tex])) tex ++;
			while (tex < eol && isdigit (text [tex])) tex ++;
		}

		if (colmode) cont = TRUE;

		if (text [eol - 1] == '\\')
		{
			cont = TRUE; eol --;
		}

		while (tex < eol && isspace (text [tex])) tex ++;
		for (j = tex; j < eol; j++) casetext [j] = tolower (text [j]);
		casetext [j] = 0;

		while (tex < eol && tok < MAXTOKENLINE - 1)
		{
			if (comment)
			{
				if (! casemode && isupper (text [tex]))
					node -> tokenline [tok] = text [tex];
				else if (islower (text [tex]))
					node -> tokenline [tok] = toupper (text [tex]);
				else if (isupper (text [tex]))
					node -> tokenline [tok] = tolower (text [tex]);
				else
					node -> tokenline [tok] = text [tex];
				tex ++;
			}
			else /* not comment mode */
			{
				curr_list = 0;
				if (quote) kw = special; /* display code replacement */
				else kw = kw_list [curr_list]; /* basic keywords */
				k = 0;
				found = FALSE;
				quantity = FALSE;
				search = TRUE;

				while (search) /* search thru lists of keyword lists */
				{
					/* search thru current keyword list */
					while (! found && kw [k].keyword [0])
						if (eol - tex + 1 >= (len = strlen (kw [k].keyword))
							&& ! strncmp (&(casetext [tex]), kw [k].keyword, len))
							found = TRUE;
						else k ++;

						if (quote || found || kw_list [curr_list + 1] == KW_NULL)
							search = FALSE;
						else
						{
							curr_list ++;
							kw = kw_list [curr_list];
						}
				}

				if (quote && ! found)
				{
					k = 0;

					/* look for partial keywords that may be followed by quantity */
					while (! quantity && kw [k].keyword [0])
						if (eol - tex + 1 >= (len = strlen (kw [k].keyword) - 1)
							&& ! strncmp (& (casetext [tex]), kw [k].keyword, len))
							quantity = TRUE;
						else k ++;
				}

				if (found)
				{
					if (! strcmp (kw [k].keyword, COMT_WORD)) comment = TRUE;
					node -> tokenline [tok] = kw [k].token;
					tex += len;
				}
				else if (quantity)
				{
					if (! tok_quantity (kw [k].token, text, &tex, len,
						node -> tokenline, &tok)) exit_illeg_subs (line_num, tex);
					tex ++;
				}
				else /* keyword not found */
				{
					if (text [tex] == '\"') quote = (quote ? FALSE : TRUE);

					if (quote)
					{
						if (! casemode && isupper (text [tex]))
							node -> tokenline [tok] = text [tex];
						else if (islower (text [tex]))
							node -> tokenline [tok] = toupper (text [tex]);
						else if (isupper (text [tex]))
							node -> tokenline [tok] = tolower (text [tex]);
						else if (text [tex] == '{')
						{
							byte = get_deci_byte (text, tex + 1, MAXLINE - 1);

							if (! byte || ! tok_quantity (byte, text, &tex,
								MAXDECIM, node -> tokenline, &tok))
								exit_illeg_subs (line_num, tex);
						}
						else
							node -> tokenline [tok] = text [tex];
					}
					else /* not quote mode */
					{
						if (islower (text [tex]))
							node -> tokenline [tok] = toupper (text [tex]);
						else
							node -> tokenline [tok] = text [tex];
					}

					tex ++;
				}
			} /* end not comment mode */

			tok++;
		} /* end while not eol */

		if (tok < MAXTOKENLINE) node -> tokenline [tok] = 0;
		else
		{
			node -> tokenline [MAXTOKENLINE - 1] = 0;
			fprintf (stderr, "\n%s: line %u is too long.\n", program, line_num);
		}

		if (cont) return FALSE;
		else if (quote)
		{
			fprintf (stderr, "\n%s: missing close quote on line %u\n",
				program, node -> line_num.whole_addy);
			return FALSE;
		}
		else return TRUE;
} /* end tokenize */
/**********************************************************************
* %FUNCTION: parse_config_file
* %ARGUMENTS:
*  es -- event selector
*  fname -- filename to parse
* %RETURNS:
*  -1 on error, 0 if all is OK
* %DESCRIPTION:
*  Parses configuration file.
***********************************************************************/
int
l2tp_parse_config_file(EventSelector *es,
		       char const *fname)
{
    char buf[512];
    char name[512];
    char value[512];
    int r = 0;
    size_t l;
    char *line;
    FILE *fp;

    /* Defaults */
    Settings.listen_port = 1701;

    if (!fname || !*fname)
	return 0;

    fp = fopen(fname, "r");
    if (!fp) {
	l2tp_set_errmsg("Could not open '%s' for reading: %s",
		   fname, strerror(errno));
	return -1;
    }

    /* Start in global context */
    option_context_fn = NULL;
    while (fgets(buf, sizeof(buf), fp) != NULL) {
	l = strlen(buf);
	if (l && (buf[l] == '\n')) {
	    buf[l--] = 0;
	}

	/* Skip leading whitespace */
	line = buf;
	while(*line && isspace(*line)) line++;

	/* Ignore blank lines and comments */
	if (!*line || *line == '#') {
	    continue;
	}

	/* Split line into two words */
	split_line_into_words(line, name, value);

	/* Check for context switch */
	if (!strcasecmp(name, "global") ||
	    !strcasecmp(name, "section")) {
	    r = parser_switch_context(es, name, value);
	    if (r < 0) break;
	    continue;
	}

	r = handle_option(es, name, value);
	if (r < 0) break;
    }
    fclose(fp);
    if (r >= 0) {
	if (option_context_fn) {
	    r = option_context_fn(es, "*end*", "*end*");
	    option_context_fn = NULL;
	}
    }

    return r;
}
Ejemplo n.º 7
0
    bool isNumber(string s) {
        if (s.empty()) return false;
        int i = 0;
        while(isspace(s[i])) {
            i++;
        }
            
        if (s[i] == '+' || s[i] == '-') {
            i++;
        }
            
        bool eAppear = false;
        bool dotAppear = false;
        bool firstPart = false;
        bool secondPart = false;
        bool spaceAppear = false;

        while(s[i] != '\0') {
            if (s[i] == '.') {
                if (dotAppear || eAppear || spaceAppear) {
                    return false;
                } else {
                    dotAppear = true;
                }
            } else if (s[i] == 'e' || s[i] == 'E') {
                if (eAppear || !firstPart || spaceAppear) {
                    return false;
                } else {
                    eAppear = true;
                }
            } else if (isdigit(s[i])) {
                if (spaceAppear) {
                    return false;
                }
   
                if (!eAppear) {
                    firstPart = true;
                } else {
                    secondPart = true;
                }
            } else if (s[i] == '+' || s[i] == '-') {
                if (spaceAppear) {
                    return false;
                }

                if (!eAppear || !(s[i - 1] == 'e' || s[i - 1] == 'E')) {
                    return false;
                }
            } else if (isspace(s[i])) {
                spaceAppear = true;
            } else {
                return false;
            }
            i++;            
        }
        
        if (!firstPart) {
            return false;
        } else if (eAppear && !secondPart) {
            return false;
        } else {
            return true;
        }
    }
Ejemplo n.º 8
0
/* This function has to be reachable by res_data.c but not publically. */
int
__res_vinit(res_state statp, int preinit) {
	register FILE *fp;
	register char *cp, **pp;
	register int n;
	char buf[BUFSIZ];
	int nserv = 0;    /* number of nameserver records read from file */
#ifdef _LIBC
	int nservall = 0; /* number of NS records read, nserv IPv4 only */
#endif
	int haveenv = 0;
	int havesearch = 0;
#ifdef RESOLVSORT
	int nsort = 0;
	char *net;
#endif
#ifndef RFC1535
	int dots;
#endif

	if (!preinit) {
		statp->retrans = RES_TIMEOUT;
		statp->retry = RES_DFLRETRY;
		statp->options = RES_DEFAULT;
		statp->id = res_randomid();
	}

#ifdef USELOOPBACK
	statp->nsaddr.sin_addr = inet_makeaddr(IN_LOOPBACKNET, 1);
#else
	statp->nsaddr.sin_addr.s_addr = INADDR_ANY;
#endif
	statp->nsaddr.sin_family = AF_INET;
	statp->nsaddr.sin_port = htons(NAMESERVER_PORT);
	statp->nscount = 1;
	statp->ndots = 1;
	statp->pfcode = 0;
	statp->_vcsock = -1;
	statp->_flags = 0;
	statp->qhook = NULL;
	statp->rhook = NULL;
	statp->_u._ext.nsinit = 0;
	statp->_u._ext.nscount = 0;
#ifdef _LIBC
	statp->_u._ext.nscount6 = 0;
	for (n = 0; n < MAXNS; n++)
	    statp->_u._ext.nsaddrs[n] = NULL;
#endif

	/* Allow user to override the local domain definition */
	if ((cp = getenv("LOCALDOMAIN")) != NULL) {
		(void)strncpy(statp->defdname, cp, sizeof(statp->defdname) - 1);
		statp->defdname[sizeof(statp->defdname) - 1] = '\0';
		haveenv++;

		/*
		 * Set search list to be blank-separated strings
		 * from rest of env value.  Permits users of LOCALDOMAIN
		 * to still have a search list, and anyone to set the
		 * one that they want to use as an individual (even more
		 * important now that the rfc1535 stuff restricts searches)
		 */
		cp = statp->defdname;
		pp = statp->dnsrch;
		*pp++ = cp;
		for (n = 0; *cp && pp < statp->dnsrch + MAXDNSRCH; cp++) {
			if (*cp == '\n')	/* silly backwards compat */
				break;
			else if (*cp == ' ' || *cp == '\t') {
				*cp = 0;
				n = 1;
			} else if (n) {
				*pp++ = cp;
				n = 0;
				havesearch = 1;
			}
		}
		/* null terminate last domain if there are excess */
		while (*cp != '\0' && *cp != ' ' && *cp != '\t' && *cp != '\n')
			cp++;
		*cp = '\0';
		*pp++ = 0;
	}

#define	MATCH(line, name) \
	(!strncmp(line, name, sizeof(name) - 1) && \
	(line[sizeof(name) - 1] == ' ' || \
	 line[sizeof(name) - 1] == '\t'))

	if ((fp = fopen(_PATH_RESCONF, "r")) != NULL) {
		/* No threads use this stream.  */
		__fsetlocking (fp, FSETLOCKING_BYCALLER);
	    /* read the config file */
	    while (fgets_unlocked(buf, sizeof(buf), fp) != NULL) {
		/* skip comments */
		if (*buf == ';' || *buf == '#')
			continue;
		/* read default domain name */
		if (MATCH(buf, "domain")) {
		    if (haveenv)	/* skip if have from environ */
			    continue;
		    cp = buf + sizeof("domain") - 1;
		    while (*cp == ' ' || *cp == '\t')
			    cp++;
		    if ((*cp == '\0') || (*cp == '\n'))
			    continue;
		    strncpy(statp->defdname, cp, sizeof(statp->defdname) - 1);
		    statp->defdname[sizeof(statp->defdname) - 1] = '\0';
		    if ((cp = strpbrk(statp->defdname, " \t\n")) != NULL)
			    *cp = '\0';
		    havesearch = 0;
		    continue;
		}
		/* set search list */
		if (MATCH(buf, "search")) {
		    if (haveenv)	/* skip if have from environ */
			    continue;
		    cp = buf + sizeof("search") - 1;
		    while (*cp == ' ' || *cp == '\t')
			    cp++;
		    if ((*cp == '\0') || (*cp == '\n'))
			    continue;
		    strncpy(statp->defdname, cp, sizeof(statp->defdname) - 1);
		    statp->defdname[sizeof(statp->defdname) - 1] = '\0';
		    if ((cp = strchr(statp->defdname, '\n')) != NULL)
			    *cp = '\0';
		    /*
		     * Set search list to be blank-separated strings
		     * on rest of line.
		     */
		    cp = statp->defdname;
		    pp = statp->dnsrch;
		    *pp++ = cp;
		    for (n = 0; *cp && pp < statp->dnsrch + MAXDNSRCH; cp++) {
			    if (*cp == ' ' || *cp == '\t') {
				    *cp = 0;
				    n = 1;
			    } else if (n) {
				    *pp++ = cp;
				    n = 0;
			    }
		    }
		    /* null terminate last domain if there are excess */
		    while (*cp != '\0' && *cp != ' ' && *cp != '\t')
			    cp++;
		    *cp = '\0';
		    *pp++ = 0;
		    havesearch = 1;
		    continue;
		}
		/* read nameservers to query */
#ifdef _LIBC
		if (MATCH(buf, "nameserver") && nservall < MAXNS) {
#else
		if (MATCH(buf, "nameserver") && nserv < MAXNS) {
#endif
		    struct in_addr a;

		    cp = buf + sizeof("nameserver") - 1;
		    while (*cp == ' ' || *cp == '\t')
			cp++;
		    if ((*cp != '\0') && (*cp != '\n')
			&& __inet_aton(cp, &a)) {
			statp->nsaddr_list[nserv].sin_addr = a;
			statp->nsaddr_list[nserv].sin_family = AF_INET;
			statp->nsaddr_list[nserv].sin_port =
				htons(NAMESERVER_PORT);
			nserv++;
#ifdef _LIBC
			nservall++;
                    } else {
                        struct in6_addr a6;
                        char *el;

                        if ((el = strchr(cp, '\n')) != NULL)
                            *el = '\0';
                        if ((*cp != '\0') &&
                            (inet_pton(AF_INET6, cp, &a6) > 0)) {
                            struct sockaddr_in6 *sa6;

                            sa6 = malloc(sizeof(*sa6));
                            if (sa6 != NULL) {
                                sa6->sin6_addr = a6;
                                sa6->sin6_family = AF_INET6;
                                sa6->sin6_port = htons(NAMESERVER_PORT);
				statp->_u._ext.nsaddrs[nservall] = sa6;
				statp->_u._ext.nstimes[nservall] = RES_MAXTIME;
				statp->_u._ext.nssocks[nservall] = -1;
                                nservall++;
                            }
                        }
#endif
		    }
		    continue;
		}
#ifdef RESOLVSORT
		if (MATCH(buf, "sortlist")) {
		    struct in_addr a;

		    cp = buf + sizeof("sortlist") - 1;
		    while (nsort < MAXRESOLVSORT) {
			while (*cp == ' ' || *cp == '\t')
			    cp++;
			if (*cp == '\0' || *cp == '\n' || *cp == ';')
			    break;
			net = cp;
			while (*cp && !ISSORTMASK(*cp) && *cp != ';' &&
			       isascii(*cp) && !isspace(*cp))
				cp++;
			n = *cp;
			*cp = 0;
			if (__inet_aton(net, &a)) {
			    statp->sort_list[nsort].addr = a;
			    if (ISSORTMASK(n)) {
				*cp++ = n;
				net = cp;
				while (*cp && *cp != ';' &&
					isascii(*cp) && !isspace(*cp))
				    cp++;
				n = *cp;
				*cp = 0;
				if (__inet_aton(net, &a)) {
				    statp->sort_list[nsort].mask = a.s_addr;
				} else {
				    statp->sort_list[nsort].mask =
					net_mask(statp->sort_list[nsort].addr);
				}
			    } else {
				statp->sort_list[nsort].mask =
				    net_mask(statp->sort_list[nsort].addr);
			    }
			    nsort++;
			}
			*cp = n;
		    }
		    continue;
		}
#endif
		if (MATCH(buf, "options")) {
		    res_setoptions(statp, buf + sizeof("options") - 1, "conf");
		    continue;
		}
	    }
	    if (nserv > 1)
		statp->nscount = nserv;
#ifdef _LIBC
	    if (nservall - nserv > 0)
		statp->_u._ext.nscount6 = nservall - nserv;
#endif
#ifdef RESOLVSORT
	    statp->nsort = nsort;
#endif
	    (void) fclose(fp);
	}
	if (statp->defdname[0] == 0 &&
	    __gethostname(buf, sizeof(statp->defdname) - 1) == 0 &&
	    (cp = strchr(buf, '.')) != NULL)
		strcpy(statp->defdname, cp + 1);

	/* find components of local domain that might be searched */
	if (havesearch == 0) {
		pp = statp->dnsrch;
		*pp++ = statp->defdname;
		*pp = NULL;

#ifndef RFC1535
		dots = 0;
		for (cp = statp->defdname; *cp; cp++)
			dots += (*cp == '.');

		cp = statp->defdname;
		while (pp < statp->dnsrch + MAXDFLSRCH) {
			if (dots < LOCALDOMAINPARTS)
				break;
			cp = __rawmemchr(cp, '.') + 1;    /* we know there is one */
			*pp++ = cp;
			dots--;
		}
		*pp = NULL;
#ifdef DEBUG
		if (statp->options & RES_DEBUG) {
			printf(";; res_init()... default dnsrch list:\n");
			for (pp = statp->dnsrch; *pp; pp++)
				printf(";;\t%s\n", *pp);
			printf(";;\t..END..\n");
		}
#endif
#endif /* !RFC1535 */
	}

	if ((cp = getenv("RES_OPTIONS")) != NULL)
		res_setoptions(statp, cp, "env");
	statp->options |= RES_INIT;
	return (0);
}

static void
internal_function
res_setoptions(res_state statp, const char *options, const char *source) {
	const char *cp = options;
	int i;

#ifdef DEBUG
	if (statp->options & RES_DEBUG)
		printf(";; res_setoptions(\"%s\", \"%s\")...\n",
		       options, source);
#endif
	while (*cp) {
		/* skip leading and inner runs of spaces */
		while (*cp == ' ' || *cp == '\t')
			cp++;
		/* search for and process individual options */
		if (!strncmp(cp, "ndots:", sizeof("ndots:") - 1)) {
			i = atoi(cp + sizeof("ndots:") - 1);
			if (i <= RES_MAXNDOTS)
				statp->ndots = i;
			else
				statp->ndots = RES_MAXNDOTS;
#ifdef DEBUG
			if (statp->options & RES_DEBUG)
				printf(";;\tndots=%d\n", statp->ndots);
#endif
		} else if (!strncmp(cp, "timeout:", sizeof("timeout:") - 1)) {
			i = atoi(cp + sizeof("timeout:") - 1);
			if (i <= RES_MAXRETRANS)
				statp->retrans = i;
			else
				statp->retrans = RES_MAXRETRANS;
		} else if (!strncmp(cp, "attempts:", sizeof("attempts:") - 1)){
			i = atoi(cp + sizeof("attempts:") - 1);
			if (i <= RES_MAXRETRY)
				statp->retry = i;
			else
				statp->retry = RES_MAXRETRY;
		} else if (!strncmp(cp, "debug", sizeof("debug") - 1)) {
#ifdef DEBUG
			if (!(statp->options & RES_DEBUG)) {
				printf(";; res_setoptions(\"%s\", \"%s\")..\n",
				       options, source);
				statp->options |= RES_DEBUG;
			}
			printf(";;\tdebug\n");
#endif
		} else if (!strncmp(cp, "inet6", sizeof("inet6") - 1)) {
			statp->options |= RES_USE_INET6;
		} else if (!strncmp(cp, "rotate", sizeof("rotate") - 1)) {
			statp->options |= RES_ROTATE;
		} else if (!strncmp(cp, "no-check-names",
				    sizeof("no-check-names") - 1)) {
			statp->options |= RES_NOCHECKNAME;
		} else {
			/* XXX - print a warning here? */
		}
		/* skip to next run of spaces */
		while (*cp && *cp != ' ' && *cp != '\t')
			cp++;
	}
}

#ifdef RESOLVSORT
/* XXX - should really support CIDR which means explicit masks always. */
static u_int32_t
net_mask(in)		/* XXX - should really use system's version of this */
	struct in_addr in;
{
	register u_int32_t i = ntohl(in.s_addr);

	if (IN_CLASSA(i))
		return (htonl(IN_CLASSA_NET));
	else if (IN_CLASSB(i))
		return (htonl(IN_CLASSB_NET));
	return (htonl(IN_CLASSC_NET));
}
#endif

u_int
res_randomid(void) {
	struct timeval now;

	__gettimeofday(&now, NULL);
	return (0xffff & (now.tv_sec ^ now.tv_usec ^ __getpid()));
}

/*
 * This routine is for closing the socket if a virtual circuit is used and
 * the program wants to close it.  This provides support for endhostent()
 * which expects to close the socket.
 *
 * This routine is not expected to be user visible.
 */
void
res_nclose(res_state statp) {
	int ns;

	if (statp->_vcsock >= 0) {
		(void) __close(statp->_vcsock);
		statp->_vcsock = -1;
		statp->_flags &= ~(RES_F_VC | RES_F_CONN);
	}
#ifdef _LIBC
	for (ns = 0; ns < statp->_u._ext.nscount + statp->_u._ext.nscount6;
	     ns++)
#else
	for (ns = 0; ns < statp->_u._ext.nscount; ns++)
#endif
	{
		if (statp->_u._ext.nssocks[ns] != -1) {
			(void) __close(statp->_u._ext.nssocks[ns]);
			statp->_u._ext.nssocks[ns] = -1;
		}
	}
	statp->_u._ext.nsinit = 0;
}
Ejemplo n.º 9
0
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   R e a d V I C A R I m a g e                                               %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ReadVICARImage() reads a VICAR image file and returns it.  It
%  allocates the memory necessary for the new Image structure and returns a
%  pointer to the new image.
%
%  The format of the ReadVICARImage method is:
%
%      Image *ReadVICARImage(const ImageInfo *image_info,
%        ExceptionInfo *exception)
%
%  A description of each parameter follows:
%
%    o image: Method ReadVICARImage returns a pointer to the image after
%      reading.  A null image is returned if there is a memory shortage or if
%      the image cannot be read.
%
%    o image_info: The image info.
%
%    o exception: return any errors or warnings in this structure.
%
%
*/
static Image *ReadVICARImage(const ImageInfo *image_info,
  ExceptionInfo *exception)
{
  char
    keyword[MaxTextExtent],
    value[MaxTextExtent];

  Image
    *image;

  int
    c;

  long
    y;

  MagickBooleanType
    status,
    value_expected;

  QuantumInfo
    quantum_info;

  register PixelPacket
    *q;

  ssize_t
    count;

  ssize_t
    length;

  unsigned char
    *scanline;

  /*
    Open image file.
  */
  assert(image_info != (const ImageInfo *) NULL);
  assert(image_info->signature == MagickSignature);
  if (image_info->debug != MagickFalse)
    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
      image_info->filename);
  assert(exception != (ExceptionInfo *) NULL);
  assert(exception->signature == MagickSignature);
  image=AllocateImage(image_info);
  status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
  if (status == MagickFalse)
    {
      image=DestroyImageList(image);
      return((Image *) NULL);
    }
  /*
    Decode image header.
  */
  c=ReadBlobByte(image);
  count=1;
  if (c == EOF)
    {
      image=DestroyImage(image);
      return((Image *) NULL);
    }
  length=0;
  image->columns=0;
  image->rows=0;
  while (isgraph(c) && ((image->columns == 0) || (image->rows == 0)))
  {
    if (isalnum(c) == MagickFalse)
      {
        c=ReadBlobByte(image);
        count++;
      }
    else
      {
        register char
          *p;

        /*
          Determine a keyword and its value.
        */
        p=keyword;
        do
        {
          if ((size_t) (p-keyword) < (MaxTextExtent/2))
            *p++=c;
          c=ReadBlobByte(image);
          count++;
        } while (isalnum(c) || (c == '_'));
        *p='\0';
        value_expected=MagickFalse;
        while ((isspace((int) ((unsigned char) c)) != 0) || (c == '='))
        {
          if (c == '=')
            value_expected=MagickTrue;
          c=ReadBlobByte(image);
          count++;
        }
        if (value_expected == MagickFalse)
          continue;
        p=value;
        while (isalnum(c))
        {
          if ((size_t) (p-value) < (MaxTextExtent/2))
            *p++=c;
          c=ReadBlobByte(image);
          count++;
        }
        *p='\0';
        /*
          Assign a value to the specified keyword.
        */
        if (LocaleCompare(keyword,"Label_RECORDS") == 0)
          length=(ssize_t) atol(value);
        if (LocaleCompare(keyword,"LBLSIZE") == 0)
          length=(ssize_t) atol(value);
        if (LocaleCompare(keyword,"RECORD_BYTES") == 0)
          image->columns=1UL*atol(value);
        if (LocaleCompare(keyword,"NS") == 0)
          image->columns=1UL*atol(value);
        if (LocaleCompare(keyword,"LINES") == 0)
          image->rows=1UL*atol(value);
        if (LocaleCompare(keyword,"NL") == 0)
          image->rows=1UL*atol(value);
      }
    while (isspace((int) ((unsigned char) c)) != 0)
    {
      c=ReadBlobByte(image);
      count++;
    }
  }
  while (count < (ssize_t) length)
  {
    c=ReadBlobByte(image);
    count++;
  }
  if ((image->columns == 0) || (image->rows == 0))
    ThrowReaderException(CorruptImageError,"NegativeOrZeroImageSize");
  image->depth=8;
  if (AllocateImageColormap(image,256) == MagickFalse)
    ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
  if (image_info->ping != MagickFalse)
    {
      CloseBlob(image);
      return(GetFirstImageInList(image));
    }
  /*
    Read VICAR pixels.
  */
  if (SetImageExtent(image,0,0) == MagickFalse)
    {
      InheritException(exception,&image->exception);
      return(DestroyImageList(image));
    }
  GetQuantumInfo(image_info,&quantum_info);
  scanline=(unsigned char *) AcquireQuantumMemory(image->columns,
    sizeof(*scanline));
  if (scanline == (unsigned char *) NULL)
    ThrowReaderException(CorruptImageError,"UnableToReadImageData");
  for (y=0; y < (long) image->rows; y++)
  {
    q=SetImagePixels(image,0,y,image->columns,1);
    if (q == (PixelPacket *) NULL)
      break;
    count=ReadBlob(image,image->columns,scanline);
    (void) ExportQuantumPixels(image,&quantum_info,GrayQuantum,scanline);
    if (SyncImagePixels(image) == MagickFalse)
      break;
    if ((image->progress_monitor != (MagickProgressMonitor) NULL) &&
        (QuantumTick(y,image->rows) != MagickFalse))
      {
        status=image->progress_monitor(LoadImageTag,y,image->rows,
          image->client_data);
        if (status == MagickFalse)
          break;
      }
  }
  scanline=(unsigned char *) RelinquishMagickMemory(scanline);
  if (EOFBlob(image) != MagickFalse)
    ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
      image->filename);
  CloseBlob(image);
  return(GetFirstImageInList(image));
}
Ejemplo n.º 10
0
Archivo: pgn.c Proyecto: zwegner/zct
/**
pgn_load():
pgn_load loads a specific game from the opened pgn database. The board
position is set to the last position in the game.
Created 091407; last modified 111208
**/
void pgn_load(int game_number, POS_FUNC pos_func, void *pos_arg)
{
	char buffer[BUFSIZ];
	char move_buf[8];
	char flag_buf[8];
	int consumed;
	int braces;
	int x;
	POS_DATA pos_data;
	PGN_GAME *game;
	PGN_STATE state;
	NOTATION old_notation;

	if (pgn_database.game_count == 0)
	{
		print("No database loaded.\n");
		return;
	}
	if (game_number < 1 || game_number > pgn_database.game_count)
	{
		print("Invalid game number: %i. Valid numbers are 1-%i\n",
			game_number, pgn_database.game_count);
		return;
	}
	/* Copy the PGN tags. */
	game = &pgn_database.game[game_number - 1];
	strcpy(pgn_game.tag.event, game->tag.event);
	strcpy(pgn_game.tag.site, game->tag.site);
	strcpy(pgn_game.tag.date, game->tag.date);
	strcpy(pgn_game.tag.round, game->tag.round);
	strcpy(pgn_game.tag.white, game->tag.white);
	strcpy(pgn_game.tag.black, game->tag.black);
	strcpy(pgn_game.tag.result, game->tag.result);
	strcpy(pgn_game.tag.fen, game->tag.fen);
	
	/* Initialize. */
	if (strcmp(pgn_game.tag.fen, "") != 0)
		initialize_board(pgn_game.tag.fen);
	else
		initialize_board(NULL);

	/* Set the engine to force mode. */
	zct->zct_side = EMPTY;
	old_notation = zct->notation;
	/* PGN uses SAN, of course... */
	zct->notation = SAN;

	braces = 0;
	state = NEUTRAL;
	pos_data.type = POS_PGN;
	pos_data.pgn = game;

	/* Find the game in the PGN file and start reading. */
	fseek(pgn_file, game->offset, SEEK_SET);
	while (fgets(buffer, sizeof(buffer), pgn_file))
	{
		switch (state)
		{
			case NEUTRAL:
				/* Stupid macros need an int cast... sigh */
				if (isspace((int)buffer[0]))
					continue;
				state = HEADERS;
			case HEADERS:
				if (buffer[0] == '[')
					continue;
				state = MOVES;
			case MOVES:
				/* Read the next line of input. Strip out all of the
					unneeded characters. */
				set_cmd_input(buffer);
				cmd_parse(" \t.+#\r\n");
				for (x = 0; x < cmd_input.arg_count; x++)
				{
					if (strchr(cmd_input.arg[x], '{'))
						braces++;
					 if (strchr(cmd_input.arg[x], '}'))
						braces--;
					else if (braces == 0)
					{
						/* Pull out any flags in the move string and separate
							them. */
						consumed = sscanf(cmd_input.arg[x], "%8[^?!=]%8[?!=]",
							move_buf, flag_buf);
						if (consumed == 2)
							strcpy(pos_data.flags, flag_buf);
						else
							strcpy(pos_data.flags, "");

						/* Check if we have a valid move. If so, make it
							and call pos_func. */
						if (input_move(move_buf, INPUT_CHECK_MOVE))
						{
							input_move(move_buf, INPUT_USER_MOVE);
							/* Now execute the pos_func, which does any
								processing for this move, for example the book
								making routine which collects statistics. */
							if (pos_func != NULL)
								if (pos_func(pos_arg, &pos_data))
									goto end;
						}
						/* Check for end-of-game. */
						else if (!strcmp(cmd_input.arg[x], "1-0") ||
							!strcmp(cmd_input.arg[x], "0-1") ||
							!strcmp(cmd_input.arg[x], "1/2-1/2") ||
							!strcmp(cmd_input.arg[x], "*"))
							goto end;
					}
				}
		}
	}
	/* Look at the spaghetti code! How unreadable! ;) */
end:
	zct->notation = old_notation;
}
Ejemplo n.º 11
0
Archivo: pgn.c Proyecto: zwegner/zct
/**
pgn_open():
pgn_open opens a .pgn file and reads all games into the internal database.
The number of games found is returned.
Created 091407; last modified 091607
**/
int pgn_open(char *file_name)
{
	char buffer[BUFSIZ];
	char *c;
	char *b;
	int games;
	long last_offset;
	PGN_GAME *game;
	PGN_STATE state;

	/* Try opening the file. */
	if (pgn_file != NULL)
		fclose(pgn_file);
	pgn_file = fopen(file_name, "rt");
	if (pgn_file == NULL)
	{
		print("%s: file not found.\n", file_name);
		return -1;
	}
	/* First, quickly find the number of games. */
	state = NEUTRAL;
	games = 0;
	while (fgets(buffer, BUFSIZ, pgn_file) != NULL)
	{
		switch (state)
		{
			case NEUTRAL:
				/* Stupid macros need an int cast... sigh */
				if (isspace((int)buffer[0]))
					continue;
				state = HEADERS;
			case HEADERS:
				if (buffer[0] == '[')
					continue;
				state = MOVES;
			case MOVES:
				if (strstr(buffer, "1-0") || strstr(buffer, "0-1") ||
					strstr(buffer, "1/2-1/2") || strstr(buffer, "*"))
				{
					games++;
					state = NEUTRAL;
				}
		}
	}
	/* Initialize the database. */
	if (pgn_database.game != NULL)
		free(pgn_database.game);
	pgn_database.game_count = games;
	pgn_database.game = calloc(games, sizeof(PGN_GAME));
	print("%i games loaded.\n", games);
	/* Read in all of the games. */
	state = NEUTRAL;
	rewind(pgn_file);
	last_offset = 0;
	game = &pgn_database.game[0];
	while (fgets(buffer, BUFSIZ, pgn_file))
	{
		switch (state)
		{
			case NEUTRAL:
				/* Stupid macros need an int cast... sigh */
				if (isspace((int)buffer[0]))
					continue;
				game->offset = last_offset;
				state = HEADERS;
			case HEADERS:
				if (buffer[0] == '[')
				{
					c = strtok(buffer, "\"");
					if (c == NULL)
						continue;
					c = strtok(buffer + strlen(c) + 1, "\"");
					if (c == NULL)
						continue;
					b = strtok(buffer + 1, " =\"");
					if (!strcmp(b, "Event"))
						strcpy(game->tag.event, c);
					if (!strcmp(b, "Site"))
						strcpy(game->tag.site, c);
					if (!strcmp(b, "Date"))
						strcpy(game->tag.date, c);
					if (!strcmp(b, "Round"))
						strcpy(game->tag.round, c);
					if (!strcmp(b, "White"))
						strcpy(game->tag.white, c);
					if (!strcmp(b, "Black"))
						strcpy(game->tag.black, c);
					if (!strcmp(b, "Result"))
						strcpy(game->tag.result, c);
					if (!strcmp(b, "FEN"))
					{
						strcpy(game->tag.fen, c);
						initialize_board(c);
					}
					continue;
				}
				state = MOVES;
			case MOVES:
				if (strstr(buffer, "1-0") || strstr(buffer, "0-1") ||
					strstr(buffer, "1/2-1/2") || strstr(buffer, "*"))
				{
					game++;
					state = NEUTRAL;
				}
		}
		last_offset = ftell(pgn_file);
	}
	return games;
}
Ejemplo n.º 12
0
struct cnfnode *parse_route(struct cnfmodule *cm, FILE *fptr)
{
	struct cnfnode *cn_root, *cn_top, *cn;
	struct confline *cl, *cl_root;

	cl_root = read_conflines(fptr);

	cn_root = create_cnfnode("(root)");

	for(cl = cl_root; cl; cl = cl->next){
		const char *p = cl->line;
		char buf[256], *q;
 		char target[256], netmask[256];
		int i;

		while(*p && isspace(*p)) p++;
		if(*p){
			if((strncmp("route", p, 5) == 0) || 
				(strncmp("/sbin/route", p, 11) == 0)) {

				cn_top = create_cnfnode("route");
				append_node(cn_root, cn_top);

				if (*p == '/') {
					p += 11;
				} else {
					p += 5;
				}
				while(*p && isspace(*p)) p++;
				if(!*p) continue;

				p = parse_route_options(cn_top, p);
				if(!*p) continue;

				if(strncmp(p, "add", 3) == 0){
					cn = create_cnfnode("add");
					append_node(cn_top, cn);
					p += 3;
				}else if(strncmp(p, "del", 3) == 0){
					cn = create_cnfnode("del");
					append_node(cn_top, cn);
					p += 3;
				}

				while(*p && isspace(*p)) p++;
				if(!*p) continue;
	
				if(strncmp(p, "-net", 4) == 0){
					cn = create_cnfnode("-net");
					append_node(cn_top, cn);
					p += 4;
				}else if(strncmp(p, "-host", 5) == 0){
					cn = create_cnfnode("-host");
					append_node(cn_top, cn);
					p += 5;
				}

				while(*p && isspace(*p)) p++;
				if(!*p) continue;

				/* get target */
				q = target;
				while(*p && !isspace(*p) && (q < target+255)) *q++ = *p++;
				*q = 0;
	
				while(*p && isspace(*p)) p++;
				if(!*p) continue;
				cn = create_cnfnode("target");
				append_node(cn_top, cn);
				cnfnode_setval(cn, target);

				netmask[0] = 0;
				if(strncmp(p, "netmask", 7) == 0){
					p += 7;
					while(*p && isspace(*p)) p++;
					if(!*p) continue;

					q = netmask;
					while(*p && !isspace(*p) && (q < netmask+255))
						*q++ = *p++;
					*q = 0;

					while(*p && isspace(*p)) p++;
					if(!*p) continue;
				}

				cn = create_cnfnode("netmask");
				append_node(cn_top, cn);
				cnfnode_setval(cn, netmask);
				//if(netmask[0])
				//	snprintf(buf, 256, "%s/%s", target, netmask);
				//else
				//	snprintf(buf, 256, "%s", target);
				//
				//cnfnode_setname(cn_top, buf);

				for(i = 0;
				    i < sizeof(route_options)/sizeof(struct route_options);
				    i++){
					if(strncmp(p, route_options[i].name,
						   strlen(route_options[i].name)) == 0){
						int j;
	    
						cn = create_cnfnode(route_options[i].name);
						append_node(cn_top, cn);
						p += strlen(route_options[i].name);
						while(*p && isspace(*p)) p++;
						if(!*p) break;
	    
						for(j = 0; j < route_options[i].nparams; j++){
							q = buf;
							while(*p && !isspace(*p) &&
							      (q < buf+255)) *q++ = *p++;
							*q = 0;
							cnfnode_setval(cn, buf);
	      
							while(*p && isspace(*p)) p++;
							if(!*p) break;
						}
						if(!*p) break;
					}
				}
				if(!*p) continue;
	
				while(*p && isspace(*p)) p++;
				if(!*p) continue;
	
				q = buf;
				while(*p && !isspace(*p) && (q < buf+255)) *q++ = *p++;
				*q = 0;
				cn = create_cnfnode("dev");
				append_node(cn_top, cn);
				cnfnode_setval(cn, buf);

			}else if(*p == '#'){
				cn = create_cnfnode(".comment");
				cnfnode_setval(cn, dup_next_line_b(&p, buf, 255));
				append_node(cn_root, cn);
			}
		}else{
			cn = create_cnfnode(".empty");
			cnfnode_setval(cn, "");
			append_node(cn_root, cn);
		}
	}
	destroy_confline_list(cl_root);
	return cn_root;
}
Ejemplo n.º 13
0
	bool isWhitespace() const
	{
		return isspace((int)_ch) > 0;
	}
Ejemplo n.º 14
0
/*
 * Converts a zone file representation in a string to an RDATA
 * on-the-wire representation.
 */
int loc_aton (const char *ascii, u_char *binary)
{
  char *cp, *maxcp;
  BYTE *bcp;
  DWORD latit     = 0, longit  = 0, alt = 0;
  DWORD lltemp1   = 0, lltemp2 = 0;
  int   altmeters = 0;
  int   altfrac   = 0;
  int   altsign   = 1;
  BYTE  hp        = 0x16;   /* default = 1e6 cm = 10000.00m = 10km */
  BYTE  vp        = 0x13;   /* default = 1e3 cm = 10.00m           */
  BYTE  siz       = 0x12;   /* default = 1e2 cm = 1.00m            */
  int   which1    = 0;
  int   which2    = 0;

  cp    = (char*)ascii;
  maxcp = cp + strlen (ascii);

  lltemp1 = latlon2ul (&cp, &which1);
  lltemp2 = latlon2ul (&cp, &which2);

  switch (which1 + which2)
  {
    case 3:                 /* 1 + 2, the only valid combination */
         if (which1 == 1 && which2 == 2)  /* normal case */
         {
           latit  = lltemp1;
           longit = lltemp2;
         }
         else if (which1 == 2 && which2 == 1) /* reversed */
         {
           longit = lltemp1;
           latit  = lltemp2;
         }
         else               /* some kind of brokenness */
           return (0);
         break;
    default:                /* we didn't get one of each */
         return (0);
  }

  /* altitude */
  if (*cp == '-')
  {
    altsign = -1;
    cp++;
  }

  if (*cp == '+')
     ++cp;

  while (isdigit(*cp))
     altmeters = altmeters * 10 + (*cp++ - '0');

  if (*cp == '.')                /* decimal meters */
  {
    cp++;
    if (isdigit(*cp))
    {
      altfrac = (*cp++ - '0') * 10;
      if (isdigit(*cp))
         altfrac += (*cp++ - '0');
    }
  }

  alt = (10000000 + (altsign * (altmeters * 100 + altfrac)));

  while (!isspace(*cp) && (cp < maxcp))
     cp++;                /* if trailing garbage or m */

  while (isspace(*cp) && (cp < maxcp))
     cp++;

  if (cp >= maxcp)
     goto defaults;

  siz = precsize_aton (&cp);

  while (!isspace(*cp) && (cp < maxcp)) /* if trailing garbage or m */
     cp++;

  while (isspace(*cp) && (cp < maxcp))
     cp++;

  if (cp >= maxcp)
     goto defaults;

  hp = precsize_aton (&cp);

  while (!isspace(*cp) && (cp < maxcp)) /* if trailing garbage or m */
     cp++;

  while (isspace(*cp) && (cp < maxcp))
     cp++;

  if (cp >= maxcp)
     goto defaults;

  vp = precsize_aton(&cp);

 defaults:

  bcp = binary;
  *bcp++ = (BYTE) 0;  /* version byte */
  *bcp++ = siz;
  *bcp++ = hp;
  *bcp++ = vp;
  PUTLONG (latit,bcp);
  PUTLONG (longit,bcp);
  PUTLONG (alt,bcp);

  return (16);            /* size of RR in octets */
}
Ejemplo n.º 15
0
void
zpcgetvector(struct zpctoken *token, const char *str, char **retstr)
{
    char             *ptr = (char *)str;
    struct zpctoken **toktab;
    struct zpctoken  *token1;
    long              ndx = 0;
    long              type = 0;
    char             *cp;
    long              sign = 0;

    toktab = malloc(DEFAULTDIM * sizeof(struct zpctoken *));
    ptr++; /* skip the '<' */
    while ((*ptr) && *ptr != '>') {
        while (isspace(*ptr)) {
            ptr++;
        }
        if (*ptr) {
            token1 = calloc(1, sizeof(struct zpctoken));
            if (*ptr == '-') {
                sign = 1;
                ptr++;
            };
            cp = index(ptr, '.');
            if (cp) {
                type = ZPCDOUBLE;
                zpcgetdouble(token1, ptr, &ptr);
            } else {
                if (strstr(ptr, "uU")) {
                    if (sign) {
                        fprintf(stderr, "sign on unsigned number\n");
                        
                        return;
                    }
                }
                if (!type) {
                    if (sign) {
#if (SMARTTYPES)
                        token1->sign = ZPCUSERSIGNED;
#endif
                        type = ZPCINT64;
                    } else {
                        type = ZPCUINT64;
                    }
                }
#if (SMARTTYPES)
                if (type == ZPCUINT64) {
                    zpcgetuint64(token1, ptr, &ptr);
                } else {
                    zpcgetint64(token1, ptr, &ptr);
                }
                if (ZPCUSERSIGNED || token1->data.ui64.u64 <= INT64_MAX) {
                    token1->type = ZPCINT64;
                } else if (!sign) {
                    token1->type = ZPCUINT64;
                }
#else
                token1->type = type;
#endif
            }
            toktab[ndx++] = token1;
        }
        if (*ptr == ',') {
            ptr++;
        }
    }
    token->type = ZPCVECTOR;
    token->data.vector.ndim = ndx;
    token->data.vector.toktab = toktab;
    *retstr = ptr;

    return;
};
Ejemplo n.º 16
0
int str2args(const char *line, char ***argv_ret)
{
    int line_i, arg_i;      /* Index into line and current argument */
    int argv_size = 10;     /* Initial # of allocated args */
    int arg_size;           /* Allocated size of the curr arg */
    char **argv;
    int argc;
    enum str2args_parse_state state = PARSE_STATE_IN_SPACE;
    const size_t line_len = strlen(line);


    argc = arg_i = 0;
    argv = (char **)malloc(argv_size * sizeof(char *));
    if (!argv) {
        return -1;
    }

    zero_argvs(0, argv_size - 1, argv);
    arg_size = 0;
    line_i = 0;

    while ((size_t)line_i < line_len && state != PARSE_STATE_ERROR) {
        switch (state) {
            case PARSE_STATE_IN_SPACE:
                /* Found the start of the next argument */
                if (!isspace(line[line_i])) {
                    state = PARSE_STATE_START_ARG;
                } else {
                    /* Gobble up space */
                    line_i++;
                }
                break;

            case PARSE_STATE_START_ARG:
                /* Increase size of argv, if needed */
                if (argc >= argv_size) {
                    void *tmp;
                    argv_size = argv_size + argv_size / 2;
                    tmp = realloc(argv, argv_size);

                    if (tmp) {
                        argv = (char **)tmp;
                        zero_argvs(argc, argv_size - 1, argv);
                    } else {
                        state = PARSE_STATE_ERROR;
                    }
                }

                /* Record start of word (unless we failed to realloc() */
                if (state != PARSE_STATE_ERROR) {

                    /* Reset per-arg variables */
                    arg_i = 0;
                    arg_size = 32;

                    /* Allocate this argument. This will be
                     * realloc'd as necessary by append_char() */
                    argv[argc] = (char *)calloc(arg_size, 1);
                    if (!argv[argc]) {
                        state = PARSE_STATE_ERROR;
                        break;
                    }

                    if (line[line_i] == '"') {
                        /* Gobble up quote */
                        state = PARSE_STATE_IN_QUOTE;
                    } else {
                        /* Append this character to the argument begin
                         * fetching up a word */
                        if (append_char(&argv[argc], &arg_size,
                                    &arg_i, line[line_i])) {
                            state = PARSE_STATE_ERROR;
                        } else {
                            state = PARSE_STATE_IN_ARG;
                        }
                    }

                    argc++;
                    line_i++;
                }

                break;

            case PARSE_STATE_IN_ARG:
                if (isspace(line[line_i])) {
                    state = PARSE_STATE_IN_SPACE;
                } else if (line[line_i] == '"') {
                    state = PARSE_STATE_IN_QUOTE;
                } else {
                    /* Append this character to the argument and remain in
                     * PARSE_STATE_IN_ARG state */
                    if (append_char(&argv[argc - 1], &arg_size,
                                    &arg_i, line[line_i])) {
                        state = PARSE_STATE_ERROR;
                    }
                }

                line_i++;
                break;


            case PARSE_STATE_IN_QUOTE:
                if (line[line_i] == '"') {
                    /* Return to looking for more of the word */
                    state = PARSE_STATE_IN_ARG;
                } else {
                    /* Append this character to the argumen */
                  if (append_char(&argv[argc - 1], &arg_size,
                                  &arg_i, line[line_i])) {
                      state = PARSE_STATE_ERROR;
                  }
                }

                line_i++;
                break;

            case PARSE_STATE_ERROR:
                break;
        }
    }

    /* Print PARSE_STATE_ERROR message if hit the EOL in an invalid state */
    switch (state) {
        case PARSE_STATE_IN_SPACE:
        case PARSE_STATE_IN_ARG:
            *argv_ret = argv;
            break;

        /* Unterminated quote or unexpexted state to end on */
        case PARSE_STATE_IN_QUOTE:
        default:
            state = PARSE_STATE_ERROR;
            break;
    }

    if (state == PARSE_STATE_ERROR) {
        free_args(argc, argv);
        return -1;
    } else {
        return argc;
    }
}
Ejemplo n.º 17
0
struct zpctoken *
zpcgettoken(const char *str, char **retstr)
{
    char            *ptr = (char *)str;
    struct zpctoken *token = NULL;
    char            *dec;
    long             sign = 0;
    long             radix;

    if (!*str) {

        return NULL;
    }
    while (isspace(*ptr)) {
        ptr++;
    }
    token = calloc(1, sizeof(struct zpctoken));
    if (*ptr == '-' && !isspace(ptr[1])) {
#if (SMARTTYPES)
        sign = ZPCUSERSIGNED;
#else
        sign = 1;
#endif
        ptr++;
    }
    if (isdigit(*ptr)) {
#if 0
        if (*ptr == '0') {
            if (ptr[1] == 'x' || ptr[1] == 'X') {
                token->radix = 16;
            } else if (ptr[1] == 'b' || ptr[1] == 'B') {
                token->radix = 2;
            } else {
                token->radix = 8;
            }
        } else {
            token->radix = 10;
        }
#endif
        token->str = calloc(1, TOKENSTRLEN);
        token->slen = TOKENSTRLEN;
        dec = index(ptr, '.');
        if(strstr(ptr, "uU")) {
#if (SMARTTYPES)
            if (sign == ZPCUSERSIGNED) {
                fprintf(stderr, "sign on unsigned number\n");
                
                return NULL;
            }
            sign = ZPCUSERUNSIGNED;
#else
            if (sign) {
                fprintf(stderr, "sign on unsigned number\n");
                
                return NULL;
            }
#endif
        }
        if (dec) {
//            token->type = ZPCDOUBLE;
            zpcgetdouble(token, ptr, &ptr);
            if (sign) {
                token->data.f64 = -token->data.f64;
                token->sign = sign;
            }
            sprintf(token->str, "%e", token->data.f64);
        } else if (!sign) {
            token->sign = 0;
            zpcgetuint64(token, ptr, &ptr);
#if (SMARTTYPES)
            if (sign == ZPCUSERSIGNED || token->data.ui64.u64 <= INT64_MAX) {
                token->type = ZPCINT64;
                token->sign = sign;
            } else {
                token->sign = ZPCUNSIGNED;
                token->type = ZPCUINT64;
            }
#else
//            token->type = ZPCUINT64;
#endif
            radix = token->radix;
#if 0
            if (!radix) {
                radix = zpcradix;
            }
#endif
            switch (radix) {
                case 2:
                    zpcconvbinuint64(token->data.ui64.u64, token->str,
                                     TOKENSTRLEN);
                    
                    break;
                case 8:
                    sprintf(token->str, "0%llo", (long long)token->data.ui64.u64);
                    
                    break;
                case 10:
                    sprintf(token->str, "%llu", (long long)token->data.ui64.u64);
                    
                    break;
                case 16:
                default:
                    sprintf(token->str, "0x%llx", (long long)token->data.ui64.u64);
                    
                    break;
            }
        } else {
//            token->type = ZPCINT64;
            zpcgetint64(token, ptr, &ptr);
            token->data.ui64.i64 = -token->data.ui64.i64;
#if (SMARTTYPES)
            token->sign = ZPCUSERSIGNED;
#else
            token->sign = 1;
#endif
            radix = token->radix;
            if (!radix) {
                radix = zpcradix;
            }
            switch (radix) {
                case 2:
#if 0
                    zpcconvbinint64(token->data.ui64.i64, token->str,
                                    TOKENSTRLEN);
#endif
                    zpcconvbinint64(token->data.ui64.i64, token->str,
                                    TOKENSTRLEN);
                    
                    break;
                case 8:
                    sprintf(token->str, "0%llo", (long long)token->data.ui64.i64);
                    
                    break;
                case 10:
                    sprintf(token->str, "%lld", (long long)token->data.ui64.i64);
                    
                    break;
                case 16:
                default:
                    sprintf(token->str, "0x%llx", (long long)token->data.ui64.i64);
                    
                    break;
            }
        }
    } else if (*ptr == '"') {
        zpcgetstr(token, ptr, &ptr);
        token->type = ZPCSTRING;
    } else if (*ptr == '<' && isxdigit(ptr[1])) {
        zpcgetvector(token, ptr, &ptr);
//    } else if (*ptr == '(' && isxdigit(ptr[1])) {
//        zpcgetcomplex(token, ptr, &ptr);
    } else if (zpcisoperchar(*ptr)) {
        zpcgetoper(token, ptr, &ptr);
    } else if (*ptr == '(') {
        token->type = ZPCLEFTPAREN;
        token->str = calloc(1, TOKENSTRLEN);
        token->slen = TOKENSTRLEN;
        *token->str = '(';
        token->str[1] = '\0';
        token->len = 1;
        ptr++;
    } else if (*ptr == ')') {
        token->type = ZPCRIGHTPAREN;
        token->str = calloc(1, TOKENSTRLEN);
        token->slen = TOKENSTRLEN;
        *token->str = ')';
        token->str[1] = '\0';
        token->len = 1;
        ptr++;
    } else {
        free(token);
        token = NULL;
    }
    if (token) {
        *retstr = (char *)ptr;
    }

    return token;
}
Ejemplo n.º 18
0
int main()
{
    FILE *fp;
    int init, *FS, **FA, i, j, col, row, fs, r, c;
    char *str, temp[50];
    
    fp = FA = FS = str = NULL;
    
    if(!(fp = fopen("input", "r")))
    {
        printf("Error opening file!!!\n");
        return -1;
    }
    
    fscanf(fp, "%d", &init);
    fgets(temp, sizeof(char)*50, fp);
    fgets(temp, sizeof(char)*50, fp);
#ifdef DEBUG
    printf("FS String: %s", temp);
#endif
    str = temp;
    i = 0;
    while(*str != '\0')
    {
        FS = (int *) realloc(FS, sizeof(int)*(i+1));
        sscanf(str, "%d", &FS[i++]);
#ifdef DEBUG
        printf("Here, i = %d, *str = %c\n", i, *str);
#endif
        str++;
        while(isdigit(*str))
        {
#ifdef DEBUG
            printf("He1");
#endif            
            str++;
        }
        while(isspace(*str))
            str++;
    }
    fs = i;
    
    fgets(temp, sizeof(char)*50, fp);
    str = temp;
    i= 0;
#ifdef DEBUG
    printf("0FA scanned: %s\n", temp);
#endif
    FA = (int **) malloc(sizeof(int *)*1);
    FA[0] = NULL;
    while(*str != '\0')
    {
    	FA[0] = (int *)realloc(FA[0], sizeof(int)*(i+1));
        sscanf(str, "%d", &FA[0][i++]);
#ifdef DEBUG
        printf("Here1, i = %d, *str = %c, FA[0][%d] = %d\n", i, *str, i-1, FA[0][i-1]);
#endif
        str++;
        while(isdigit(*str))
            str++;
        while(isspace(*str))
            str++;
    }
    row = 1;
    col = i;
    while(!feof(fp))
    {
    	FA = (int **) realloc(FA, sizeof(int *)*(row+1));
    	FA[row] = NULL;
        fgets(temp, sizeof(char)*50, fp);
#ifdef DEBUG        
        printf("1FA scanned: %s\n", temp);
#endif        
        str = temp;
        i= 0;
        while(*str != '\0')
        {
        	FA[row] = (int *)realloc(FA[row], sizeof(int)*(i+1));
            sscanf(str, "%d", &FA[row][i++]);
#ifdef DEBUG
		        printf("Here1, i = %d, *str = %c, FA[%d][%d] = %d\n", i, *str, row,  i-1, FA[row][i-1]);
#endif
            str++;
            while(isdigit(*str))
                str++;
            while(isspace(*str))
                str++;
        }
        row++;
    }
    
    
    
    printf("Initial State: %d\n", init);
    printf("Final states: ");
    for(i = 0; i < fs; i++)
        printf("%d ", FS[i]);
    printf("\nInput Table:\n");
    for(i = 0; i < row; i++)
    {
        for(j = 0; j < col; j++)
        {
            printf("%d\t", FA[i][j]);
        }
        printf("\n");
    }
    
    while(1)
    {
    	printf("Enter the string to be validated using the Finite Automata (\"!end\" to quit): ");
    	scanf("%s", temp);
    	if(strcmp(temp, "!end") == 0)
    		break;
    	str = temp;
    	r = 0;
    	while(*str != '\0')
    	{
    		c = tolower(*str) - 97;		//Column of FA to be matched for the current input symbol
    		if((c >= col) || (c < 0))
    		{
    			printf("Error! Invalid input symbol!\n");
    			c = -1;
    			break;
    		}
    		if(FA[r][c] != -1)
    		{
    			r = FA[r][c];
    			str++;
    		}
    		else
    		{
    			printf("Error! Input symbol unexpected!\n");
    			c = -1;
    			break;
    		}
    	}
    	if(c == -1)
    		continue;
    	for(i = 0; i < fs; i++)
    		if(r == FS[i])
    		{
    			printf("String validated.\n");
    			break;
    		}
    	if(i == fs)
    		printf("String ending at a non-final state.\n");
    };
    return 0;
}
Ejemplo n.º 19
0
/*
 * Get from "/proc/net/dev" all interfaces listed there; if they're
 * already in the list of interfaces we have, that won't add another
 * instance, but if they're not, that'll add them.
 *
 * We don't bother getting any addresses for them; it appears you can't
 * use SIOCGIFADDR on Linux to get IPv6 addresses for interfaces, and,
 * although some other types of addresses can be fetched with SIOCGIFADDR,
 * we don't bother with them for now.
 *
 * We also don't fail if we couldn't open "/proc/net/dev"; we just leave
 * the list of interfaces as is.
 */
static int
scan_proc_net_dev(pcap_if_t **devlistp, int fd, char *errbuf)
{
	FILE *proc_net_f;
	char linebuf[512];
	int linenum;
	unsigned char *p;
	char name[512];	/* XXX - pick a size */
	char *q, *saveq;
	struct ifreq ifrflags;
	int ret = 0;

	proc_net_f = fopen("/proc/net/dev", "r");
	if (proc_net_f == NULL)
		return (0);

	for (linenum = 1;
	    fgets(linebuf, sizeof linebuf, proc_net_f) != NULL; linenum++) {
		/*
		 * Skip the first two lines - they're headers.
		 */
		if (linenum <= 2)
			continue;

		p = &linebuf[0];

		/*
		 * Skip leading white space.
		 */
		while (*p != '\0' && isspace(*p))
			p++;
		if (*p == '\0' || *p == '\n')
			continue;	/* blank line */

		/*
		 * Get the interface name.
		 */
		q = &name[0];
		while (*p != '\0' && !isspace(*p)) {
			if (*p == ':') {
				/*
				 * This could be the separator between a
				 * name and an alias number, or it could be
				 * the separator between a name with no
				 * alias number and the next field.
				 *
				 * If there's a colon after digits, it
				 * separates the name and the alias number,
				 * otherwise it separates the name and the
				 * next field.
				 */
				saveq = q;
				while (isdigit(*p))
					*q++ = *p++;
				if (*p != ':') {
					/*
					 * That was the next field,
					 * not the alias number.
					 */
					q = saveq;
				}
				break;
			} else
				*q++ = *p++;
		}
		*q = '\0';

		/*
		 * Get the flags for this interface, and skip it if
		 * it's not up.
		 */
		strncpy(ifrflags.ifr_name, name, sizeof(ifrflags.ifr_name));
		if (ioctl(fd, SIOCGIFFLAGS, (char *)&ifrflags) < 0) {
			if (errno == ENXIO)
				continue;
			(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
			    "SIOCGIFFLAGS: %.*s: %s",
			    (int)sizeof(ifrflags.ifr_name),
			    ifrflags.ifr_name,
			    pcap_strerror(errno));
			ret = -1;
			break;
		}
		if (!(ifrflags.ifr_flags & IFF_UP))
			continue;

		/*
		 * Add an entry for this interface, with no addresses.
		 */
		if (pcap_add_if(devlistp, name, ifrflags.ifr_flags, NULL,
		    errbuf) == -1) {
			/*
			 * Failure.
			 */
			ret = -1;
			break;
		}
	}
	if (ret != -1) {
		/*
		 * Well, we didn't fail for any other reason; did we
		 * fail due to an error reading the file?
		 */
		if (ferror(proc_net_f)) {
			(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
			    "Error reading /proc/net/dev: %s",
			    pcap_strerror(errno));
			ret = -1;
		}
	}

	(void)fclose(proc_net_f);
	return (ret);
}
Ejemplo n.º 20
0
/* receive one JSON object from the server.
 * Returns: - NULL after a network error OR
 *          - an empty JSON object if there is a parsing error OR
 *          - the parsed response from the server */
static json_t *receive_json_msg(void)
{
    char *rbuf, *bp;
    int datalen, ret, rbufsize;
    json_t *recv_msg;
    json_error_t err;
    fd_set rfds;
    struct timeval tv;
    
    FD_ZERO(&rfds);
    FD_SET(sockfd, &rfds);
    
    rbufsize = 1024 * 1024; /* initial size: 1MB */
    rbuf = malloc(rbufsize);
    memset(rbuf, 0, rbufsize);
    recv_msg = NULL;
    datalen = 0;
    while (!recv_msg) {
	/* select before reading so that we get a timeout. Otherwise the
	 * program might hang indefinitely in read if the connection has failed */
	tv.tv_sec = 10; /* 10s * 3 retries results in a long wait on failed connections... */
	tv.tv_usec = 0;
	ret = select(sockfd + 1, &rfds, NULL, NULL, &tv);
	if (ret <= 0) {
	    /* we aren't expecting any signals, so it seems ok to abort even if
	     * ret == -1 && errno == EINTR */
	    free(rbuf);
	    return NULL;
	}
	
	/* leave the last byte in the buffer free for the '\0' */
	ret = recv(sockfd, &rbuf[datalen], rbufsize - datalen - 1, 0);
	if (ret == -1 && errno == EINTR)
	    continue;
	else if (ret <= 0) {
	    free(rbuf);
	    return NULL;
	}
	datalen += ret;
	
	rbuf[datalen] = '\0'; /* terminate the string */
	bp = &rbuf[datalen - 1];
	while (isspace(*bp))
	    bp--;

	recv_msg = NULL;
	if (*bp == '}') { /* possibly the end of the json object */
	    recv_msg = json_loads(rbuf, JSON_REJECT_DUPLICATES, &err);
	    if (!recv_msg && err.position < datalen) {
		print_error("Broken response received from server.");
		free(rbuf);
		return json_object();
	    }
	}
	
	/* allow the receive buffer to grow to 16MB. Growing larger than 1MB is
	 * extremely unlikely (I can't imagine how it would happen); 16MB or
	 * more is clearly an error. */
	if (!recv_msg && datalen >= rbufsize - 1) {
	    if (datalen < 16 * 1024 * 1024) {
		rbufsize *= 2;
		rbuf = realloc(rbuf, rbufsize);
	    } else {
		print_error("Too much incoming data. Server error?");
		free(rbuf);
		return json_object();
	    }
	}
    }
    
    free(rbuf);    
    return recv_msg;
}
Ejemplo n.º 21
0
static ssize_t ldap_recv(struct connectdata *conn, int sockindex, char *buf,
                         size_t len, CURLcode *err)
{
  ldapconninfo *li = conn->proto.generic;
  struct SessionHandle *data=conn->data;
  ldapreqinfo *lr = data->state.proto.generic;
  int rc, ret;
  LDAPMessage *result = NULL;
  LDAPMessage *ent;
  BerElement *ber = NULL;
  struct timeval tv = {0,1};
  (void)len;
  (void)buf;
  (void)sockindex;

  rc = ldap_result(li->ld, lr->msgid, LDAP_MSG_RECEIVED, &tv, &result);
  if (rc < 0) {
    failf(data, "LDAP local: search ldap_result %s", ldap_err2string(rc));
    *err = CURLE_RECV_ERROR;
    return -1;
  }

  *err = CURLE_AGAIN;
  ret = -1;

  /* timed out */
  if (result == NULL)
    return ret;

  for (ent = ldap_first_message(li->ld, result); ent;
    ent = ldap_next_message(li->ld, ent)) {
    struct berval bv, *bvals, **bvp = &bvals;
    int binary = 0, msgtype;

    msgtype = ldap_msgtype(ent);
    if (msgtype == LDAP_RES_SEARCH_RESULT) {
      int code;
      char *info = NULL;
      rc = ldap_parse_result(li->ld, ent, &code, NULL, &info, NULL, NULL, 0);
      if (rc) {
        failf(data, "LDAP local: search ldap_parse_result %s", ldap_err2string(rc));
        *err = CURLE_LDAP_SEARCH_FAILED;
      } else if (code && code != LDAP_SIZELIMIT_EXCEEDED) {
        failf(data, "LDAP remote: search failed %s %s", ldap_err2string(rc),
          info ? info : "");
        *err = CURLE_LDAP_SEARCH_FAILED;
      } else {
        /* successful */
        if (code == LDAP_SIZELIMIT_EXCEEDED)
          infof(data, "There are more than %d entries\n", lr->nument);
        data->req.size = data->req.bytecount;
        *err = CURLE_OK;
        ret = 0;
      }
      lr->msgid = 0;
      ldap_memfree(info);
      break;
    } else if (msgtype != LDAP_RES_SEARCH_ENTRY) {
      continue;
    }

    lr->nument++;
    rc = ldap_get_dn_ber(li->ld, ent, &ber, &bv);
    Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"DN: ", 4);
    Curl_client_write(conn, CLIENTWRITE_BODY, (char *)bv.bv_val, bv.bv_len);
    Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"\n", 1);
    data->req.bytecount += bv.bv_len + 5;

    for (rc = ldap_get_attribute_ber(li->ld, ent, ber, &bv, bvp);
      rc == LDAP_SUCCESS;
      rc = ldap_get_attribute_ber(li->ld, ent, ber, &bv, bvp)) {
      int i;

      if (bv.bv_val == NULL) break;

      if (bv.bv_len > 7 && !strncmp(bv.bv_val + bv.bv_len - 7, ";binary", 7))
        binary = 1;

      for (i=0; bvals[i].bv_val != NULL; i++) {
        int binval = 0;
        Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"\t", 1);
        Curl_client_write(conn, CLIENTWRITE_BODY, (char *)bv.bv_val, bv.bv_len);
        Curl_client_write(conn, CLIENTWRITE_BODY, (char *)":", 1);
        data->req.bytecount += bv.bv_len + 2;

        if (!binary) {
          /* check for leading or trailing whitespace */
          if (isspace(bvals[i].bv_val[0]) ||
              isspace(bvals[i].bv_val[bvals[i].bv_len-1])) {
            binval = 1;
          } else {
            /* check for unprintable characters */
            unsigned int j;
            for (j=0; j<bvals[i].bv_len; j++)
              if (!isprint(bvals[i].bv_val[j])) {
                binval = 1;
                break;
              }
          }
        }
        if (binary || binval) {
          char *val_b64;
          /* Binary value, encode to base64. */
          size_t val_b64_sz = Curl_base64_encode(data,
                                            bvals[i].bv_val,
                                            bvals[i].bv_len,
                                            &val_b64);
          Curl_client_write(conn, CLIENTWRITE_BODY, (char *)": ", 2);
          data->req.bytecount += 2;
          if(val_b64_sz > 0) {
            Curl_client_write(conn, CLIENTWRITE_BODY, val_b64, val_b64_sz);
            free(val_b64);
            data->req.bytecount += val_b64_sz;
          }
        } else {
          Curl_client_write(conn, CLIENTWRITE_BODY, (char *)" ", 1);
          Curl_client_write(conn, CLIENTWRITE_BODY, bvals[i].bv_val,
                            bvals[i].bv_len);
          data->req.bytecount += bvals[i].bv_len + 1;
        }
        Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"\n", 0);
        data->req.bytecount++;
      }
      ber_memfree(bvals);
      Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"\n", 0);
      data->req.bytecount++;
    }
    Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"\n", 0);
    data->req.bytecount++;
    ber_free(ber, 0);
  }
  ldap_msgfree(result);
  return ret;
}
Ejemplo n.º 22
0
// returns the last port from the trace file
uint16_t openInputTraceFile(const char *name)
{
  FILE *in = fopen(name, "r");
  TraceRecord *previous = NULL;
  uint16_t i;

  if (in == NULL) {
    fprintf(stderr, "Open \"%s\" failed.\n", name);
    exit(-1);
  }

  emReadingTrace = true;
  int result = 0;

  while (true) {
    int tag = fgetc(in);
    unsigned int length;
    TraceRecord *traceRecord = {0};
    int port;
    uint8_t addressFromFile[100] = {0};

    if (tag == EOF) {
      break;
    } else if (isspace(tag)) {
      continue;
    }

    if (fscanf(in, " %d", &port) != 1) {
      fprintf(stderr, "Failed to read port");
      exit(-1);
    }

    ASSERT(port <= 0xFFFF);

    if (fscanf(in, " %s", addressFromFile) != 1) {
      fprintf(stderr, "Failed to read address");
      exit(-1);
    }

    if (fscanf(in, " %u", &length) != 1) {
      fprintf(stderr, "Failed to read trace length.");
      exit(-1);
    }

    traceRecord = (TraceRecord *) malloc(sizeof(TraceRecord) + length);

    if (traceRecord == NULL) {
      fprintf(stderr, "Failed to allocate TraceRecord.");
      exit(-1);
    }

    traceRecord->tag = tag;
    traceRecord->previous = previous;
    traceRecord->next = NULL;
    traceRecord->length = length;
    traceRecord->port = port;

    result = traceRecord->port;

    // i don't like having an #ifdef here, but it's easier than
    // pulling in ip-address.c to the tls and pana tests
#ifdef UNIX_SCRIPTED_HOST
    stringToIpAddress(addressFromFile,
                      strlen(addressFromFile),
                      traceRecord->address);
#endif

    if (previous == NULL) {
      theTrace = traceRecord;
    } else {
      previous->next = traceRecord;
    }

    previous = traceRecord;

    for (i = 0; i < length; i++) {
      unsigned int n;
      if (fscanf(in, " %2X", &n) != 1) {
        fprintf(stderr, "Failed to read trace value.");
        exit(-1);
      }
      traceRecord->contents[i] = n;
    }
  }

  fprintf(stderr, "[Running \"%s\" ", name);
  return result;
}
Ejemplo n.º 23
0
char * skip_token (const char *p) {
    while (isspace((unsigned char)*p)) p++;
    while (*p && !isspace((unsigned char)*p)) p++;
    return (char *)p;
}         
Ejemplo n.º 24
0
UINT32
strtoul (
    const char              *String,
    char                    **Terminator,
    UINT32                  Base)
{
    UINT32                  converted = 0;
    UINT32                  index;
    UINT32                  sign;
    const char              *StringStart;
    UINT32                  ReturnValue = 0;
    ACPI_STATUS             Status = AE_OK;


    /*
     * Save the value of the pointer to the buffer's first
     * character, save the current errno value, and then
     * skip over any white space in the buffer:
     */
    StringStart = String;
    while (isspace (*String) || *String == '\t')
    {
        ++String;
    }

    /*
     * The buffer may contain an optional plus or minus sign.
     * If it does, then skip over it but remember what is was:
     */
    if (*String == '-')
    {
        sign = ACPI_SIGN_NEGATIVE;
        ++String;
    }
    else if (*String == '+')
    {
        ++String;
        sign = ACPI_SIGN_POSITIVE;
    }
    else
    {
        sign = ACPI_SIGN_POSITIVE;
    }

    /*
     * If the input parameter Base is zero, then we need to
     * determine if it is octal, decimal, or hexadecimal:
     */
    if (Base == 0)
    {
        if (*String == '0')
        {
            if (tolower (*(++String)) == 'x')
            {
                Base = 16;
                ++String;
            }
            else
            {
                Base = 8;
            }
        }
        else
        {
            Base = 10;
        }
    }
    else if (Base < 2 || Base > 36)
    {
        /*
         * The specified Base parameter is not in the domain of
         * this function:
         */
        goto done;
    }

    /*
     * For octal and hexadecimal bases, skip over the leading
     * 0 or 0x, if they are present.
     */
    if (Base == 8 && *String == '0')
    {
        String++;
    }

    if (Base == 16 &&
        *String == '0' &&
        tolower (*(++String)) == 'x')
    {
        String++;
    }

    /*
     * Main loop: convert the string to an unsigned long:
     */
    while (*String)
    {
        if (isdigit (*String))
        {
            index = (UINT32) ((UINT8) *String - '0');
        }
        else
        {
            index = (UINT32) toupper (*String);
            if (isupper (index))
            {
                index = index - 'A' + 10;
            }
            else
            {
                goto done;
            }
        }

        if (index >= Base)
        {
            goto done;
        }

        /*
         * Check to see if value is out of range:
         */

        if (ReturnValue > ((ACPI_UINT32_MAX - (UINT32) index) /
                            (UINT32) Base))
        {
            Status = AE_ERROR;
            ReturnValue = 0;           /* reset */
        }
        else
        {
            ReturnValue *= Base;
            ReturnValue += index;
            converted = 1;
        }

        ++String;
    }

done:
    /*
     * If appropriate, update the caller's pointer to the next
     * unconverted character in the buffer.
     */
    if (Terminator)
    {
        if (converted == 0 && ReturnValue == 0 && String != NULL)
        {
            *Terminator = (char *) StringStart;
        }
        else
        {
            *Terminator = (char *) String;
        }
    }

    if (Status == AE_ERROR)
    {
        ReturnValue = ACPI_UINT32_MAX;
    }

    /*
     * If a minus sign was present, then "the conversion is negated":
     */
    if (sign == ACPI_SIGN_NEGATIVE)
    {
        ReturnValue = (ACPI_UINT32_MAX - ReturnValue) + 1;
    }

    return (ReturnValue);
}
Ejemplo n.º 25
0
void process_mult (FILE *in, int overwrite, int casemode, int colmode)
{
	Basrec_type rec;
	int processing = FALSE, i, j, eol, len;
	char file_out [MAXPATH], casetext [MAXLINE], fext [MAXEXT];
	FILE *out;

	while (getline (line, MAXLINE, in) != EOF)
	{
		i = 0;
		eol = strlen (line);
		while (i < eol && isspace (line [i])) i ++;
		for (j = i; j < eol; j++) casetext [j] = tolower (line [j]);
		casetext [j] = 0;
		len = strlen (START_PROC);

		if (! strncmp (& (casetext [i]), START_PROC, len))
		{
			if (processing)
			{
				end_prg (out);
				fclose (out);
				processing = FALSE;
				fprintf (stderr, " done.\n");
			}

			i += len;

			if (sscanf (& (line [i]), "%s", file_out) == 1)
			{
				if (! extension (file_out, fext, MAXEXT -1))
					strncat (file_out, PRG_EXT, MAXPATH - 1);
				else if (! strcmp (fext, TXT_EXT))
				{
					fclose (in);
					fprintf (stderr, "%s: not expecting \"%s\" as output.\n",
						program, file_out);
					exit (EXITBAD);
				}

				if (! exit_exists (overwrite, in, file_out))
					if ((out = fopen (file_out, "wb")) == NULL)
					{
						fprintf (stderr, "%s: Can't open %s for output\n",
							program, file_out);
						fclose (in);
						exit (EXITBAD);
					}
					else
					{
						fprintf (stderr, "==> %s ...", file_out);
						processing = TRUE;
						set_addy (BASREC_NULL);
						tokenize (BASREC_NULL, CH_NULL, TRUE, TRUE);
						start_prg (out);
					}
			}
			else
			{
				fprintf (stderr, "%s: no output filename given\n",
					program);
				fclose (in);
				exit (EXITBAD);
			}
		}
		else if (! strncmp (& (casetext [i]), STOP_PROC, strlen (STOP_PROC)))
		{
			if (processing)
			{
				end_prg (out);
				fclose (out);
				processing = FALSE;
				fprintf (stderr, " done.\n");
			}
		}
		else if (processing)
		{
			if (tokenize (&rec, line, casemode, colmode))
			{
				set_addy (&rec);
				outprg (out, &rec);
			}
		}
	}

	return;
}
Ejemplo n.º 26
0
static NEOERR* _hdf_read_string (HDF *hdf, const char **str, STRING *line,
                                 const char *path, int *lineno,
                                 int include_handle, int expect_end_brace) {
  NEOERR *err;
  HDF *lower;
  char *s;
  char *name, *value;
  HDF_ATTR *attr = NULL;

  while (**str != '\0')
  {
    /* Reset string length, but don't free the reserved buffer */
    line->len = 0;
    err = _copy_line_advance(str, line);
    if (err) return nerr_pass(err);
    attr = NULL;
    (*lineno)++;
    s = line->buf;
    SKIPWS(s);
    if ((!strncmp(s, "#include ", 9) || !strncmp(s, "-include ", 9)) && include_handle != INCLUDE_IGNORE)
    {
      int required = !strncmp(s, "#include ", 9);
      if (include_handle == INCLUDE_ERROR)
      {
	return nerr_raise (NERR_PARSE,
                           "[%d]: #include not supported in string parse",
                           *lineno);
      }
      else if (include_handle < INCLUDE_MAX_DEPTH)
      {
        int l;
        s += 9;
        name = neos_strip(s);
        l = strlen(name);
        if (name[0] == '"' && name[l-1] == '"')
        {
          name[l-1] = '\0';
          name++;
        }
        char fullpath[PATH_MAX];
        if (name[0] != '/') {
          memset(fullpath, 0, PATH_MAX);

          char *p = strrchr(path, '/');
          if (p == NULL) {
            char pwd[PATH_MAX];
            memset(pwd, 0, PATH_MAX);
            getcwd(pwd, PATH_MAX);
            snprintf(fullpath, PATH_MAX, "%s/%s", pwd, name);
          } else {
            int dir_len = p - path + 1;
            snprintf(fullpath, PATH_MAX, "%s", path);
            snprintf(fullpath + dir_len, PATH_MAX - dir_len, "%s", name);
          }
          name = fullpath;
        }
        err = hdf_read_file_internal(hdf, name, include_handle + 1);
        if (err != STATUS_OK && required)
        {
          return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
        }
      }
      else {
        return nerr_raise (NERR_MAX_RECURSION,
                           "[%d]: Too many recursion levels.",
                           *lineno
                           );
      }
    }
    else if (s[0] == '#')
    {
      /* comment: pass */
    }
    else if (s[0] == '}') /* up */
    {
      s = neos_strip(s);
      if (strcmp(s, "}"))
      {
        err = nerr_raise(NERR_PARSE,
	    "[%s:%d] Trailing garbage on line following }: %s", path, *lineno,
	    line->buf);
        return err;
      }
      return STATUS_OK;
    }
    else if (s[0])
    {
      /* Valid hdf name is [0-9a-zA-Z_.]+ */
      int splice = *s == '@';
      if (splice) s++;
      name = s;
      while (*s && (isalnum(*s) || *s == '_' || *s == '.' || *s == '*')) s++;
      SKIPWS(s);

      char num[16];
      static int counter = 0;
      if (*name == '*') {
        snprintf(num, sizeof(num), "%d", counter++);
        name = num;
      }

      if (s[0] == '[') /* attributes */
      {
	*s = '\0';
	name = neos_strip(name);
	s++;
	err = parse_attr(&s, &attr);
	if (err)
        {
          return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
        }
	SKIPWS(s);
      }
      if (splice) {
        name = neos_strip(name);
        HDF *h = hdf_get_obj(hdf->top, name);
        if (h) {
          HDF *c = hdf_obj_child(h);
          while (c) {
            err = hdf_copy (hdf, hdf_obj_name(c), c);
            if (err != STATUS_OK) break;
            c = hdf_obj_next(c);
          }
        }
	if (err != STATUS_OK)
        {
          return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
        }
      } else if (s[0] == '=') /* assignment */
      {
	*s = '\0';
	name = neos_strip(name);
	s++;
	value = neos_strip(s);
	err = _set_value (hdf, name, value, 1, 1, 0, attr, NULL);
	if (err != STATUS_OK)
        {
          return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
        }
      }
      else if (s[0] == ':' && s[1] == '=') /* copy */
      {
	*s = '\0';
	name = neos_strip(name);
	s+=2;
	value = neos_strip(s);
        HDF *h = hdf_get_obj(hdf->top, value);
        if (!h)
        {
	  err = nerr_raise(NERR_PARSE,
                           "[%s:%d] Failed to copy a node that is not loaded "
                           "yet: %s", path, *lineno, value);
          return err;
        }
        err = hdf_copy(hdf, name, h);
	if (err != STATUS_OK)
        {
          return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
        }
      }
      else if (s[0] == '!' && s[1] == '=') /* exec */
      {
	*s = '\0';
	name = neos_strip(name);
	s+=2;
	value = neos_strip(s);

        FILE *f = popen(value, "r");
	if (f == NULL)
        {
	  err = nerr_raise(NERR_PARSE,
                           "[%s:%d] Failed to exec specified command: %s",
                           path, *lineno, line->buf);
          return err;
        }
        char *content = _read_file(f);
        fclose(f);
        int len = strlen(content);
        if (len > 0 && content[len - 1] == '\n') {
          content[len - 1] = '\0'; // remove \n artifact
        }
	err = _set_value (hdf, name, content, 1, 1, 0, attr, NULL);
        free(content);

	if (err != STATUS_OK)
        {
          return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
        }
      }
      else if (s[0] == ':') /* link */
      {
	*s = '\0';
	name = neos_strip(name);
	s++;
	value = neos_strip(s);
	err = _set_value (hdf, name, value, 1, 1, 1, attr, NULL);
	if (err != STATUS_OK)
        {
          return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
        }
      }
      else if (s[0] == '{') /* deeper */
      {
	*s = '\0';
	name = neos_strip(name);
	lower = hdf_get_obj (hdf, name);
	if (lower == NULL)
	{
	  err = _set_value (hdf, name, NULL, 1, 1, 0, attr, &lower);
	}
	else
	{
	  err = _set_value (lower, NULL, lower->value, 1, 1, 0, attr, NULL);
	}
	if (err != STATUS_OK)
        {
          return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
        }
	err = _hdf_read_string (lower, str, line, path, lineno, include_handle,
                                1);
	if (err != STATUS_OK)
        {
          return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
        }
      }
      else if (s[0] == '<' && s[1] == '<') /* multi-line assignment */
      {
	char *m;
	int msize = 0;
	int mmax = 128;
	int l;

	*s = '\0';
	name = neos_strip(name);
	s+=2;
	value = neos_strip(s);
	l = strlen(value);
	if (l == 0)
        {
	  err = nerr_raise(NERR_PARSE,
	      "[%s:%d] No multi-assignment terminator given: %s", path, *lineno,
	      line->buf);
          return err;
        }
	m = (char *) malloc (mmax * sizeof(char));
	if (m == NULL)
        {
	  return nerr_raise(NERR_NOMEM,
	    "[%s:%d] Unable to allocate memory for multi-line assignment to %s",
	    path, *lineno, name);
        }
	while (_copy_line (str, m+msize, mmax-msize) != 0)
	{
          (*lineno)++;
	  if (!strncmp(value, m+msize, l) && isspace(m[msize+l]))
	  {
	    m[msize] = '\0';
	    break;
	  }
	  msize += strlen(m+msize);
	  if (msize + l + 10 > mmax)
	  {
	    void *new_ptr;
	    mmax += 128;
	    new_ptr = realloc (m, mmax * sizeof(char));
	    if (new_ptr == NULL)
	    {
        free(m);
	      return nerr_raise(NERR_NOMEM,
		  "[%s:%d] Unable to allocate memory for multi-line assignment to %s: size=%d",
		  path, *lineno, name, mmax);
      }
      m = (char *) new_ptr;
	  }
	}
	err = _set_value (hdf, name, m, 0, 1, 0, attr, NULL);
	if (err != STATUS_OK)
	{
	  free (m);
          return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
	}

      }
      else
      {
	err = nerr_raise(NERR_PARSE, "[%s:%d] Unable to parse line %s", path,
	    *lineno, line->buf);
        return err;
      }
    }
  }
  if (expect_end_brace) {
    err = nerr_raise(NERR_PARSE, "[%s:%d] Missing matching }", path, *lineno);
    return err;
  }
  return STATUS_OK;
}
Ejemplo n.º 27
0
/**
 * skip_spaces - Removes leading whitespace from @str.
 * @str: The string to be stripped.
 *
 * Returns a pointer to the first non-whitespace character in @str.
 */
char __attribute__((weak))  *skip_spaces(const char *str)
{
	while (isspace(*str))
		++str;
	return (char *)str;
}
Ejemplo n.º 28
0
bool
TMXLoader::Private::processLayer(XMLElement &e)
{
	const char *l_name;
	float l_opacity = 1.f;
	int l_visible = 1;

	if ((!(l_name = e.Attribute("name")))) {
		MMWARNING("Layer element is missing one or more required attributes.");
		return(false);
	}

	MMIGNORE e.QueryFloatAttribute("opacity", &l_opacity);
	MMIGNORE e.QueryIntAttribute("visible", &l_visible);

	XMLElement *l_data = e.FirstChildElement(TMXLAYER_DATA_NODE);

	if (!l_data) {
		MMWARNING("Layer element is missing data element.");
		return(false);
	}

	const char *l_data_encoding;
	const char *l_data_compression;

	if (!(l_data_encoding = l_data->Attribute("encoding")) ||
	    !(l_data_compression = l_data->Attribute("compression"))) {
		MMWARNING("Layer data element is missing one or more required attributes.");
		return(false);
	}
	const char *l_data_raw = XMLUtil::SkipWhiteSpace(l_data->GetText());
	size_t l_data_raw_len = strlen(l_data_raw);

	/* right-side data trim */
	while (l_data_raw_len > 0 && isspace(l_data_raw[l_data_raw_len - 1]))
		--l_data_raw_len;

	if (!l_data_raw_len) {
		MMWARNING("Zero size layer data encountered.");
		return(false);
	}

	char *l_data_array = 0;

#define TMXDATA_ENCODING_BASE64 "base64"
	if (0 == strcmp(l_data_encoding, TMXDATA_ENCODING_BASE64)) {
		char *l_decoded_data;
		size_t l_decoded_data_size =
		    Core::Base64::Decode(l_data_raw, l_data_raw_len, &l_decoded_data);

#define TMXDATA_COMPRESSION_ZLIB "zlib"
		if (0 == strcmp(l_data_compression, TMXDATA_COMPRESSION_ZLIB)) {
			char *l_inflated_data;
			if (0 < Core::Zlib::Inflate(l_decoded_data, l_decoded_data_size,
			    static_cast<size_t>(map_size.width * map_size.height * 4), &l_inflated_data))
				l_data_array = l_inflated_data;
		}
#define TMXDATA_COMPRESSION_GZIP "gzip"
		else if (0 == strcmp(l_data_compression, TMXDATA_COMPRESSION_GZIP)) {
			char *l_inflated_data;
			if (0 < Core::Gzip::Inflate(l_decoded_data, l_decoded_data_size,
			    static_cast<size_t>(map_size.width * map_size.height * 4), &l_inflated_data))
				l_data_array = l_inflated_data;
		}

		delete[] l_decoded_data;
	}

#define TMXDATA_ENCODING_CSV "csv"
	else if (0 == strcmp(l_data_encoding, TMXDATA_ENCODING_CSV)) {
		// TODO(gamaral)
		assert(0 && "CSV data encoding is currently unimplemented");
		return(false);
	}

	if (!l_data_array)
		return(false);

	Game::TilemapSceneLayer *l_layer = new Game::TilemapSceneLayer(l_name, scene);
	l_layer->setData(reinterpret_cast<uint32_t *>(l_data_array));
	l_layer->setOpacity(l_opacity);
	l_layer->setSize(map_size);
	l_layer->setTileSize(tile_size);
	l_layer->setScale(scale);
	l_layer->setVisibility(1 == l_visible);

	/* process properties */
	XMLElement *l_properties = e.FirstChildElement(TMXPROPERTIES_NODE);
	XMLElement *l_property = l_properties ? l_properties->FirstChildElement(TMXPROPERTIES_PROPERTY_NODE) : 0;
	if (l_property)
	do {
		const char *l_pname = l_property->Attribute("name");
		const char *l_value = l_property->Attribute("value");
		if (!l_pname)
			continue;

		/* scale property */
		if (0 == strcmp(l_pname, "scale")) {
			if (!l_value) {
				MMWARNING("Skipping incomplete scale property.");
				continue;
			}

			Math::Size2f l_scale = l_layer->scale();
			if (0 == MMSTRCASECMP(l_value, "screen")) {
				const Math::Size2f &l_vsize = Graphics::Viewport::Size();
				const Math::Size2i &l_wsize = Graphics::Viewport::WindowSize();

				/*
				 * calculate pixels per viewport coordinate ratio
				 * scale ratio = vSize (vcoord)) / wSize (pixels)
				 */
				l_scale = l_vsize / l_wsize.cast<float>();
				l_layer->setScale(l_scale);

				continue;
			}
			else if (2 == sscanf(l_value, "%fx%f", &l_scale.width, &l_scale.height)) {
				l_layer->setScale(l_scale);
				continue;
			} else if (1 == sscanf(l_value, "%f", &l_scale.width)) {
				l_scale.height = l_scale.width;
				l_layer->setScale(l_scale);
				continue;
			}

			MMERROR("Invalid scale value encountered.");
			continue;
		}
		else l_layer->setProperty(l_name, l_value ? l_value : std::string());

	} while ((l_property = l_property->NextSiblingElement(TMXPROPERTIES_PROPERTY_NODE)));

	/* attach tilesets */
	TilesetCollection::iterator l_tileset_i;
	for (l_tileset_i = tilesets.begin(); l_tileset_i != tilesets.end(); ++l_tileset_i)
		l_layer->attachTileset(l_tileset_i->first, l_tileset_i->second);

	layers.push_back(l_layer);

	return(true);
}
Ejemplo n.º 29
0
static int getstructure(char *tag, int structure)
{

/* int len; *//* not used - 2/22/00 */
    char    oldChar = 0;
    char   *endOfTag = NULL;
    char   *pos;

    pos = tag;
    while (*pos)
    {
        if (isspace((int) ((unsigned char) *pos)))
        {
            endOfTag = pos;     /* remember where we are... */
            oldChar = *pos;     /* ...and what we saw */
            *pos = '\0';        /* truncate string, for now */
        }
        else
            pos++;
    }
    /*      Store Word Context
       **      Modified DLN 1999-10-24 - Comments and Cleaning
       **  TODO: Make sure that these allow for HTML attributes
       * */

    /* HEAD  */
    if (strcasecmp(tag, "/head") == 0)
        structure &= ~IN_HEAD;  /* Out  */
    else if (strcasecmp(tag, "head") == 0)
        structure |= IN_HEAD;   /* In  */
    /* TITLE  */
    else if (strcasecmp(tag, "/title") == 0)
        structure &= ~IN_TITLE;
    else if (strcasecmp(tag, "title") == 0)
        structure |= IN_TITLE;
    /* BODY */
    else if (strcasecmp(tag, "/body") == 0)
        structure &= ~IN_BODY;  /* In */
    else if (strcasecmp(tag, "body") == 0)
        structure |= IN_BODY;   /* Out */
    /* H1, H2, H3, H4, H5, H6  */
    else if (tag[0] == '/' && tolower((int)((unsigned char)tag[1])) == 'h' && isdigit((int)((unsigned char)tag[2]))) /* cast to int - 2/22/00 */
        structure &= ~IN_HEADER; /* In */
    else if (tolower((int)((unsigned char)tag[0])) == 'h' && isdigit((int)(unsigned char)tag[1])) /* cast to int - 2/22/00 */
        structure |= IN_HEADER; /* Out */
    /* EM, STRONG  */
    else if ((strcasecmp(tag, "/em") == 0) || (strcasecmp(tag, "/strong") == 0))
        structure &= ~IN_EMPHASIZED; /* Out */
    else if ((strcasecmp(tag, "em") == 0) || (strcasecmp(tag, "strong") == 0))
        structure |= IN_EMPHASIZED; /* In */
    /* B, I are seperate for semantics  */
    else if ((strcasecmp(tag, "/b") == 0) || (strcasecmp(tag, "/i") == 0))
        structure &= ~IN_EMPHASIZED; /* Out */
    else if ((strcasecmp(tag, "b") == 0) || (strcasecmp(tag, "i") == 0))
        structure |= IN_EMPHASIZED; /* In */
    /* The End  */

    if (endOfTag != NULL)
    {
        *endOfTag = oldChar;
    }
    return structure;
}
Ejemplo n.º 30
0
fm_s32 cfg_parser(fm_s8 *buffer, CFG_HANDLER handler, fm_cust_cfg *cfg)
{
    fm_s32 ret = 0;
    fm_s8 *p = buffer;
    fm_s8 *group_start = NULL;
    fm_s8 *key_start = NULL;
    fm_s8 *value_start = NULL;

    enum fm_cfg_parser_state state = FM_CFG_STAT_NONE;

    FMR_ASSERT(p);

    for (p = buffer; *p != '\0'; p++) {
        switch (state) {
        case FM_CFG_STAT_NONE: {
            if (*p == '[') {
                /* if we get char '[' in none state, it means a new group name start */
                state = FM_CFG_STAT_GROUP;
                group_start = p + 1;
            } else if (*p == COMMENT_CHAR) {
                /* if we get char '#' in none state, it means a new comment start */
                state = FM_CFG_STAT_COMMENT;
            } else if (!isspace(*p) && (*p != '\n') && (*p != '\r')) {
                /* if we get an nonspace char in none state, it means a new key start */
                state = FM_CFG_STAT_KEY;
                key_start = p;
            }

            break;
        }
        case FM_CFG_STAT_GROUP: {
            if (*p == ']') {
                /* if we get char ']' in group state, it means a group name complete */
                *p = '\0';
                /* FIX_ME */
                /* record group name */
                state = FM_CFG_STAT_NONE;
                trim_string(&group_start);
                /* WCN_DBG(FM_NTC|MAIN, "g=%s\n", group_start); */
            }

            break;
        }
        case FM_CFG_STAT_COMMENT: {
            if (*p == '\n') {
                /* if we get char '\n' in comment state, it means new line start */
                state = FM_CFG_STAT_NONE;
                group_start = p + 1;
            }

            break;
        }
        case FM_CFG_STAT_KEY: {
            if (*p == DELIMIT_CHAR) {
                /* if we get char '=' in key state, it means a key name complete */
                *p = '\0';
                /* FIX_ME */
                /* record key name */
                state = FM_CFG_STAT_VALUE;
                value_start = p + 1;
                trim_string(&key_start);
                /* WCN_DBG(FM_NTC|MAIN, "k=%s\n", key_start); */
            }

            break;
        }
        case FM_CFG_STAT_VALUE: {
            if (*p == '\n' || *p == '\r') {
                /* if we get char '\n' or '\r' in value state, it means a value complete */
                *p = '\0';
                /* record value */
                trim_string(&value_start);
                /* WCN_DBG(FM_NTC|MAIN, "v=%s\n", value_start); */

                if (handler) {
                    ret =
                        handler(group_start, key_start, value_start,
                                cfg);
                }

                state = FM_CFG_STAT_NONE;
            }

            break;
        }
        default:
            break;
        }
    }

    return ret;
}