/**
* extract the value of Content-Type header
* - src: pointer to C-T content
* - len: length of src
* - ctype: parsed C-T
* - flag: what to parse - bit mask of CT_TYPE, CT_CHARSET, CT_MSGR
*
* #return: 0 OK ; -1 error
*/
int m_extract_content_type(char* src, int len, t_content_type* ctype, int flag)
{
char *p, *end;
int f = 0, pos;
if( !src || len <=0 )
goto error;
p = src;
end = p + len;
while((p < end) && f != flag)
{
EAT_SPACES(p, end);
if((flag & CT_TYPE) && !(f & CT_TYPE))
{
NEXT_SEP(p, pos, end);
if(p[pos] == ';')
{
ctype->type.s = p;
ctype->type.len = pos;
SKIP_CHARS(p, pos+1, end);
f |= CT_TYPE;
continue;
}
}
if((flag & CT_CHARSET) && !(f & CT_CHARSET))
{
}
if((flag & CT_MSGR) && !(f & CT_MSGR))
{
}
}
return 0;
error:
return -1;
}
/*
* Read key blob from string buffer (null terminated) and convert it to
* binary format. Returns xmallocated blob, and if blob_len, version_major,
* version_minor, or is_public have non NULL value the length of blob,
* major and minor version numbers of format, and whatever the blob was
* private or public key are returned.
*/
unsigned char *ssh_key_blob_read_from_string(const char *str,
size_t *blob_len,
char **headers,
unsigned int *version_major,
unsigned int *version_minor,
Boolean *is_public)
{
unsigned char *blob, *blob2;
const char *base64blob, *crc64blob;
unsigned int number;
size_t base64blob_len, crc64blob_len;
const char *p, *compare, *again, *headers_beg, *headers_end;
unsigned char *p2;
Boolean public;
SshUInt32 crc32;
if (version_major != NULL)
*version_major = 0;
if (version_minor != NULL)
*version_minor = 0;
if (blob_len != NULL)
*blob_len = 0;
p = str;
#define SKIP_SPACE(p) \
do { while (isspace(*(p))) (p)++; } while (0)
#define EXPECT_CHAR(p,ch) \
do { if (*(p) != (ch)) goto error; } while (0)
#define SKIP_CHARS(p,ch) \
do { while (*(p) == (ch) || isspace(*(p))) (p)++; } while (0)
#define MATCH_STRING(p,str) \
do { for(; *(p) && *(str) == tolower(*(p));(str)++) { (p)++; SKIP_SPACE(p);}\
} while (0)
#define MATCH_STRING_GOTO_ERROR(p,str) \
do { MATCH_STRING((p),(str)); if (*(str)) goto error; } while (0)
#define READ_NUMBER(p,n) \
do { (n) = 0; SKIP_SPACE(p); for(; isdigit(*(p)); ) \
{ (n) = ((n) * 10) + (*(p) - '0'); (p)++; SKIP_SPACE(p); } } while (0)
SKIP_SPACE(p);
/* Read begin line */
EXPECT_CHAR(p, '-');
SKIP_CHARS(p, '-');
compare = "beginssh";
MATCH_STRING_GOTO_ERROR(p, compare);
again = p;
compare = "public";
MATCH_STRING(p, compare);
if (*compare)
{
p = again;
compare = "private";
MATCH_STRING_GOTO_ERROR(p, compare);
public = FALSE;
}
/*
* Executes matching of the precompiled pattern on the input string.
* Returns REG_OK or REG_NOMATCH depending on if we find a match or not.
*/
int
tre_match_fast(const fastmatch_t *fg, const void *data, size_t len,
tre_str_type_t type, int nmatch, regmatch_t pmatch[], int eflags)
{
unsigned int shift, u = 0, v = 0;
ssize_t j = 0;
int ret = REG_NOMATCH;
int mismatch;
const char *str_byte = data;
const void *startptr = NULL;
const tre_char_t *str_wide = data;
/* Calculate length if unspecified. */
if (len == (size_t)-1)
switch (type)
{
case STR_WIDE:
len = tre_strlen(str_wide);
break;
default:
len = strlen(str_byte);
break;
}
/* Shortcut for empty pattern */
if (fg->matchall)
{
if (!fg->nosub && nmatch >= 1)
{
pmatch[0].rm_so = 0;
pmatch[0].rm_eo = len;
}
if (fg->bol && fg->eol)
return (len == 0) ? REG_OK : REG_NOMATCH;
else
return REG_OK;
}
/* No point in going farther if we do not have enough data. */
switch (type)
{
case STR_WIDE:
if (len < fg->wlen)
return ret;
shift = fg->wlen;
break;
default:
if (len < fg->len)
return ret;
shift = fg->len;
}
/*
* REG_NOTBOL means not anchoring ^ to the beginning of the line, so we
* can shift one because there can't be a match at the beginning.
*/
if (fg->bol && (eflags & REG_NOTBOL))
j = 1;
/*
* Like above, we cannot have a match at the very end when anchoring to
* the end and REG_NOTEOL is specified.
*/
if (fg->eol && (eflags & REG_NOTEOL))
len--;
if (fg->reversed)
j = len - (type == STR_WIDE ? fg->wlen : fg->len);
/* Only try once at the beginning or ending of the line. */
if ((fg->bol || fg->eol) && !fg->newline && !(eflags & REG_NOTBOL) &&
!(eflags & REG_NOTEOL))
{
/* Simple text comparison. */
if (!((fg->bol && fg->eol) &&
(type == STR_WIDE ? (len != fg->wlen) : (len != fg->len))))
{
/* Determine where in data to start search at. */
j = fg->eol ? len - (type == STR_WIDE ? fg->wlen : fg->len) : 0;
SKIP_CHARS(j);
mismatch = fastcmp(fg, startptr, type);
if (mismatch == REG_OK)
{
if (fg->word && !IS_ON_WORD_BOUNDARY)
return ret;
if (!fg->nosub && nmatch >= 1)
{
pmatch[0].rm_so = j;
pmatch[0].rm_eo = j + (type == STR_WIDE ? fg->wlen : fg->len);
}
return REG_OK;
}
}
}
else
{
/* Quick Search / Turbo Boyer-Moore algorithm. */
do
{
SKIP_CHARS(j);
mismatch = fastcmp(fg, startptr, type);
if (mismatch == REG_OK)
{
if (fg->word)
CHECK_WORD_BOUNDARY;
if (fg->bol)
CHECK_BOL_ANCHOR;
if (fg->eol)
CHECK_EOL_ANCHOR;
if (!fg->nosub && nmatch >= 1)
{
pmatch[0].rm_so = j;
pmatch[0].rm_eo = j + ((type == STR_WIDE) ? fg->wlen : fg->len);
}
return REG_OK;
}
else if (mismatch > 0)
return mismatch;
mismatch = -mismatch - 1;
SHIFT;
} while (!IS_OUT_OF_BOUNDS);
}
return ret;
}
/**
* Gets whether the first non-whitespace character in \a s is a comment
* character.
*
* @param s The string to check.
* @return Returns a pointer to the first non-whitespace character in \a s only
* if it's a comment delimiter character; NULL otherwise.
*/
static inline char* is_line_comment( char const *s ) {
return is_comment_char( *SKIP_CHARS( s, WS_ST ) ) ? (char*)s : NULL;
}