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 (switch_port_t start, switch_port_t end, switch_port_flag_t flags, switch_core_port_allocator_t **new_allocator)
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

void switch_core_port_allocator_destroy

(

switch_core_port_allocator_t **

alloc

)

Definition at line 194 of file switch_core_port_allocator.c.

References pool, and switch_core_destroy_memory_pool.

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

switch_status_t switch_core_port_allocator_free_port	(	switch_core_port_allocator_t *	alloc,
		switch_port_t	port
	)

Definition at line 172 of file switch_core_port_allocator.c.

References SPF_EVEN, SPF_ODD, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_test_flag.

{
        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 = 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_status_t switch_core_port_allocator_new	(	switch_port_t	start,
		switch_port_t	end,
		switch_port_flag_t	flags,
		switch_core_port_allocator_t **	new_allocator
	)

Definition at line 50 of file switch_core_port_allocator.c.

References pool, SPF_EVEN, SPF_ODD, SWITCH_CHANNEL_LOG, switch_core_alloc, switch_core_destroy_memory_pool, switch_core_new_memory_pool, switch_log_printf(), SWITCH_LOG_WARNING, switch_mutex_init(), SWITCH_MUTEX_NESTED, SWITCH_STATUS_MEMERR, SWITCH_STATUS_SUCCESS, and switch_test_flag.

{
        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;
        even = switch_test_flag(alloc, SPF_EVEN);
        odd = switch_test_flag(alloc, SPF_ODD);

        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_status_t switch_core_port_allocator_request_port	(	switch_core_port_allocator_t *	alloc,
		switch_port_t *	port_ptr
	)

Definition at line 113 of file switch_core_port_allocator.c.

References SPF_EVEN, SPF_ODD, switch_micro_time_now(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_test_flag, and switch_thread_self().

{
        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) {
                        alloc->track[index] = 1;
                        alloc->track_used++;
                        status = SWITCH_STATUS_SUCCESS;

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


  end:

        switch_mutex_unlock(alloc->mutex);

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


        return status;

}

---