Return to lexparser.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / utils

Annotation of embedaddon/strongswan/src/libstrongswan/utils/lexparser.c, revision 1.1

1.1     ! misho       1: /*
        !             2:  * Copyright (C) 2001-2006 Andreas Steffen
        !             3:  *
        !             4:  * This program is free software; you can redistribute it and/or modify it
        !             5:  * under the terms of the GNU General Public License as published by the
        !             6:  * Free Software Foundation; either version 2 of the License, or (at your
        !             7:  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
        !             8:  *
        !             9:  * This program is distributed in the hope that it will be useful, but
        !            10:  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
        !            11:  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
        !            12:  * for more details.
        !            13:  */
        !            14: 
        !            15: #include "lexparser.h"
        !            16: 
        !            17: /**
        !            18:  * eat whitespace
        !            19:  */
        !            20: bool eat_whitespace(chunk_t *src)
        !            21: {
        !            22:        while (src->len > 0 && (*src->ptr == ' ' || *src->ptr == '\t'))
        !            23:        {
        !            24:                src->ptr++;  src->len--;
        !            25:        }
        !            26:        return  src->len > 0 && *src->ptr != '#';
        !            27: }
        !            28: 
        !            29: /**
        !            30:  * compare string with chunk
        !            31:  */
        !            32: bool match(const char *pattern, const chunk_t *ch)
        !            33: {
        !            34:        return ch->len == strlen(pattern) && strncmp(pattern, ch->ptr, ch->len) == 0;
        !            35: }
        !            36: 
        !            37: /**
        !            38:  * extracts a token ending with the first occurrence of a given termination symbol
        !            39:  */
        !            40: bool extract_token(chunk_t *token, const char termination, chunk_t *src)
        !            41: {
        !            42:        u_char *eot = memchr(src->ptr, termination, src->len);
        !            43: 
        !            44:        if (termination == ' ')
        !            45:        {
        !            46:                u_char *eot_tab = memchr(src->ptr, '\t', src->len);
        !            47: 
        !            48:                /* check if a tab instead of a space terminates the token */
        !            49:                eot = ( eot_tab == NULL || (eot && eot < eot_tab) ) ? eot : eot_tab;
        !            50:        }
        !            51: 
        !            52:        /* initialize empty token */
        !            53:        *token = chunk_empty;
        !            54: 
        !            55:        if (eot == NULL) /* termination symbol not found */
        !            56:        {
        !            57:                return FALSE;
        !            58:        }
        !            59: 
        !            60:        /* extract token */
        !            61:        token->ptr = src->ptr;
        !            62:        token->len = (u_int)(eot - src->ptr);
        !            63: 
        !            64:        /* advance src pointer after termination symbol */
        !            65:        src->ptr = eot + 1;
        !            66:        src->len -= (token->len + 1);
        !            67: 
        !            68:        return TRUE;
        !            69: }
        !            70: 
        !            71: /**
        !            72:  * extracts a token ending with the first occurrence of a given null-terminated string
        !            73:  */
        !            74: bool extract_token_str(chunk_t *token, const char *termination, chunk_t *src)
        !            75: {
        !            76:        u_char *eot = memstr(src->ptr, termination, src->len);
        !            77:        size_t l = strlen(termination);
        !            78: 
        !            79:        /* initialize empty token */
        !            80:        *token = chunk_empty;
        !            81: 
        !            82:        if (eot == NULL) /* termination string not found */
        !            83:        {
        !            84:                return FALSE;
        !            85:        }
        !            86: 
        !            87:        /* extract token */
        !            88:        token->ptr = src->ptr;
        !            89:        token->len = (u_int)(eot - src->ptr);
        !            90: 
        !            91:        /* advance src pointer after termination string */
        !            92:        src->ptr = eot + l;
        !            93:        src->len -= (token->len + l);
        !            94: 
        !            95:        return TRUE;
        !            96: }
        !            97: 
        !            98: /**
        !            99:  *  fetches a new line terminated by \n or \r\n
        !           100:  */
        !           101: bool fetchline(chunk_t *src, chunk_t *line)
        !           102: {
        !           103:        if (src->len == 0) /* end of src reached */
        !           104:                return FALSE;
        !           105: 
        !           106:        if (extract_token(line, '\n', src))
        !           107:        {
        !           108:                if (line->len > 0 && *(line->ptr + line->len -1) == '\r')
        !           109:                        line->len--;  /* remove optional \r */
        !           110:        }
        !           111:        else /*last line ends without newline */
        !           112:        {
        !           113:                *line = *src;
        !           114:                src->ptr += src->len;
        !           115:                src->len = 0;
        !           116:        }
        !           117:        return TRUE;
        !           118: }
        !           119: 
        !           120: err_t extract_value(chunk_t *value, chunk_t *line)
        !           121: {
        !           122:        char delimiter = ' ';
        !           123: 
        !           124:        if (!eat_whitespace(line))
        !           125:        {
        !           126:                *value = chunk_empty;
        !           127:                return NULL;
        !           128:        }
        !           129:        if (*line->ptr == '\'' || *line->ptr == '"')
        !           130:        {
        !           131:                delimiter = *line->ptr;
        !           132:                line->ptr++;  line->len--;
        !           133:        }
        !           134:        if (!extract_token(value, delimiter, line))
        !           135:        {
        !           136:                if (delimiter == ' ')
        !           137:                {
        !           138:                        *value = *line;
        !           139:                        line->len = 0;
        !           140:                }
        !           141:                else
        !           142:                {
        !           143:                        return "missing second delimiter";
        !           144:                }
        !           145:        }
        !           146:        return NULL;
        !           147: }
        !           148: 
        !           149: /**
        !           150:  * extracts a parameter: value pair
        !           151:  */
        !           152: err_t extract_parameter_value(chunk_t *name, chunk_t *value, chunk_t *line)
        !           153: {
        !           154:        /* extract name */
        !           155:        if (!extract_token(name,':', line))
        !           156:        {
        !           157:                return "missing ':'";
        !           158:        }
        !           159: 
        !           160:        /* extract value */
        !           161:        return extract_value(value, line);
        !           162: }