/*

 *   This program is free software; you can redistribute it and/or modify

 *   it under the terms of the GNU General Public License as published by

 *   the Free Software Foundation; either version 2 of the License, or

 *   (at your option) any later version.

 *

 *   This program is distributed in the hope that it will be useful,

 *   but WITHOUT ANY WARRANTY; without even the implied warranty of

 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *   GNU General Public License for more details.

 *

 *   You should have received a copy of the GNU General Public License

 *   along with this program; if not, write to the Free Software

 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA

 */

/**

 * $Id: b715a702ef0052a76afee767462061130fc2bf3f $

 *

 * @file unlang/limit.c

 * @brief Unlang "limit" keyword evaluation.

 *

 * @copyright 2022 Network RADIUS SAS (legal@networkradius.com)

 */

RCSID("$Id: b715a702ef0052a76afee767462061130fc2bf3f $")

#include <freeradius-devel/server/rcode.h>

#include "group_priv.h"

#include "limit_priv.h"

typedef struct {

  uint32_t        active_callers;

} unlang_thread_limit_t;

typedef struct {

  unlang_thread_limit_t     *thread;

  uint32_t        limit;

  request_t       *request;

  fr_value_box_list_t     result;

} unlang_frame_state_limit_t;

/** Send a signal (usually stop) to a request

 *

 * @param[in] request   The current request.

 * @param[in] frame   current stack frame.

 * @param[in] action    to signal.

 */

static void unlang_limit_signal(UNUSED request_t *request, unlang_stack_frame_t *frame, fr_signal_t action)

{

  unlang_frame_state_limit_t  *state = talloc_get_type_abort(frame->state, unlang_frame_state_limit_t);

  if (action == FR_SIGNAL_CANCEL) {

    state->thread->active_callers--;

  }

}

static unlang_action_t unlang_limit_resume_done(UNUSED unlang_result_t *p_result, UNUSED request_t *request, unlang_stack_frame_t *frame)

{

  unlang_frame_state_limit_t  *state = talloc_get_type_abort(frame->state, unlang_frame_state_limit_t);

  state->thread->active_callers--;

  return UNLANG_ACTION_CALCULATE_RESULT;

}

static unlang_action_t unlang_limit_enforce(UNUSED unlang_result_t *p_result, request_t *request, unlang_stack_frame_t *frame)

{

  unlang_frame_state_limit_t  *state = talloc_get_type_abort(frame->state, unlang_frame_state_limit_t);

  unlang_action_t     action;

  state->thread = unlang_thread_instance(frame->instruction);

  fr_assert(state->thread != NULL);

  if (state->thread->active_callers >= state->limit) return UNLANG_ACTION_FAIL;

  frame_repeat(frame, unlang_limit_resume_done);

  action = unlang_interpret_push_children(NULL, request, RLM_MODULE_NOT_SET, UNLANG_NEXT_STOP);

  state->thread->active_callers += (action == UNLANG_ACTION_PUSHED_CHILD);

  return action;

}

static unlang_action_t unlang_limit_xlat_done(unlang_result_t *p_result, request_t *request, unlang_stack_frame_t *frame)

{

  unlang_frame_state_limit_t  *state = talloc_get_type_abort(frame->state, unlang_frame_state_limit_t);

  fr_value_box_t      *box = fr_value_box_list_head(&state->result);

  if (unlikely(!box)) RETURN_UNLANG_FAIL;

  /*

   *  compile_limit() ensures that the tmpl is cast to uint32, so we don't have to do any more work here.

   */

  state->limit = box->vb_uint32;

  return unlang_limit_enforce(p_result, request, frame);

}

static unlang_action_t unlang_limit(unlang_result_t *p_result, request_t *request, unlang_stack_frame_t *frame)

{

  unlang_group_t      *g;

  unlang_limit_t      *gext;

  unlang_frame_state_limit_t  *state = talloc_get_type_abort(frame->state, unlang_frame_state_limit_t);

  g = unlang_generic_to_group(frame->instruction);

  gext = unlang_group_to_limit(g);

  state->request = request;

  if (!gext->vpt) {

    state->limit = gext->limit;

    return unlang_limit_enforce(p_result, request, frame);

  }

  fr_value_box_list_init(&state->result);

  if (unlang_tmpl_push(state, NULL, &state->result, request, gext->vpt, NULL, UNLANG_SUB_FRAME) < 0) return UNLANG_ACTION_FAIL;

  frame_repeat(frame, unlang_limit_xlat_done);

  return UNLANG_ACTION_PUSHED_CHILD;

}

