LIMIT code

Collaboration diagram for LIMIT code:

Macros
#define	SWITCH_LIMIT_INCR(name)   static switch_status_t name (switch_core_session_t *session, const char *realm, const char *resource, const int max, const int interval)
#define	SWITCH_LIMIT_RELEASE(name)   static switch_status_t name (switch_core_session_t *session, const char *realm, const char *resource)
#define	SWITCH_LIMIT_USAGE(name)   static int name (const char *realm, const char *resource, uint32_t *rcount)
#define	SWITCH_LIMIT_RESET(name)   static switch_status_t name (void)
#define	SWITCH_LIMIT_INTERVAL_RESET(name)   static switch_status_t name (const char *realm, const char *resource)
#define	SWITCH_LIMIT_STATUS(name)   static char * name (void)
#define	LIMIT_IGNORE_TRANSFER_VARIABLE   "limit_ignore_transfer"
#define	LIMIT_BACKEND_VARIABLE   "limit_backend"
#define	LIMIT_EVENT_USAGE   "limit::usage"
#define	LIMIT_DEF_XFER_EXTEN   "limit_exceeded"

Functions
SWITCH_BEGIN_EXTERN_C void	switch_limit_init (switch_memory_pool_t *pool)
	Initilize the LIMIT Core System. More...
switch_status_t	switch_limit_incr (const char *backend, switch_core_session_t *session, const char *realm, const char *resource, const int max, const int interval)
	Increment resource. More...
switch_status_t	switch_limit_release (const char *backend, switch_core_session_t *session, const char *realm, const char *resource)
	Release resource. More...
int	switch_limit_usage (const char *backend, const char *realm, const char *resource, uint32_t *rcount)
	get usage count for resource More...
switch_status_t	switch_limit_interval_reset (const char *backend, const char *realm, const char *resource)
	reset interval usage counter for a given resource More...
switch_status_t	switch_limit_reset (const char *backend)
	reset all usage counters More...
void	switch_limit_fire_event (const char *backend, const char *realm, const char *resource, uint32_t usage, uint32_t rate, uint32_t max, uint32_t ratemax)
	fire event for limit usage More...
char *	switch_limit_status (const char *backend)
	retrieve arbitrary status information More...

Detailed Description

Macro Definition Documentation

LIMIT_BACKEND_VARIABLE

#define LIMIT_BACKEND_VARIABLE   "limit_backend"

Definition at line 121 of file switch_limit.h.

Referenced by limit_state_handler(), and switch_limit_incr().

LIMIT_DEF_XFER_EXTEN

#define LIMIT_DEF_XFER_EXTEN   "limit_exceeded"

Definition at line 123 of file switch_limit.h.

LIMIT_EVENT_USAGE

#define LIMIT_EVENT_USAGE   "limit::usage"

Definition at line 122 of file switch_limit.h.

Referenced by switch_limit_fire_event(), and switch_limit_init().

LIMIT_IGNORE_TRANSFER_VARIABLE

#define LIMIT_IGNORE_TRANSFER_VARIABLE   "limit_ignore_transfer"

Definition at line 120 of file switch_limit.h.

Referenced by limit_state_handler().

SWITCH_LIMIT_INCR

#define SWITCH_LIMIT_INCR

(

name

)

static switch_status_t name (switch_core_session_t *session, const char *realm, const char *resource, const int max, const int interval)

callback to init a backend

Definition at line 113 of file switch_limit.h.

SWITCH_LIMIT_INTERVAL_RESET

#define SWITCH_LIMIT_INTERVAL_RESET

(

name

)

static switch_status_t name (const char *realm, const char *resource)

Definition at line 117 of file switch_limit.h.

SWITCH_LIMIT_RELEASE

#define SWITCH_LIMIT_RELEASE

(

name

)

static switch_status_t name (switch_core_session_t *session, const char *realm, const char *resource)

Definition at line 114 of file switch_limit.h.

SWITCH_LIMIT_RESET

#define SWITCH_LIMIT_RESET

(

name

)

static switch_status_t name (void)

Definition at line 116 of file switch_limit.h.

SWITCH_LIMIT_STATUS

#define SWITCH_LIMIT_STATUS

(

name

)

static char * name (void)

Definition at line 118 of file switch_limit.h.

SWITCH_LIMIT_USAGE

