switch_core_port_allocator.c File Reference

#include <switch.h>
#include "private/switch_core_pvt.h"

Include dependency graph for switch_core_port_allocator.c:

Go to the source code of this file.

Data Structures
struct	switch_core_port_allocator

Functions
switch_status_t	switch_core_port_allocator_new (const char *ip, switch_port_t start, switch_port_t end, switch_port_flag_t flags, switch_core_port_allocator_t **new_allocator)
static switch_bool_t	test_port (switch_core_port_allocator_t *alloc, int type, switch_port_t port)
switch_status_t	switch_core_port_allocator_request_port (switch_core_port_allocator_t *alloc, switch_port_t *port_ptr)
switch_status_t	switch_core_port_allocator_free_port (switch_core_port_allocator_t *alloc, switch_port_t port)
void	switch_core_port_allocator_destroy (switch_core_port_allocator_t **alloc)

Function Documentation

switch_core_port_allocator_destroy()

void switch_core_port_allocator_destroy

(

switch_core_port_allocator_t **

alloc

)

Definition at line 246 of file switch_core_port_allocator.c.

References switch_core_port_allocator::pool, and switch_core_destroy_memory_pool.

{
        switch_memory_pool_t *pool = (*alloc)->pool;
        switch_core_destroy_memory_pool(&pool);
        *alloc = NULL;
}

switch_core_port_allocator_free_port()

switch_status_t switch_core_port_allocator_free_port	(	switch_core_port_allocator_t *	alloc,
		switch_port_t	port
	)

Definition at line 218 of file switch_core_port_allocator.c.

References index, switch_core_port_allocator::mutex, SPF_EVEN, SPF_ODD, switch_core_port_allocator::start, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, switch_test_flag, switch_core_port_allocator::track, and switch_core_port_allocator::track_used.

{
        switch_status_t status = SWITCH_STATUS_FALSE;
        int even = switch_test_flag(alloc, SPF_EVEN);
        int odd = switch_test_flag(alloc, SPF_ODD);
        int index;

        if (port < alloc->start) {
                return SWITCH_STATUS_GENERR;
        }

        index = port - alloc->start;

        if (!(even && odd)) {
                index /= 2;
        }

        switch_mutex_lock(alloc->mutex);
        if (alloc->track[index] > 0) {
                alloc->track[index] = -4;
                alloc->track_used--;
                status = SWITCH_STATUS_SUCCESS;
        }
        switch_mutex_unlock(alloc->mutex);

        return status;
}

switch_core_port_allocator_new()

switch_status_t switch_core_port_allocator_new	(	const char *	ip,
		switch_port_t	start,
		switch_port_t	end,
		switch_port_flag_t	flags,
		switch_core_port_allocator_t **	new_allocator
	)

Definition at line 51 of file switch_core_port_allocator.c.

References switch_core_port_allocator::end, switch_core_port_allocator::flags, switch_core_port_allocator::ip, switch_core_port_allocator::mutex, switch_core_port_allocator::next, switch_core_port_allocator::pool, switch_runtime::port_alloc_flags, runtime, SPF_EVEN, SPF_ODD, switch_core_port_allocator::start, SWITCH_CHANNEL_LOG, switch_core_alloc, switch_core_destroy_memory_pool, switch_core_new_memory_pool, switch_core_strdup, switch_log_printf(), SWITCH_LOG_WARNING, switch_mutex_init(), SWITCH_MUTEX_NESTED, SWITCH_STATUS_MEMERR, SWITCH_STATUS_SUCCESS, switch_test_flag, switch_core_port_allocator::track, and switch_core_port_allocator::track_len.

{
        switch_status_t status;
        switch_memory_pool_t *pool;
        switch_core_port_allocator_t *alloc;
        int even, odd;

        if ((status = switch_core_new_memory_pool(&pool)) != SWITCH_STATUS_SUCCESS) {
                return status;
        }

        if (!(alloc = switch_core_alloc(pool, sizeof(*alloc)))) {
                switch_core_destroy_memory_pool(&pool);
                return SWITCH_STATUS_MEMERR;
        }

        alloc->flags = flags;
        alloc->ip = switch_core_strdup(pool, ip);
        even = switch_test_flag(alloc, SPF_EVEN);
        odd = switch_test_flag(alloc, SPF_ODD);

        alloc->flags |= runtime.port_alloc_flags;


        if (!(even && odd)) {
                if (even) {
                        if ((start % 2) != 0) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Rounding odd start port %d to %d\n", start, start + 1);
                                start++;
                        }
                        if ((end % 2) != 0) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Rounding odd end port %d to %d\n", end, end - 1);
                                end--;
                        }
                } else if (odd) {
                        if ((start % 2) == 0) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Rounding even start port %d to %d\n", start, start + 1);
                                start++;
                        }
                        if ((end % 2) == 0) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Rounding even end port %d to %d\n", end, end - 1);
                                end--;
                        }
                }
        }

        alloc->track_len = (end - start) + 2;

        if (!(even && odd)) {
                alloc->track_len /= 2;
        }

        alloc->track = switch_core_alloc(pool, (alloc->track_len + 2) * sizeof(switch_byte_t));

        alloc->start = start;
        alloc->next = start;
        alloc->end = end;


        switch_mutex_init(&alloc->mutex, SWITCH_MUTEX_NESTED, pool);
        alloc->pool = pool;
        *new_allocator = alloc;

        return SWITCH_STATUS_SUCCESS;
}

