/* This file is part of Mailfromd.             -*- c -*-
   Copyright (C) 2006, 2007, 2008 Sergey Poznyakoff

   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 3, 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, see <http://www.gnu.org/licenses/>. */

static int
valid_user_p(eval_environ_t env, const char *name)
{
	int rc;
	struct mu_auth_data *auth_data = NULL;

#if HAVE_MU_GET_AUTH
	rc = mu_get_auth(&auth_data, mu_auth_key_name, name);
	mu_auth_data_free(auth_data);
	switch (rc) {
	case 0:
		rc = 1;
		break;
		
	case MU_ERR_AUTH_FAILURE:
		rc = 0;
		break;

	case EAGAIN:
                MF_THROW(mfe_temp_failure,
		         _("Temporary failure querying for username %s"),
			 name);
		break;

	default:
                MF_THROW(mfe_failure,
		         _("Failure querying for username %s"),
			 name);
		break;
	}
#else
	auth_data = mu_get_auth_by_name(name);
	rc = auth_data != NULL;
	mu_auth_data_free(auth_data);
#endif
	debug2(10, "Checking user %s: %s", name,
	       rc ? "true" : "false");
	return rc;
}

MF_DEFUN(validuser, NUMBER, STRING name)
{
	MF_RETURN(valid_user_p(env, name));
}
END

MF_DEFUN(interval, NUMBER, STRING str)
{
       time_t t;
       const char *endp;

       MF_ASSERT(parse_time_interval(str, &t, &endp) == 0,
	         mfe_invtime,
		 _("Unrecognized time format (near `%s')"), endp);
       MF_RETURN(t);
}
END

MF_DEFUN(rate, NUMBER, STRING key, NUMBER interval, OPTIONAL, NUMBER mincnt,
	 NUMBER threshold)
{
	long ret;

	MF_ASSERT(get_rate(key, &ret, interval,
			   MF_OPTVAL(mincnt),
			   MF_OPTVAL(threshold)) == mf_success,
		  mfe_dbfailure,
		 _("Cannot get rate for %s"), key);

	MF_RETURN(ret);
}
END

MF_DEFUN(tbf_rate, NUMBER, STRING key, NUMBER cost,
	 NUMBER interval, NUMBER burst_size)
{
        int result;
		
	MF_ASSERT(check_tbf_rate(key, &result, cost, interval,
				 burst_size) == mf_success,
		  mfe_dbfailure,
		  _("Cannot check TBF rate for %s"), key);
	
	MF_RETURN(result);
}
END

MF_DEFUN(debug_level, NUMBER, OPTIONAL, STRING modname)
{
	int level;
	MF_ASSERT(debug_module_level(MF_OPTVAL(modname, NULL), &level) == 0,
		  mfe_range,
		  _("Invalid module name: %s"), modname);
	MF_RETURN(level);
}
END

MF_DEFUN(debug_spec, STRING, OPTIONAL, STRING modnames)
{
	char *buf;
	char *s;
	size_t off;

 	int rc = debug_spec_string(MF_OPTVAL(modnames, NULL), &buf);
	MF_ASSERT(rc == 0,
		  mfe_failure,
		  "%s", mu_strerror(rc));
	s = MF_ALLOC_HEAP(off, strlen(buf) + 1);
	strcpy(s, buf);
	free(buf);
	MF_RETURN(off);
}
END

MF_DEFUN(debug, VOID, STRING spec)
{
	debug_parse_spec(spec);
}
END

MF_DEFUN(program_trace, VOID, STRING name)
{
	enable_prog_trace(name);
}
END

MF_DEFUN(cancel_program_trace, VOID, STRING name)
{
	disable_prog_trace(name);
}
END	

MF_DEFUN(stack_trace, VOID)
{
	runtime_stack_trace(env);
}
END

MF_INIT