Sat, 26 Nov 2022 19:15:33 +0100
implement successor listener, fix webserver_reconfig
/* * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. * * Copyright 2013 Olaf Wintermann. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #include <cx/string.h> #include <cx/linked_list.h> #include <cx/array_list.h> #include <cx/compare.h> #include "../public/nsapi.h" #include "object.h" #include "util.h" #include "pool.h" #include "../daemon/func.h" httpd_object* object_new(pool_handle_t *pool, char *name) { httpd_object *obj = pool_malloc(pool, sizeof(httpd_object)); obj->pool = pool; obj->name = name; obj->path = NULL; // create directive table obj->dt = pool_calloc(pool, NUM_NSAPI_TYPES - 1, sizeof(struct dtable)); obj->nd = NUM_NSAPI_TYPES - 1; return obj; } void object_free(httpd_object *obj) { //free(obj->name); //free(obj->dt); } int object_add_directive(httpd_object *obj, directive *dir, int dt) { dtable *l = object_get_dtable(obj, dt); // allocate space for the new directive if(l->ndir >= l->alloc) { l->alloc += 8; directive **drs = pool_realloc(obj->pool, l->dirs, (l->alloc)*sizeof(void*)); if(!drs) { l->alloc -= 8; return -1; } l->dirs = drs; } // add directive l->dirs[l->ndir++] = dir; return 0; } /* objset functions */ httpd_objset* objset_create(pool_handle_t *pool) { httpd_objset *os = pool_malloc(pool, sizeof(httpd_objset)); os->obj = pool_calloc(pool, 2, sizeof(void*)); os->pos = 0; return os; } void objset_add_object(pool_handle_t *p, httpd_objset *os, httpd_object *obj) { if(os->pos != 0 && os->pos % 2 == 0) { os->obj = pool_realloc(p, os->obj, (os->pos + 2) * sizeof(void*)); } os->obj[os->pos] = obj; os->pos++; } void httpobjconf_add_object(HTTPObjectConfig *conf, httpd_object *obj) { conf->nobj++; conf->objects = realloc(conf->objects, conf->nobj * sizeof(void*)); conf->objects[conf->nobj - 1] = obj; } void nsapi_context_next_stage(NSAPIContext *context) { context->dtable_index = 0; context->objset_index = -1; context->last_req_code = REQ_NOACTION; } /* ------------------------------ Expression ------------------------------ */ Expression* condition_create(pool_handle_t *pool, CxList *tokens) { size_t pos = 0; NSAPIExpression *expression = expr_parse_logical_expr(pool, tokens, &pos); if(!expression || pos != tokens->size) { return NULL; } return NULL; } typedef struct { pool_handle_t *pool; CxList *op_stack; CxList *ex_stack; CxList *tokens; size_t *pos; WSBool expect_value; WSBool expect_arg; } ExprParser; typedef struct { NSAPIExpressionOperator operator; cxstring identifier; int expect_value; int open_parenthesis; } ExprOpStackItem; static void expr_free(pool_handle_t *pool, NSAPIExpression *expr) { if(expr->left) { expr_free(pool, expr->left); } if(expr->right) { expr_free(pool, expr->right); } if(expr->type == NSAPI_EXPRESSION_STRING && expr->value.str.ptr) { pool_free(pool, (char*)expr->value.str.ptr); } else if(expr->type == NSAPI_EXPRESSION_VARIABLE && expr->value.var.ptr) { pool_free(pool, (char*)expr->value.var.ptr); } pool_free(pool, expr); } static NSAPIExpressionOperator expr_operator(cxstring token) { if(!cx_strcmp(token, cx_str(","))) { return NSAPI_EXPRESSION_ARG; } else if(!cx_strcmp(token, cx_str("+"))) { return NSAPI_EXPRESSION_ADD; } else if(!cx_strcmp(token, cx_str("-"))) { return NSAPI_EXPRESSION_SUB; } else if(!cx_strcmp(token, cx_str("*"))) { return NSAPI_EXPRESSION_MUL; } else if(!cx_strcmp(token, cx_str("/"))) { return NSAPI_EXPRESSION_DIV; } else if(!cx_strcmp(token, cx_str("%"))) { return NSAPI_EXPRESSION_MOD; } else if(!cx_strcmp(token, cx_str("not"))) { return NSAPI_EXPRESSION_NOT; } else if(!cx_strcmp(token, cx_str("and"))) { return NSAPI_EXPRESSION_AND; } else if(!cx_strcmp(token, cx_str("or"))) { return NSAPI_EXPRESSION_OR; } else if(!cx_strcmp(token, cx_str("xor"))) { return NSAPI_EXPRESSION_XOR; } else if(!cx_strcmp(token, cx_str("=="))) { return NSAPI_EXPRESSION_EQ; } else if(!cx_strcmp(token, cx_str("!="))) { return NSAPI_EXPRESSION_NEQ; } else if(!cx_strcmp(token, cx_str(">"))) { return NSAPI_EXPRESSION_GT; } else if(!cx_strcmp(token, cx_str("<"))) { return NSAPI_EXPRESSION_LT; } else if(!cx_strcmp(token, cx_str(">="))) { return NSAPI_EXPRESSION_GE; } else if(!cx_strcmp(token, cx_str("<="))) { return NSAPI_EXPRESSION_LE; } return NSAPI_EXPRESSION_NOOP; } static int token_is_int(cxstring token) { if(token.length == 0) { return 0; } size_t start = 0; if(token.ptr[0] == '-' || token.ptr[0] == '+') { if(token.length < 2) { return 0; } start++; } for(size_t i=start;i<token.length;i++) { if(!isdigit(token.ptr[i])) { return 0; } } return 1; } static int expr_set_value(pool_handle_t *pool, NSAPIExpression *expr, cxstring token) { if(token.length >= 2 && token.ptr[0] == '\"' && token.ptr[token.length-1] == '\"') { expr->value.str = cx_strcast(cx_strdup_a(pool_allocator(pool), cx_strsubsl(token, 1, token.length-2))); expr->type = NSAPI_EXPRESSION_STRING; } else if(token.length >= 2 && token.ptr[0] == '$' && isalpha(token.ptr[1])) { expr->value.var = cx_strcast(cx_strdup_a(pool_allocator(pool), cx_strsubs(token, 1))); expr->type = NSAPI_EXPRESSION_VARIABLE; } else if(token_is_int(token)) { if(!util_strtoint(token.ptr, &expr->value.i)) { return 1; } expr->type = NSAPI_EXPRESSION_INT; } else if(!strcmp(token.ptr, "true")) { expr->type = NSAPI_EXPRESSION_BOOL; expr->value.b = 1; } else if(!strcmp(token.ptr, "false")) { expr->type = NSAPI_EXPRESSION_BOOL; expr->value.b = 0; } else { return 1; } // TODO: double return 0; } cxstring expr_next_token(CxList *tokens, size_t *pos) { cxstring *token = cxListAt(tokens, *pos); if(token) { (*pos)++; return *token; } return (cxstring){NULL, 0}; } NSAPIExpression* expr_parser_pop(ExprParser *parser) { CxList *stack = parser->ex_stack; if(stack->size == 0) { return NULL; } NSAPIExpression *ret = *((NSAPIExpression**)cxListAt(stack, stack->size-1)); cxListRemove(stack, stack->size-1); return ret; } // takes items from ex_stack and adds a new operator expression to ex_stack static int expr_add_operator(ExprParser *parser, ExprOpStackItem *op) { NSAPIExpression *exp = pool_malloc(parser->pool, sizeof(NSAPIExpression)); exp->operator = op->operator; // op->expect_value == TRUE means, that the operator was found in a case // a value was expected. // For example: 1 + - 2 // After + a value is expected, but there is the - operator // in that case, the - operator is a unary expression if(op->expect_value) { // We expected a value but got an operator? This must be an unary operator if(op->operator == NSAPI_EXPRESSION_ARG && !parser->expect_arg) { // simplify unary arg pool_free(parser->pool, exp); parser->expect_value = TRUE; parser->expect_arg = FALSE; return 0; } exp->type = NSAPI_EXPRESSION_UNARY; exp->left = expr_parser_pop(parser); exp->right = NULL; } else { // binary operator exp->type = NSAPI_EXPRESSION_BINARY; exp->right = expr_parser_pop(parser); exp->left = expr_parser_pop(parser); } if(!exp->left && !exp->right) { return 1; // error } cxListAdd(parser->ex_stack, &exp); parser->expect_value = TRUE; parser->expect_arg = FALSE; return 0; } static int expr_add_func(ExprParser *parser, ExprOpStackItem *func) { NSAPIExpression *exp = pool_malloc(parser->pool, sizeof(NSAPIExpression)); if(!exp) { return 1; } exp->type = NSAPI_EXPRESSION_IDENTIFIER; exp->operator = NSAPI_EXPRESSION_CALL; exp->left = NULL; exp->right = NULL; exp->value.str = func->identifier; if(parser->ex_stack->size > 0) { NSAPIExpression *top = *((NSAPIExpression**)cxListAt(parser->ex_stack, parser->ex_stack->size - 1)); if(top && top->operator == NSAPI_EXPRESSION_ARG) { exp->left = top; cxListRemove(parser->ex_stack, parser->ex_stack->size - 1); } } if(cxListAdd(parser->ex_stack, &exp)) { return 1; } parser->expect_value = FALSE; return 0; } // converts the token to a value expression (int, bool, str, ...) // and adds it to parser->ex_stack // sets parser->expect_value to false static int expr_add_value(ExprParser *parser, cxstring token) { NSAPIExpression *exp = pool_malloc(parser->pool, sizeof(NSAPIExpression)); ZERO(exp, sizeof(NSAPIExpression)); if(expr_set_value(parser->pool, exp, token)) { return 1; } cxListAdd(parser->ex_stack, &exp); if(parser->expect_arg) { ExprOpStackItem argList; argList.expect_value = TRUE; argList.identifier = (cxstring){NULL, 0}; argList.open_parenthesis = FALSE; argList.operator = NSAPI_EXPRESSION_ARG; if(expr_add_operator(parser, &argList)) { return 1; } } parser->expect_value = FALSE; parser->expect_arg = FALSE; return 0; } static int token_is_identifier(cxstring token) { if(token.length == 0) { return 0; } if(!isalpha(token.ptr[0])) { return 0; } for(int i=1;i<token.length;i++) { if(!isalnum(token.ptr[i])) { return 0; } } if(!cx_strcmp(token, cx_str("true")) || !cx_strcmp(token, cx_str("false"))) { return 0; } return 1; } static NSAPIExpression* expr_parse_expr(ExprParser *parser) { CxList *op_stack = parser->op_stack; CxList *ex_stack = parser->ex_stack; // Shunting yard algorithm cxstring token = expr_next_token(parser->tokens, parser->pos); for(;token.ptr;token=expr_next_token(parser->tokens, parser->pos)) { NSAPIExpressionOperator op = expr_operator(token); if(op != NSAPI_EXPRESSION_NOOP) { ExprOpStackItem new_op; new_op.operator = op; new_op.identifier = (cxstring){NULL,0}; new_op.expect_value = parser->expect_value; new_op.open_parenthesis = FALSE; while(op_stack->size > 0) { ExprOpStackItem *stack_item = cxListAt(op_stack, op_stack->size-1); if(stack_item->operator == NSAPI_EXPRESSION_NOOP) { break; } // check presedence if(op >= stack_item->operator) { break; } if(expr_add_operator(parser, stack_item)) { return NULL; } cxListRemove(op_stack, op_stack->size-1); } cxListAdd(op_stack, &new_op); parser->expect_value = TRUE; parser->expect_arg = FALSE; } else if(token.length == 1 && token.ptr[0] == '(') { ExprOpStackItem *prev_op = NULL; if(op_stack->size > 0) { prev_op = cxListAt(op_stack, op_stack->size - 1); } if(prev_op && prev_op->operator == NSAPI_EXPRESSION_CALL) { // function call open parenthesis // we don't need to add a new op stack item, just mark function // call as open parenthesis prev_op->open_parenthesis = TRUE; parser->expect_arg = TRUE; } else { ExprOpStackItem new_op; new_op.operator = NSAPI_EXPRESSION_NOOP; new_op.identifier = (cxstring){NULL,0}; new_op.expect_value = 0; new_op.open_parenthesis = TRUE; cxListAdd(op_stack, &new_op); } parser->expect_value = TRUE; } else if(token.length == 1 && token.ptr[0] == ')') { int found_open_bracket = FALSE; ExprOpStackItem stack_item; while(op_stack->size > 0) { ExprOpStackItem *stack_item_ptr = cxListAt(op_stack, op_stack->size-1); stack_item = *stack_item_ptr; cxListRemove(op_stack, op_stack->size-1); if(stack_item.open_parenthesis) { found_open_bracket = TRUE; break; } else { if(expr_add_operator(parser, &stack_item)) { return NULL; } } } if(!found_open_bracket) { return NULL; } if(stack_item.operator == NSAPI_EXPRESSION_CALL) { if(expr_add_func(parser, &stack_item)) { return NULL; } } parser->expect_value = FALSE; parser->expect_arg = FALSE; } else if(token_is_identifier(token)) { ExprOpStackItem new_op; new_op.operator = NSAPI_EXPRESSION_CALL; new_op.identifier = token; new_op.expect_value = 0; new_op.open_parenthesis = FALSE; cxListAdd(op_stack, &new_op); parser->expect_value = FALSE; parser->expect_arg = FALSE; } else { if(expr_add_value(parser, token)) { return NULL; } } } while(op_stack->size > 0) { ExprOpStackItem *stack_item = cxListAt(op_stack, op_stack->size-1); if(stack_item->open_parenthesis) { return NULL; } if(expr_add_operator(parser, stack_item)) { return NULL; } cxListRemove(op_stack, op_stack->size-1); } if(ex_stack->size != 1) { return NULL; } NSAPIExpression **ret = cxListAt(ex_stack, 0); return *ret; } NSAPIExpression* expr_parse_logical_expr(pool_handle_t *pool, CxList *tokens, size_t *pos) { CxList *op_stack = cxArrayListCreate(pool_allocator(pool), cx_cmp_ptr, sizeof(ExprOpStackItem), 32); CxList *ex_stack = cxArrayListCreate(pool_allocator(pool), cx_cmp_ptr, sizeof(NSAPIExpression*), 32); ExprParser parser; parser.pool = pool; parser.op_stack = op_stack; parser.ex_stack = ex_stack; parser.tokens = tokens; parser.pos = pos; parser.expect_value = TRUE; parser.expect_arg = FALSE; NSAPIExpression *ret = expr_parse_expr(&parser); cxListDestroy(op_stack); cxListDestroy(ex_stack); return ret; } int condition_evaluate(Condition *condition, Session *sn, Request *rq) { return 1; }