const char * smpd_get_string(const char *str, char *val, int maxlen, int *num_chars)
{
smpd_enter_fn(FCNAME);
if (maxlen < 1)
{
*num_chars = 0;
smpd_exit_fn(FCNAME);
return NULL;
}
/* line up with the first token */
str = first_token(str);
if (str == NULL)
{
*num_chars = 0;
smpd_exit_fn(FCNAME);
return NULL;
}
/* copy the token */
token_copy(str, val, maxlen);
*num_chars = (int)strlen(val);
/* move to the next token */
str = next_token(str);
smpd_exit_fn(FCNAME);
return str;
}
static void iter_fn(void *str, void *new_list, void *orig_token)
{
t_token *new_token;
new_token = token_copy(orig_token);
token_set_text(new_token, str);
twl_lst_push_back(new_list, new_token);
}
t_ast_assignment *ast_assignment_new(t_token *token, char *key, char *value)
{
t_ast_assignment *ast_assignment;
ast_assignment = twl_malloc_x0(sizeof(t_ast_assignment));
ast_assignment->token = token_copy(token);
ast_assignment->key = twl_strdup(key);
ast_assignment->key_unexpanded = twl_strdup(key);
ast_assignment->value = value ? twl_strdup(value) : NULL;
ast_assignment->value_unexpanded = value ? twl_strdup(value) : NULL;
return (ast_assignment);
}
int smpd_get_string_arg(const char *str, const char *flag, char *val, int maxlen)
{
smpd_enter_fn(FCNAME);
if (maxlen < 1)
{
smpd_exit_fn(FCNAME);
return SMPD_FALSE;
}
/* line up with the first token */
str = first_token(str);
if (str == NULL)
{
smpd_exit_fn(FCNAME);
return SMPD_FALSE;
}
/* This loop will match the first instance of "flag = value" in the string. */
do
{
if (compare_token(str, flag) == 0)
{
str = next_token(str);
if (compare_token(str, SMPD_DELIM_STR) == 0)
{
str = next_token(str);
if (str == NULL)
{
smpd_exit_fn(FCNAME);
return SMPD_FALSE;
}
token_copy(str, val, maxlen);
smpd_exit_fn(FCNAME);
return SMPD_TRUE;
}
}
else
{
str = next_token(str);
}
} while (str);
smpd_exit_fn(FCNAME);
return SMPD_FALSE;
}
static t_token *expand_pattern(t_token *pattern)
{
t_expansion *expansion;
char *text;
t_token *ret;
expansion = expansion_new_from_token(pattern);
text = expansion_get_string_pattern_case(expansion);
if (expansion->error)
{
twl_dprintf(2, "%s\n", expansion->error);
expansion_del(expansion);
shenv_singleton()->shenv_shall_quit_curr_ast = true;
shenv_singleton()->last_exit_code = 1;
return (NULL);
}
ret = token_copy(pattern);
token_set_text(ret, text);
free(text);
expansion_del(expansion);
return (ret);
}
/*
* Parse variable name or structure element and output appropriate tokens.
* Passed with identifier in token, and declaration for token in decl.
* Returns with token terminating variable.
* Handles <member> { [ ( <expression> ) ] [ .<identifier> ] }
*/
int
parse_member(TOKEN *token, DECL_MEMBER *decl, DECL_ID *decl_id)
{
int token_class;
TOKEN member;
DECL_MEMBER *var_decl;
DECL_ID *var_decl_id;
/* Check for literal */
if (decl->literal) {
/* Yes - output case converted literal */
out_white_space(token);
out_cvt_name(token);
/* Return next token */
token_class = get_token(token);
return token_class;
}
token_copy(token, &member);
token_class = get_token(token);
/* Check for array subscript */
if (decl->array_bound) {
out_ident(&member, decl, decl_id);
if (token_class == LEFT_PAREN) {
/* Convert to open square bracket */
token->token_name[0] = '[';
out_token(token);
/* Parse expression to right parenthesis */
token_class = parse_expression(token);
if (token_class != RIGHT_PAREN) {
parse_error("')' expected");
return ERROR;
}
/* Convert to close square bracket */
token->token_name[0] = ']';
out_token(token);
token_class = get_token(token);
}
}
/* Check for .<identifier> */
if ((decl->type->token_type == STRUCTURE) && (token_class == PERIOD)) {
if (decl->array_bound)
/* Already printed identifier */
out_token(token);
else {
if (decl->at_ptr || decl_id->based_name) {
/*
* --- Note: Does not handle BASED AT variables!
*/
/* Print 'member->' */
out_token(&member);
out_str("->");
} else {
/* Print 'member.' */
out_ident(&member, decl, decl_id);
out_token(token);
}
}
token_class = get_token(token);
if (token_class != IDENTIFIER) {
parse_error("Illegal structure member");
return ERROR;
}
/* Find variable in list */
if (!find_list_symbol(token, decl->struct_list,
&var_decl, &var_decl_id)) {
parse_error("Undefined structure member");
return ERROR;
}
/* Parse this member now */
token_class = parse_member(token, var_decl, var_decl_id);
} else if (decl->array_bound == NULL)
out_ident(&member, decl, decl_id);
return token_class;
}
/*
* Parse statement starting with an identifier.
* Possibilities include:
* Assignment
* Procedure statement
*/
void
parse_identifier(TOKEN *first_token)
{
TOKEN token, next_token;
TOKEN param_token, attrib_token, type_token;
int token_class, next_token_class;
DECL *decl_list, *extra_decl_list;
PARAM_LIST *param_list, *param_ptr;
DECL_MEMBER *decl_ptr;
DECL_ID *decl_id;
BOOLEAN extern_proc, got_type, interrupt_proc;
char *tmp_text_ptr;
/* Check for label or procedure */
tmp_text_ptr = text_ptr;
token_class = get_token(&token);
if (token_class == LABEL) {
/* Determine if label or procedure definition */
next_token_class = get_token(&next_token);
if ((next_token_class == RESERVED) &&
(next_token.token_type == PROCEDURE)) {
/*
* Procedure - Check for parameter list
*/
param_list = NULL;
token_class = get_token(¶m_token);
if (token_class == LEFT_PAREN) {
/* Yes - get parameter list */
get_param_list(¶m_list);
/* Get token after parameter list */
token_class = get_token(&attrib_token);
} else
/* No param list - save as attribute */
token_copy(¶m_token, &attrib_token);
out_white_space(first_token);
extern_proc = FALSE;
interrupt_proc = FALSE;
got_type = (token_class == RESERVED) &&
(attrib_token.token_type >= BYTE) &&
(attrib_token.token_type <= SELECTOR);
if (got_type) {
/*
* Process [ <type> ]
*/
token_copy(&attrib_token, &type_token);
token_class = get_token(&attrib_token);
}
while (token_class == RESERVED) {
if (attrib_token.token_type == INTERRUPT) {
/*
* Process [ <interrupt> ]
*/
interrupt_proc = TRUE;
token_class = get_token(&attrib_token);
if (token_class == NUMERIC)
/* Interrupt number */
token_class = get_token(&attrib_token);
} else
/*
* Process [ EXTERNAL | { [ PUBLIC ] [ REENTRANT ] } ]
*/
if (attrib_token.token_type == EXTERNAL) {
out_str("extern");
out_must_white(&attrib_token);
extern_proc = TRUE;
token_class = get_token(&attrib_token);
} else
if ((attrib_token.token_type == PUBLIC) ||
(attrib_token.token_type == REENTRANT)) {
do {
if (attrib_token.token_type == PUBLIC) {
/* Ignore for now */
token_class = get_token(&attrib_token);
} else
if (attrib_token.token_type == REENTRANT) {
/* Ignore for now */
token_class = get_token(&attrib_token);
} else
break;
} while (token_class == RESERVED);
} else
break;
}
if (token_class != END_OF_LINE) {
parse_error("';' expected");
return;
}
if (interrupt_proc && !extern_proc)
parse_warning("INTERRUPT procedure declared");
/* Create declaration for procedure */
get_element_ptr(&decl_ptr);
get_var_ptr(&decl_ptr->name_list);
/* Type = PROCEDURE */
get_token_ptr(&decl_ptr->type);
token_copy(&next_token, decl_ptr->type);
/* Name = procedure name */
get_token_ptr(&decl_ptr->name_list->name);
token_copy(first_token, decl_ptr->name_list->name);
/* Flag if parameter list */
if (param_list)
decl_ptr->initialization = DATA;
/* Add it to context */
add_to_context(decl_ptr);
if (got_type) {
/* Output procedure type */
out_token_name(&type_token);
out_must_white(&type_token);
}
/* Output procedure name */
out_token_name(first_token);
if (extern_proc) {
out_str("()");
if (param_list)
/* Parse parameter declarations */
parse_param_list(param_list, &decl_list,
&extra_decl_list);
out_char(';');
/* Eat closing 'END [<proc name>];' */
token_class = get_token(&token);
if ((token_class != RESERVED) ||
(token.token_type != END)) {
parse_error("END expected");
return;
}
out_white_space(&token);
token_class = get_token(&token);
if (token_class == IDENTIFIER) {
token_class = get_token(&token);
}
if (token_class != END_OF_LINE) {
parse_error("';' expected");
}
return;
} else
if (param_list) {
out_token(¶m_token);
/* Output parameter list */
param_ptr = param_list;
while (param_ptr) {
out_token(¶m_ptr->param);
param_ptr = param_ptr->next_param;
if (param_ptr)
out_char(',');
}
out_char(')');
/* Parse parameter declarations */
parse_param_list(param_list, &decl_list,
&extra_decl_list);
/* Output declarations */
if (decl_list) {
out_decl(decl_list);
/* Add declarations to context */
add_decl_to_context(decl_list);
}
out_str("\n{"); /* } for dumb vi */
if (extra_decl_list) {
out_decl(extra_decl_list);
/* Add declarations to context */
add_decl_to_context(extra_decl_list);
}
/* Discard declarations */
free_decl(decl_list);
free_decl(extra_decl_list);
} else
/* No parameter list */
out_str("()\n{"); /* } for dumb vi */
/* Create new context */
new_context(PROCEDURE, first_token);
/* Parse statements to END */
parse_to_end();
/* Pop procedure context */
pop_context();
} else {
/*
* Label - add label name
*/
out_token(first_token);
/* Add colon */
out_token(&token);
/* Is this a defined label or a module? */
if (find_symbol(first_token, &decl_ptr, &decl_id)) {
if (decl_ptr->type->token_class == LABEL) {
/* Label - new context */
new_context(MODULE, first_token);
parse_statement(&next_token);
pop_context();
} else {
parse_error("Illegal label name");
return;
}
} else
parse_statement(&next_token);
}
return;
}
/* Assignment statement */
text_ptr = tmp_text_ptr;
token_copy(first_token, &token);
token_class = parse_variable(&token, &decl_ptr, &decl_id);
/* Check for multiple assignments */
while (token_class == COMMA) {
/* Print ' =' instead of ',' */
out_str(" =");
out_white_space(&token);
/* Get identifier part of next assignment variable */
token_class = get_token(&token);
if (token_class != IDENTIFIER) {
parse_error("Illegal assignment");
return;
}
/* Parse remainder of variable (if any) */
token_class = parse_variable(&token, &decl_ptr, &decl_id);
}
if (token_class == OPERATOR) {
if (token.token_type != EQUAL) {
parse_error("Illegal use of identifier");
return;
}
out_token(&token);
/* Check for POINTER assignment */
if (decl_ptr->type->token_type == POINTER) {
/* Yes - cast it */
out_str(" (");
out_str(TYPE_POINTER);
out_str(" *) ");
}
if (parse_expression(&token) != END_OF_LINE)
parse_error("';' expected");
else
out_token(&token);
return;
} else
if (token_class != LABEL) {
parse_error("Illegal use of identifier");
return;
}
}
token_t parse_new_token(word_t *token)
{
token_t cls = NONE;
unsigned char *cp;
bool done = false;
/* If saved IPADDR, truncate last octet */
if ( block_on_subnets && save_class == IPADDR )
{
byte *t = xmemrchr(ipsave->u.text, '.', ipsave->leng);
if (t == NULL)
save_class = NONE;
else
{
ipsave->leng = (uint) (t - ipsave->u.text);
token_set( token, ipsave->u.text, ipsave->leng);
cls = save_class;
done = true;
}
}
while (!done) {
uint leng;
byte *text;
cls = (*lexer->yylex)();
token->leng = lexer->get_parser_token(&token->u.text);
Z(token->u.text[token->leng]); /* for easier debugging - removable */
leng = token->leng;
text = token->u.text;
if (DEBUG_TEXT(2)) {
word_puts(token, 0, dbgout);
fputc('\n', dbgout);
}
if (cls == NONE) /* End of message */
break;
switch (cls) {
case EOH: /* end of header - bogus if not empty */
if (leng > max_token_len)
continue;
if (msg_state->mime_type == MIME_MESSAGE)
mime_add_child(msg_state);
if (leng == 1)
continue;
else { /* "spc:invalid_end_of_header" */
token_copy( &yylval, nonblank_line);
done = true;
}
break;
case BOUNDARY: /* don't return boundary tokens to the user */
continue;
case VERP: /* Variable Envelope Return Path */
{
byte *st = (byte *)text;
byte *in;
byte *fst = NULL;
byte *lst = NULL;
for (in = st; *in != '\0'; in += 1) {
if (*in == '-') {
if (fst == NULL)
fst = in;
lst = in;
}
}
if (fst != NULL && lst != NULL && lst - fst > 3) {
byte *ot = fst;
*ot++ = '-';
*ot++ = '#';
for (in = lst; *in != '\0'; in += 1, ot += 1)
*ot = *in;
token->leng = leng = (uint) (ot - st);
}
Z(token->u.text[token->leng]); /* for easier debugging - removable */
}
break;
case HEADKEY:
{
if (!header_line_markup || *text == '\0')
continue;
else {
const char *delim = strchr((const char *)text, ':');
leng = (uint) (delim - (const char *)text);
if (leng > max_token_len)
continue;
token_set( &yylval, text, leng);
}
}
/*@fallthrough@*/
case TOKEN: /* ignore anything when not reading text MIME types */
if (leng < min_token_len)
continue;
/*@fallthrough@*/
case MONEY: /* 2 character money is OK */
if (leng > max_token_len)
continue;
token->u.text = text;
token->leng = leng;
if (token_prefix == NULL) {
switch (msg_state->mime_type) {
case MIME_TEXT:
case MIME_TEXT_HTML:
case MIME_TEXT_PLAIN:
case MIME_MULTIPART:
break;
case MIME_MESSAGE:
case MIME_APPLICATION:
case MIME_IMAGE:
continue;
default:
continue;
}
}
break;
case MESSAGE_ID:
/* special token; saved for formatted output, but not returned to bogofilter */
/** \bug: the parser MUST be aligned with lexer_v3.l! */
if (leng < max_token_len)
{
while (!isspace(text[0])) {
text += 1;
leng -= 1;
}
while (isspace(text[0])) {
text += 1;
leng -= 1;
}
token_set( msg_id, text, leng);
}
continue;
case QUEUE_ID:
/* special token; saved for formatted output, but not returned to bogofilter */
/** \bug: the parser MUST be aligned with lexer_v3.l! */
if (*queue_id->u.text == '\0' &&
leng < max_token_len )
{
while (isspace(text[0])) {
text += 1;
leng -= 1;
}
if (memcmp(text, "id", 2) == 0) {
text += 2;
leng -= 2;
}
while (isspace(text[0])) {
text += 1;
leng -= 1;
}
if (text[0] == '<') {
text += 1;
leng -= 1;
}
if (text[leng-1] == '>') {
leng -= 1;
}
leng = min(queue_id->leng, leng);
memcpy( queue_id->u.text, text, leng );
Z(queue_id->u.text[leng]);
}
continue;
case MESSAGE_ADDR:
{
/* trim brackets */
text += 1;
leng -= 2;
Z(text[leng]); /* for easier debugging - removable */
token_set( &yylval, text, leng);
/* if top level, no address, not localhost, .... */
if (token_prefix == w_recv &&
msg_state->parent == NULL &&
*msg_addr->u.text == '\0' &&
strcmp((char *)text, "127.0.0.1") != 0)
{
/* Not guaranteed to be the originating address of the message. */
memcpy( msg_addr->u.text, yylval.u.text, min(msg_addr->leng, yylval.leng)+D );
Z(msg_addr->u.text[yylval.leng]);
}
}
/*@fallthrough@*/
case IPADDR:
if (block_on_subnets)
{
int q1, q2, q3, q4;
/*
* Trick collected by ESR in real time during John
* Graham-Cummings's talk at Paul Graham's spam conference
* in January 2003... Some spammers know that people are
* doing recognition on spamhaus IP addresses. They use
* the fact that HTML clients normally interpret IP addresses
* by doing a simple accumulate-and-shift algorithm; they
* add large random multiples of 256 to the quads to
* mask their origin. Nuke the high bits to unmask the
* address.
*/
if (sscanf((const char *)text, "%d.%d.%d.%d", &q1, &q2, &q3, &q4) == 4)
/* safe because result string guaranteed to be shorter */
sprintf((char *)text, "%d.%d.%d.%d",
q1 & 0xff, q2 & 0xff, q3 & 0xff, q4 & 0xff);
leng = strlen((const char *)text);
token->u.text = text;
token->leng = leng;
token_copy( ipsave, token );
save_class = IPADDR;
return (cls);
}
token->u.text = text;
token->leng = leng;
break;
case NONE: /* nothing to do */
break;
case MSG_COUNT_LINE:
msg_count_file = true;
multi_token_count = 1;
header_line_markup = false;
token_prefix = NULL;
lexer = &msg_count_lexer;
if (mbox_mode) {
/* Allows processing multiple messages, **
** but only a single file. */
reader_more = msgcount_more;
}
continue;
case BOGO_LEX_LINE:
token_set( &yylval, text, leng);
done = true;
break;
}
if (DEBUG_TEXT(1)) {
word_puts(&yylval, 0, dbgout);
fputc('\n', dbgout);
}
/* eat all long words */
if (token->leng <= max_token_len)
done = true;
}
if (!msg_count_file) {
/* Remove trailing blanks */
/* From "From ", for example */
while (token->leng > 1 && token->u.text[token->leng-1] == ' ') {
token->leng -= 1;
token->u.text[token->leng] = (byte) '\0';
}
/* Remove trailing colon */
if (token->leng > 1 && token->u.text[token->leng-1] == ':') {
token->leng -= 1;
token->u.text[token->leng] = (byte) '\0';
}
if (replace_nonascii_characters) {
/* replace nonascii characters by '?'s */
for (cp = token->u.text; cp < token->u.text+token->leng; cp += 1)
*cp = casefold_table[*cp];
}
}
return(cls);
}
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* check_norris_loves_the_norminette.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: chuck <*****@*****.**> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2042/02/30 42:00:00 by chuck #+# #+# */
/* Updated: 2042/02/30 41:59:59 by chuck ### ########.fr */
/* */
/* ************************************************************************** */
#include "ast/nodes/ast_pipe_item.h"
void ast_pipe_item_set_separator(t_ast_pipe_item *this, t_token *token)
{
this->separator = token_copy(token);
}