switch_core_port_allocator_request_port()

switch_status_t switch_core_port_allocator_request_port	(	switch_core_port_allocator_t *	alloc,
		switch_port_t *	port_ptr
	)

Definition at line 143 of file switch_core_port_allocator.c.

References switch_core_port_allocator::end, switch_core_port_allocator::flags, index, switch_core_port_allocator::mutex, SPF_EVEN, SPF_ODD, SPF_ROBUST_TCP, SPF_ROBUST_UDP, switch_core_port_allocator::start, SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, switch_log_printf(), switch_micro_time_now(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_test_flag, switch_thread_self(), SWITCH_TRUE, test_port(), switch_core_port_allocator::track, switch_core_port_allocator::track_len, and switch_core_port_allocator::track_used.

{
        switch_port_t port = 0;
        switch_status_t status = SWITCH_STATUS_FALSE;
        int even = switch_test_flag(alloc, SPF_EVEN);
        int odd = switch_test_flag(alloc, SPF_ODD);

        switch_mutex_lock(alloc->mutex);
        srand((unsigned) ((unsigned) (intptr_t) port_ptr + (unsigned) (intptr_t) switch_thread_self() + switch_micro_time_now()));

        while (alloc->track_used < alloc->track_len) {
                uint32_t index;
                uint32_t tries = 0;

                /* randomly pick a port */
                index = rand() % alloc->track_len;

                /* if it is used walk up the list to find a free one */
                while (alloc->track[index] && tries < alloc->track_len) {
                        tries++;
                        if (alloc->track[index] < 0) {
                                alloc->track[index]++;
                        }
                        if (++index >= alloc->track_len) {
                                index = 0;
                        }
                }

                if (tries < alloc->track_len) {
                        switch_bool_t r = SWITCH_TRUE;

                        if ((even && odd)) {
                                port = (switch_port_t) (index + alloc->start);
                        } else {
                                port = (switch_port_t) (index + (alloc->start / 2));
                                port *= 2;
                        }

                        if ((alloc->flags & SPF_ROBUST_UDP)) {
                                r = test_port(alloc, SOCK_DGRAM, port);
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "UDP port robustness check for port %d %s\n", port, r ? "pass" : "fail");
                        }

                        if ((alloc->flags & SPF_ROBUST_TCP)) {
                                r = test_port(alloc, SOCK_STREAM, port);
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "TCP port robustness check for port %d %s\n", port, r ? "pass" : "fail");
                        }

                        if (r) {
                                alloc->track[index] = 1;
                                alloc->track_used++;
                                status = SWITCH_STATUS_SUCCESS;
                                goto end;
                        } else {
                                alloc->track[index] = -4;
                        }
                }
        }


  end:

        switch_mutex_unlock(alloc->mutex);

        if (status == SWITCH_STATUS_SUCCESS) {
                *port_ptr = port;
        } else {
                *port_ptr = 0;
        }


        return status;

}

test_port()

static switch_bool_t test_port ( switch_core_port_allocator_t *  alloc, int  type, switch_port_t  port  )

static

Definition at line 118 of file switch_core_port_allocator.c.

References switch_core_port_allocator::ip, switch_core_port_allocator::pool, switch_core_destroy_memory_pool, switch_core_new_memory_pool, SWITCH_FALSE, switch_sockaddr_get_family(), switch_sockaddr_new(), switch_socket_bind(), switch_socket_close(), switch_socket_create(), SWITCH_STATUS_SUCCESS, and SWITCH_TRUE.

Referenced by switch_core_port_allocator_request_port().

{
        switch_memory_pool_t *pool = NULL;
        switch_sockaddr_t *local_addr = NULL;
        switch_socket_t *sock = NULL;
        switch_bool_t r = SWITCH_FALSE;

        if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) {
                return SWITCH_FALSE;
        }

        if (switch_sockaddr_new(&local_addr, alloc->ip, port, pool) == SWITCH_STATUS_SUCCESS) {
                if (switch_socket_create(&sock, switch_sockaddr_get_family(local_addr), type, 0, pool) == SWITCH_STATUS_SUCCESS) {
                        if (switch_socket_bind(sock, local_addr) == SWITCH_STATUS_SUCCESS) {
                                r = SWITCH_TRUE;
                        }
                        switch_socket_close(sock);
                }
        }

        switch_core_destroy_memory_pool(&pool);

        return r;
}