#define SWITCH_LIMIT_USAGE

(

name

)

static int name (const char *realm, const char *resource, uint32_t *rcount)

Definition at line 115 of file switch_limit.h.

Function Documentation

switch_limit_fire_event()

void switch_limit_fire_event	(	const char *	backend,
		const char *	realm,
		const char *	resource,
		uint32_t	usage,
		uint32_t	rate,
		uint32_t	max,
		uint32_t	ratemax
	)

fire event for limit usage

Parameters

backend	to use
realm
resource
usage
rate
max
ratemax

Definition at line 60 of file switch_limit.c.

References LIMIT_EVENT_USAGE, switch_event_add_header(), switch_event_add_header_string(), switch_event_create_subclass, SWITCH_EVENT_CUSTOM, switch_event_fire, SWITCH_STACK_BOTTOM, and SWITCH_STATUS_SUCCESS.

{
        switch_event_t *event;

        if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, LIMIT_EVENT_USAGE) == SWITCH_STATUS_SUCCESS) {
                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "backend", backend);
                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "realm", realm);
                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", key);
                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "usage", "%d", usage);
                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "rate", "%d", rate);
                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "max", "%d", max);
                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "ratemax", "%d", ratemax);
                switch_event_fire(&event);
        }
}

switch_limit_incr()

switch_status_t switch_limit_incr	(	const char *	backend,
		switch_core_session_t *	session,
		const char *	realm,
		const char *	resource,
		const int	max,
		const int	interval
	)

Increment resource.

Parameters

backend	to use
realm
resource
max	- 0 means no limit, just count
interval	- 0 means no interval

Returns

true/false - true ok, false over limit

Definition at line 109 of file switch_limit.c.

References get_backend(), switch_limit_interface::incr, LIMIT_BACKEND_VARIABLE, limit_state_handler(), release_backend(), switch_channel_get_variable, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_variable, switch_channel_set_variable_printf(), switch_core_session_get_channel(), switch_goto_status, SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_STATUS_GENERR, and SWITCH_STATUS_SUCCESS.

                                                                                                                                                                                   {
        switch_limit_interface_t *limit = NULL;
        switch_channel_t *channel = NULL;
        int status = SWITCH_STATUS_SUCCESS;

        assert(session);

        channel = switch_core_session_get_channel(session);

        /* locate impl, call appropriate func */
        if (!(limit = get_backend(backend))) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Limit subsystem %s not found!\n", backend);
                switch_goto_status(SWITCH_STATUS_GENERR, end);
        }

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "incr called: %s_%s max:%d, interval:%d\n",
                                          realm, resource, max, interval);

        if ((status = limit->incr(session, realm, resource, max, interval)) == SWITCH_STATUS_SUCCESS) {
                /* race condition? what if another leg is doing the same thing? */
                const char *existing = switch_channel_get_variable(channel, LIMIT_BACKEND_VARIABLE);
                if (existing) {
                        if (!strstr(existing, backend)) {
                                switch_channel_set_variable_printf(channel, LIMIT_BACKEND_VARIABLE, "%s,%s", existing, backend);
                        }
                } else {
                        switch_channel_set_variable(channel, LIMIT_BACKEND_VARIABLE, backend);
                        switch_core_event_hook_add_state_change(session, limit_state_handler);
                }
        }

        release_backend(limit);

end:
        return status;
}

switch_limit_init()

SWITCH_BEGIN_EXTERN_C void switch_limit_init

(

switch_memory_pool_t *

pool

)

Initilize the LIMIT Core System.

Parameters

pool	the memory pool to use for long term allocations

Note

Generally called by the core_init

Definition at line 53 of file switch_limit.c.

References LIMIT_EVENT_USAGE, SWITCH_CHANNEL_LOG, switch_event_reserve_subclass, SWITCH_LOG_ERROR, switch_log_printf(), and SWITCH_STATUS_SUCCESS.

                                                                   {
        if (switch_event_reserve_subclass(LIMIT_EVENT_USAGE) != SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Couldn't register event subclass \"%s\"", LIMIT_EVENT_USAGE);
        }
}

switch_limit_interval_reset()

switch_status_t switch_limit_interval_reset	(	const char *	backend,
		const char *	realm,
		const char *	resource
	)