static unlang_t *unlang_compile_limit(unlang_t *parent, unlang_compile_ctx_t *unlang_ctx, CONF_ITEM const *ci)

{

  CONF_SECTION    *cs = cf_item_to_section(ci);

  char const    *name2;

  unlang_t    *c;

  unlang_group_t    *g;

  unlang_limit_t    *gext;

  tmpl_t      *vpt = NULL;

  fr_token_t    token;

  ssize_t     slen;

  tmpl_rules_t    t_rules;

  /*

   *  limit <number>

   */

  name2 = cf_section_name2(cs);

  if (!name2) {

    cf_log_err(cs, "You must specify a value for 'limit'");

  print_url:

    cf_log_err(ci, DOC_KEYWORD_REF(limit));

    return NULL;

  }

  if (!cf_item_next(cs, NULL)) return UNLANG_IGNORE;

  g = unlang_group_allocate(parent, cs, UNLANG_TYPE_LIMIT);

  if (!g) return NULL;

  c = unlang_group_to_generic(g);

  c->name = "limit";

  c->debug_name = talloc_typed_asprintf(c, "limit %s", name2);

  gext = unlang_group_to_limit(g);

  token = cf_section_name2_quote(cs);

  /*

   *  We don't allow unknown attributes here.

   */

  t_rules = *(unlang_ctx->rules);

  t_rules.attr.allow_unknown = false;

  RULES_VERIFY(&t_rules);

  slen = tmpl_afrom_substr(gext, &vpt,

         &FR_SBUFF_IN_STR(name2),

         token,

         NULL,

         &t_rules);

  if (!vpt) {

  syntax_error:

    cf_canonicalize_error(cs, slen, "Failed parsing argument to 'limit'", name2);

  error:

    talloc_free(g);

    goto print_url;

  }

  gext->vpt = vpt;

  /*

   *  Fixup the tmpl so that we know it's somewhat sane.

   */

  if (!pass2_fixup_tmpl(gext, &vpt, cf_section_to_item(cs), unlang_ctx->rules->attr.dict_def)) {

    goto error;

  }

  if (tmpl_is_list(vpt)) {

    cf_log_err(cs, "Cannot use list as argument for 'limit' statement");

    goto error;

  }

  if (tmpl_contains_regex(vpt)) {

    cf_log_err(cs, "Cannot use regular expression as argument for 'limit' statement");

    goto error;

  }

  if (tmpl_is_data(vpt) && (token == T_BARE_WORD)) {

    fr_value_box_t box;

    if (fr_value_box_cast(NULL, &box, FR_TYPE_UINT32, NULL, tmpl_value(vpt)) < 0) goto syntax_error;

    gext->limit = box.vb_uint32;

  } else {

    /*

     *  Attribute or xlat MUST be cast to a 32-bit unsigned number.

     */

    if (tmpl_cast_set(vpt, FR_TYPE_UINT32) < 0) {

      cf_log_perr(cs, "Failed setting cast type");

      goto syntax_error;

    }

  }

  return unlang_compile_children(g, unlang_ctx);

}

void unlang_limit_init(void)

{

  unlang_register(&(unlang_op_t){

      .name = "limit",

      .type = UNLANG_TYPE_LIMIT,

      .flag = UNLANG_OP_FLAG_DEBUG_BRACES,

      .compile = unlang_compile_limit,

      .interpret = unlang_limit,

      .signal = unlang_limit_signal,

      .unlang_size = sizeof(unlang_limit_t),

      .unlang_name = "unlang_limit_t",

      .frame_state_size = sizeof(unlang_frame_state_limit_t),

      .frame_state_type = "unlang_frame_state_limit_t",

      .thread_inst_size = sizeof(unlang_thread_limit_t),

      .thread_inst_type = "unlang_thread_limit_t",

    });

}