reset interval usage counter for a given resource

Parameters

backend
realm
resource

Definition at line 197 of file switch_limit.c.

References get_backend(), switch_limit_interface::interval_reset, release_backend(), SWITCH_CHANNEL_LOG, switch_goto_status, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_STATUS_GENERR, and SWITCH_STATUS_SUCCESS.

                                                                                                                          {
        switch_limit_interface_t *limit = NULL;
        int status = SWITCH_STATUS_SUCCESS;

        /* locate impl, call appropriate func */
        if (!(limit = get_backend(backend))) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Limit subsystem %s not found!\n", backend);
                switch_goto_status(SWITCH_STATUS_GENERR, end);
        }

        if (!limit->interval_reset) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Limit subsystem %s does not implement interval_reset!\n", backend);
                switch_goto_status(SWITCH_STATUS_GENERR, end);
        }

        status = limit->interval_reset(realm, resource);

end:
        release_backend(limit);
        return status;
}

switch_limit_release()

switch_status_t switch_limit_release	(	const char *	backend,
		switch_core_session_t *	session,
		const char *	realm,
		const char *	resource
	)

Release resource.

Parameters

backend	to use
realm
resource

Returns

true/false - true ok, false over limit

Definition at line 146 of file switch_limit.c.

References get_backend(), switch_limit_interface::release, release_backend(), SWITCH_CHANNEL_SESSION_LOG, switch_goto_status, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_STATUS_GENERR, and SWITCH_STATUS_SUCCESS.

Referenced by limit_state_handler().

                                                                                                                                                   {
        switch_limit_interface_t *limit = NULL;
        int status = SWITCH_STATUS_SUCCESS;

        /* locate impl, call appropriate func */
        if (!(limit = get_backend(backend))) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Limit subsystem %s not found!\n", backend);
                switch_goto_status(SWITCH_STATUS_GENERR, end);
        }

        status = limit->release(session, realm, resource);

end:
        release_backend(limit);
        return status;
}

switch_limit_reset()

switch_status_t switch_limit_reset

(

const char *

backend

)

reset all usage counters

Parameters

backend

to use

Definition at line 180 of file switch_limit.c.

References get_backend(), release_backend(), switch_limit_interface::reset, SWITCH_CHANNEL_LOG, switch_goto_status, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_STATUS_GENERR, and SWITCH_STATUS_SUCCESS.

                                                                        {
        switch_limit_interface_t *limit = NULL;
        int status = SWITCH_STATUS_SUCCESS;

        /* locate impl, call appropriate func */
        if (!(limit = get_backend(backend))) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Limit subsystem %s not found!\n", backend);
                switch_goto_status(SWITCH_STATUS_GENERR, end);
        }

        status = limit->reset();

end:
        release_backend(limit);
        return status;
}

switch_limit_status()

char* switch_limit_status

(

const char *

backend

)

retrieve arbitrary status information

Parameters

backend

to use

Note

caller must free returned value

Definition at line 219 of file switch_limit.c.

References get_backend(), release_backend(), switch_limit_interface::status, SWITCH_CHANNEL_LOG, switch_goto_status, SWITCH_LOG_ERROR, and switch_log_printf().

                                                                {
        switch_limit_interface_t *limit = NULL;
        char *status = NULL;

        /* locate impl, call appropriate func */
        if (!(limit = get_backend(backend))) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Limit subsystem %s not found!\n", backend);
                switch_goto_status(strdup("-ERR"), end);
        }

        status = limit->status();

end:
        release_backend(limit);
        return status;
}

switch_limit_usage()

int switch_limit_usage	(	const char *	backend,
		const char *	realm,
		const char *	resource,
		uint32_t *	rcount
	)

get usage count for resource

Parameters

backend	to use
realm
resource
rcount	- output paramter, rate counter

Definition at line 163 of file switch_limit.c.

References get_backend(), release_backend(), SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, switch_log_printf(), usage, and switch_limit_interface::usage.

                                                                                                                       {
        switch_limit_interface_t *limit = NULL;
        int usage = 0;

        /* locate impl, call appropriate func */
        if (!(limit = get_backend(backend))) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Limit subsystem %s not found!\n", backend);
                goto end;
        }

        usage = limit->usage(realm, resource, rcount);

end:
        release_backend(limit);
        return usage;
}