cellular-infrastructure
/
osmocom-analog
9
1
Fork 2
Code Issues 12 Pull Requests 2 Projects Releases Wiki Activity
osmocom-analog/src/libosmocc/endpoint.c

1506 lines
39 KiB
C
Raw Blame History

/* Endpoint and call process handling
*
* (C) 2019 by Andreas Eversberg <jolly@eversberg.eu>
* All Rights Reserved
*
* 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 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, see <http://www.gnu.org/licenses/>.
*/
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <unistd.h>
#include "../libtimer/timer.h"
#include "../libdebug/debug.h"
#include "endpoint.h"
osmo_cc_endpoint_t *osmo_cc_endpoint_list = NULL;
static osmo_cc_call_t *call_new(osmo_cc_endpoint_t *ep, uint32_t callref)
{
osmo_cc_call_t *call, **cp;
call = calloc(1, sizeof(*call));
if (!call) {
PDEBUG(DCC, DEBUG_ERROR, "No memory for call process instance.\n");
abort();
}
PDEBUG(DCC, DEBUG_DEBUG, "Creating new call with callref %u.\n", callref);
call->ep = ep;
call->callref = callref;
/* attach to call process list */
cp = &ep->call_list;
while (*cp)
cp = &((*cp)->next);
*cp = call;
/* return new entry */
return call;
}
static void call_delete(osmo_cc_call_t *call)
{
osmo_cc_call_t **cp;
PDEBUG(DCC, DEBUG_DEBUG, "Destroying call with callref %u.\n", call->callref);
/* detach from call process list */
cp = &call->ep->call_list;
while (*cp != call)
cp = &((*cp)->next);
*cp = call->next;
/* flush message queue */
while (call->sock_queue) {
osmo_cc_msg_t *msg = osmo_cc_msg_list_dequeue(&call->sock_queue, NULL);
osmo_cc_free_msg(msg);
}
/* free remote peer */
free((char *)call->attached_name);
free((char *)call->attached_host);
free(call);
}
static const char *state_names[] = {
"IDLE",
"INIT-OUT",
"INIT-IN",
"OVERLAP-OUT",
"OVERLAP-IN",
"PROCEEDING-OUT",
"PROCEEDING-IN",
"ALERTING-OUT",
"ALERTING-IN",
"CONNECTING-OUT",
"CONNECTING-IN",
"ACTIVE",
"DISCONNECTING-OUT",
"DISCONNECTING-IN",
"DISCONNECT-COLLISION",
"RELEASING-OUT",
"ATTACH-SENT",
"ATTACH-OUT",
"ATTACH-WAIT",
"ATTACH-IN",
};
static void new_call_state(osmo_cc_call_t *call, enum osmo_cc_state new_state)
{
PDEBUG(DCC, DEBUG_DEBUG, "Changing call state with callref %u from %s to %s.\n", call->callref, state_names[call->state], state_names[new_state]);
call->state = new_state;
}
/* helper to forward message to lower layer */
static void forward_to_ll(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
if (call->lower_layer_released)
return;
if (msg->type == OSMO_CC_MSG_SETUP_REQ
|| msg->type == OSMO_CC_MSG_SETUP_RSP) {
/* screen towards lower layer */
msg = osmo_cc_screen_msg(call->ep, msg, 0, NULL);
}
osmo_cc_msg_list_enqueue(&call->ep->ll_queue, msg, call->callref);
}
static void sock_reject_msg(osmo_cc_socket_t *os, uint32_t callref, uint8_t location, uint8_t socket_cause, uint8_t isdn_cause, uint16_t sip_cause)
{
osmo_cc_msg_t *msg;
/* create message */
msg = osmo_cc_new_msg(OSMO_CC_MSG_REJ_IND);
/* add cause */
osmo_cc_add_ie_cause(msg, location, isdn_cause, sip_cause, socket_cause);
osmo_cc_convert_cause_msg(msg);
/* message to socket */
osmo_cc_sock_send_msg(os, callref, msg, NULL, 0);
}
static void ll_reject_msg(osmo_cc_call_t *call, uint8_t location, uint8_t socket_cause, uint8_t isdn_cause, uint16_t sip_cause)
{
osmo_cc_msg_t *msg;
/* create message */
msg = osmo_cc_new_msg(OSMO_CC_MSG_REJ_REQ);
/* add cause */
osmo_cc_add_ie_cause(msg, location, isdn_cause, sip_cause, socket_cause);
osmo_cc_convert_cause_msg(msg);
/* message to lower layer */
forward_to_ll(call, msg);
}
static int split_address(const char *address, const char **host_p, uint16_t *port_p)
{
const char *portstring;
*host_p = osmo_cc_host_of_address(address);
if (!(*host_p)) {
PDEBUG(DCC, DEBUG_ERROR, "Host IP in given address '%s' is invalid.\n", address);
return -EINVAL;
}
portstring = osmo_cc_port_of_address(address);
if (!portstring) {
PDEBUG(DCC, DEBUG_ERROR, "Port number in given address '%s' is not specified or invalid.\n", address);
return -EINVAL;
}
*port_p = atoi(portstring);
return 0;
}
osmo_cc_call_t *osmo_cc_get_attached_interface(osmo_cc_endpoint_t *ep, const char *interface)
{
osmo_cc_call_t *att;
for (att = ep->call_list; att; att = att->next) {
if (att->state != OSMO_CC_STATE_ATTACH_IN)
continue;
/* no interface given, just use the attached peer */
if (!interface[0])
break;
/* no interface name given on attached peer, ignore it */
if (!att->attached_name || !att->attached_name[0])
continue;
/* interface given, use the attached peer with the same interface name */
if (!strcmp(interface, att->attached_name))
break;
}
return att;
}
/* helper to forward message to upper layer */
static void forward_to_ul(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
const char *address = NULL, *host = NULL;
uint16_t port;
int rc;
if (call->upper_layer_released)
return;
if (msg->type == OSMO_CC_MSG_SETUP_IND
|| msg->type == OSMO_CC_MSG_SETUP_CNF) {
/* screen towards upper layer */
msg = osmo_cc_screen_msg(call->ep, msg, 1, &address);
}
/* no socket: forward message to upper layer */
if (call->ep->ul_msg_cb) {
call->ep->ul_msg_cb(call, msg);
return;
}
/* if remote peer is included in the setup message */
if (address && msg->type == OSMO_CC_MSG_SETUP_IND) {
rc = split_address(address, &host, &port);
if (rc < 0) {
PDEBUG(DCC, DEBUG_ERROR, "Given remote peer's address '%s' in setup message is invalid, rejecting call.\n", address);
reject:
/* reject, due to error */
osmo_cc_free_msg(msg);
new_call_state(call, OSMO_CC_STATE_IDLE);
ll_reject_msg(call, call->ep->serving_location, 0, OSMO_CC_ISDN_CAUSE_DEST_OOO, 0);
call_delete(call);
return;
}
PDEBUG(DCC, DEBUG_DEBUG, "Using host IP '%s' and port '%d' from setup message.\n", host, port);
}
/* for attach message, use remote peer */
if (msg->type == OSMO_CC_MSG_ATTACH_IND) {
host = call->ep->remote_host;
port = call->ep->remote_port;
PDEBUG(DCC, DEBUG_DEBUG, "Using host IP '%s' and port '%d' from remote address for attach message.\n", host, port);
}
/* if there is no remote peer in the setup message, use remote peer */
if (!address && msg->type == OSMO_CC_MSG_SETUP_IND && call->ep->remote_host) {
host = call->ep->remote_host;
port = call->ep->remote_port;
PDEBUG(DCC, DEBUG_DEBUG, "Using host IP '%s' and port '%d' from remote address for setup message.\n", host, port);
}
/* if there is no remote peer set, try to use the interface name */
if (!host && msg->type == OSMO_CC_MSG_SETUP_IND) {
char interface[256];
osmo_cc_call_t *att;
rc = osmo_cc_get_ie_called_interface(msg, 0, interface, sizeof(interface));
if (rc < 0)
interface[0] = '\0';
/* check for incoming attachment */
att = osmo_cc_get_attached_interface(call->ep, interface);
if (!att && !interface[0]) {
PDEBUG(DCC, DEBUG_ERROR, "No remote peer attached, rejecting call.\n");
goto reject;
}
if (!att) {
PDEBUG(DCC, DEBUG_ERROR, "No remote peer attached for given interface '%s', rejecting call.\n", interface);
goto reject;
}
host = att->attached_host;
port = att->attached_port;
PDEBUG(DCC, DEBUG_DEBUG, "Using host IP '%s' and port '%d' from attached peer for setup message.\n", host, port);
}
/* add local interface name to setup message */
// FIXME: should we do that if there is already an interface name given?
if (msg->type == OSMO_CC_MSG_SETUP_IND && call->ep->local_name)
osmo_cc_add_ie_calling_interface(msg, call->ep->local_name);
/* forward message to socket */
osmo_cc_sock_send_msg(&call->ep->os, call->callref, msg, host, port);
}
/* send attach indication to socket */
void send_attach_ind(struct timer *timer)
{
osmo_cc_endpoint_t *ep = (osmo_cc_endpoint_t *)timer->priv;
osmo_cc_call_t *call;
osmo_cc_msg_t *msg;
PDEBUG(DCC, DEBUG_DEBUG, "Trying to attach to remote peer \"%s\".\n", ep->remote_host);
/* create new call for attachment */
call = osmo_cc_call_new(ep);
/* create attach message */
msg = osmo_cc_new_msg(OSMO_CC_MSG_ATTACH_IND);
/* set interface name and address */
osmo_cc_add_ie_calling_interface(msg, ep->local_name);
osmo_cc_add_ie_socket_address(msg, ep->local_address);
/* message to socket */
forward_to_ul(call, msg);
/* set state */
new_call_state(call, OSMO_CC_STATE_ATTACH_SENT);
}
void attach_rsp(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
PDEBUG(DCC, DEBUG_INFO, "Attached to remote peer \"%s\".\n", call->ep->remote_address);
/* set state */
new_call_state(call, OSMO_CC_STATE_ATTACH_OUT);
/* drop message */
osmo_cc_free_msg(msg);
}
void attach_rel(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* (re-)start timer for next attachment */
if (call->state == OSMO_CC_STATE_ATTACH_SENT
|| call->state == OSMO_CC_STATE_ATTACH_OUT) {
timer_start(&call->ep->attach_timer, OSMO_CC_ATTACH_TIMER);
PDEBUG(DCC, DEBUG_INFO, "Attachment to remote peer \"%s\" failed, retrying.\n", call->ep->remote_address);
}
if (call->attached_name)
PDEBUG(DCC, DEBUG_INFO, "Peer with remote interface \"%s\" detached from us.\n", call->attached_name);
/* change state */
new_call_state(call, OSMO_CC_STATE_IDLE);
/* unset interface */
free((char *)call->attached_name);
call->attached_name = NULL;
free((char *)call->attached_host);
call->attached_host = NULL;
/* drop message */
osmo_cc_free_msg(msg);
/* destroy */
call_delete(call);
}
void attach_req(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
char address[256];
char interface[256];
const char *host;
uint16_t port;
int rc;
/* get peer from message */
rc = osmo_cc_get_ie_socket_address(msg, 0, address, sizeof(address));
if (rc < 0)
address[0] = '\0';
if (!address[0]) {
PDEBUG(DCC, DEBUG_ERROR, "Attachment request from remote peer has no remote address set, rejecting.\n");
rel:
/* change to REL_REQ */
msg->type = OSMO_CC_MSG_REL_IND;
PDEBUG(DCC, DEBUG_INFO, "Changing message to %s.\n", osmo_cc_msg_value2name(msg->type));
/* message to socket */
forward_to_ul(call, msg);
/* destroy */
call_delete(call);
return;
}
rc = split_address(address, &host, &port);
if (rc < 0) {
PDEBUG(DCC, DEBUG_ERROR, "Given remote peer's address '%s' in attach message is invalid, rejecting call.\n", address);
goto rel;
}
free((char *)call->attached_host);
call->attached_host = strdup(host);
call->attached_port = port;
rc = osmo_cc_get_ie_calling_interface(msg, 0, interface, sizeof(interface));
if (rc < 0)
interface[0] = '\0';
if (interface[0]) {
free((char *)call->attached_name);
call->attached_name = strdup(interface);
}
PDEBUG(DCC, DEBUG_INFO, "Remote peer with socket address '%s' and port '%d' and interface '%s' attached to us.\n", call->attached_host, call->attached_port, call->attached_name);
/* changing to confirm message */
msg->type = OSMO_CC_MSG_ATTACH_CNF;
PDEBUG(DCC, DEBUG_INFO, "Changing message to %s.\n", osmo_cc_msg_value2name(msg->type));
/* message to socket */
forward_to_ul(call, msg);
/* set state */
new_call_state(call, OSMO_CC_STATE_ATTACH_IN);
}
static void setup_req(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* change state */
new_call_state(call, OSMO_CC_STATE_INIT_OUT);
/* to lower layer */
forward_to_ll(call, msg);
}
static void setup_ind(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* change state */
new_call_state(call, OSMO_CC_STATE_INIT_IN);
/* to upper layer */
forward_to_ul(call, msg);
}
static void rej_req(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* change state */
new_call_state(call, OSMO_CC_STATE_IDLE);
/* to lower layer */
forward_to_ll(call, msg);
/* destroy */
call_delete(call);
}
static void rej_ind(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* change state */
new_call_state(call, OSMO_CC_STATE_IDLE);
/* to upper layer */
forward_to_ul(call, msg);
/* destroy */
call_delete(call);
}
static void setup_ack_req(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* change state */
new_call_state(call, OSMO_CC_STATE_OVERLAP_IN);
/* to lower layer */
forward_to_ll(call, msg);
}
static void setup_ack_ind(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* change state */
new_call_state(call, OSMO_CC_STATE_OVERLAP_OUT);
/* to upper layer */
forward_to_ul(call, msg);
}
static void proc_req(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* change state */
new_call_state(call, OSMO_CC_STATE_PROCEEDING_IN);
/* to lower layer */
forward_to_ll(call, msg);
}
static void proc_ind(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* change state */
new_call_state(call, OSMO_CC_STATE_PROCEEDING_OUT);
/* to upper layer */
forward_to_ul(call, msg);
}
static void alert_req(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* change state */
new_call_state(call, OSMO_CC_STATE_ALERTING_IN);
/* to lower layer */
forward_to_ll(call, msg);
}
static void alert_ind(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* change state */
new_call_state(call, OSMO_CC_STATE_ALERTING_OUT);
/* to upper layer */
forward_to_ul(call, msg);
}
static void setup_rsp(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* change state */
new_call_state(call, OSMO_CC_STATE_CONNECTING_IN);
/* to lower layer */
forward_to_ll(call, msg);
}
static void setup_cnf(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* change state */
new_call_state(call, OSMO_CC_STATE_CONNECTING_OUT);
/* to upper layer */
forward_to_ul(call, msg);
}
static void setup_comp_req(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* change state */
new_call_state(call, OSMO_CC_STATE_ACTIVE);
/* to lower layer */
forward_to_ll(call, msg);
}
static void setup_comp_ind(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* change state */
new_call_state(call, OSMO_CC_STATE_ACTIVE);
/* to upper layer */
forward_to_ul(call, msg);
}
static void info_req(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* to lower layer */
forward_to_ll(call, msg);
}
static void info_ind(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* to upper layer */
forward_to_ul(call, msg);
}
static void progress_req(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* to lower layer */
forward_to_ll(call, msg);
}
static void progress_ind(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* to upper layer */
forward_to_ul(call, msg);
}
static void notify_req(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* to lower layer */
forward_to_ll(call, msg);
}
static void notify_ind(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* to upper layer */
forward_to_ul(call, msg);
}
static void disc_req(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* change state */
new_call_state(call, OSMO_CC_STATE_DISCONNECTING_OUT);
/* to lower layer */
forward_to_ll(call, msg);
}
static void disc_ind(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* change state */
new_call_state(call, OSMO_CC_STATE_DISCONNECTING_IN);
/* to upper layer */
forward_to_ul(call, msg);
}
static void rel_req(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* terminate process, if there is no lower layer anmore */
if (call->lower_layer_released) {
/* change state */
new_call_state(call, OSMO_CC_STATE_IDLE);
/* drop message */
osmo_cc_free_msg(msg);
/* destroy */
call_delete(call);
return;
}
/* change state */
new_call_state(call, OSMO_CC_STATE_RELEASING_OUT);
/* to lower layer */
forward_to_ll(call, msg);
}
static void rel_ind(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* change state */
new_call_state(call, OSMO_CC_STATE_IDLE);
/* to upper layer */
forward_to_ul(call, msg);
/* destroy */
call_delete(call);
}
static void rel_cnf(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* change state */
new_call_state(call, OSMO_CC_STATE_IDLE);
/* drop message */
osmo_cc_free_msg(msg);
/* destroy */
call_delete(call);
}
static void disc_collision_ind(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* release to lower layer wheen there is no upper layer */
if (call->upper_layer_released) {
/* change state */
new_call_state(call, OSMO_CC_STATE_RELEASING_OUT);
/* change to REL_REQ */
msg->type = OSMO_CC_MSG_REL_REQ;
PDEBUG(DCC, DEBUG_INFO, "Changing message to %s.\n", osmo_cc_msg_value2name(msg->type));
/* to lower layer */
forward_to_ll(call, msg);
return;
}
/* change state */
new_call_state(call, OSMO_CC_STATE_DISC_COLLISION);
/* to upper layer */
forward_to_ul(call, msg);
}
static void disc_collision_req(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* release to upper layer wheen there is no lower layer */
if (call->lower_layer_released) {
/* change to REL_REQ */
msg->type = OSMO_CC_MSG_REL_IND;
PDEBUG(DCC, DEBUG_INFO, "Changing message to %s.\n", osmo_cc_msg_value2name(msg->type));
/* to upper layer */
forward_to_ul(call, msg);
/* destroy */
call_delete(call);
return;
}
/* change state */
new_call_state(call, OSMO_CC_STATE_DISC_COLLISION);
/* to lower layer */
forward_to_ll(call, msg);
}
static void rel_collision(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* change state */
if (call->state != OSMO_CC_STATE_IDLE)
new_call_state(call, OSMO_CC_STATE_IDLE);
/* drop message */
osmo_cc_free_msg(msg);
/* destroy */
call_delete(call);
}
static void rej_ind_disc(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* change state */
new_call_state(call, OSMO_CC_STATE_IDLE);
/* change to REL_IND */
msg->type = OSMO_CC_MSG_REL_IND;
PDEBUG(DCC, DEBUG_INFO, "Changing message to %s.\n", osmo_cc_msg_value2name(msg->type));
/* to upper layer */
forward_to_ul(call, msg);
/* destroy */
call_delete(call);
}
static void rej_req_disc(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
/* change state */
new_call_state(call, OSMO_CC_STATE_IDLE);
/* change to REL_REQ */
msg->type = OSMO_CC_MSG_REL_REQ;
PDEBUG(DCC, DEBUG_INFO, "Changing message to %s.\n", osmo_cc_msg_value2name(msg->type));
/* to lower layer */
forward_to_ll(call, msg);
/* destroy */
call_delete(call);
}
static void rel_ind_other(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
// FIXME: does this event really happens in this state?
// just to be safe we handle it
/* if thereis no upper layer, we are done */
if (call->upper_layer_released) {
/* drop message */
osmo_cc_free_msg(msg);
/* destroy */
call_delete(call);
return;
}
/* change state */
new_call_state(call, OSMO_CC_STATE_DISCONNECTING_IN);
/* change to DISC_IND */
msg->type = OSMO_CC_MSG_DISC_IND;
PDEBUG(DCC, DEBUG_INFO, "Changing message to %s.\n", osmo_cc_msg_value2name(msg->type));
call->lower_layer_released = 1;
/* to upper layer */
forward_to_ul(call, msg);
}
static void rel_req_other(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
// FIXME: does this event really happens in this state?
// just to be safe we handle it
/* if thereis no lower layer, we are done */
if (call->lower_layer_released) {
/* drop message */
osmo_cc_free_msg(msg);
/* destroy */
call_delete(call);
return;
}
/* change state */
new_call_state(call, OSMO_CC_STATE_DISCONNECTING_OUT);
/* change to DISC_REQ */
msg->type = OSMO_CC_MSG_DISC_REQ;
PDEBUG(DCC, DEBUG_INFO, "Changing message to %s.\n", osmo_cc_msg_value2name(msg->type));
call->upper_layer_released = 1;
/* to lower layer */
forward_to_ll(call, msg);
}
#define SBIT(a) (1 << a)
#define ALL_STATES (~0)
static struct statemachine {
uint32_t states;
int type;
void (*action)(osmo_cc_call_t *call, osmo_cc_msg_t *msg);
} statemachine_list[] = {
/* attachment states */
{SBIT(OSMO_CC_STATE_ATTACH_SENT),
OSMO_CC_MSG_ATTACH_RSP, attach_rsp},
{SBIT(OSMO_CC_STATE_ATTACH_OUT) | SBIT(OSMO_CC_STATE_ATTACH_SENT),
OSMO_CC_MSG_REL_REQ, attach_rel},
{SBIT(OSMO_CC_STATE_IDLE),
OSMO_CC_MSG_ATTACH_REQ, attach_req},
{SBIT(OSMO_CC_STATE_ATTACH_IN),
OSMO_CC_MSG_REL_REQ, attach_rel},
/* call setup toward lower layer protocol */
{SBIT(OSMO_CC_STATE_IDLE),
OSMO_CC_MSG_SETUP_REQ, setup_req},
{SBIT(OSMO_CC_STATE_INIT_OUT),
OSMO_CC_MSG_SETUP_ACK_IND, setup_ack_ind},
{SBIT(OSMO_CC_STATE_INIT_OUT) | SBIT(OSMO_CC_STATE_OVERLAP_OUT),
OSMO_CC_MSG_PROC_IND, proc_ind},
{SBIT(OSMO_CC_STATE_INIT_OUT) | SBIT(OSMO_CC_STATE_OVERLAP_OUT) |
SBIT(OSMO_CC_STATE_PROCEEDING_OUT),
OSMO_CC_MSG_ALERT_IND, alert_ind},
{SBIT(OSMO_CC_STATE_INIT_OUT) | SBIT(OSMO_CC_STATE_OVERLAP_OUT) |
SBIT(OSMO_CC_STATE_PROCEEDING_OUT) | SBIT(OSMO_CC_STATE_ALERTING_OUT),
OSMO_CC_MSG_SETUP_CNF, setup_cnf},
{SBIT(OSMO_CC_STATE_OVERLAP_OUT) | SBIT(OSMO_CC_STATE_PROCEEDING_OUT) |
SBIT(OSMO_CC_STATE_ALERTING_OUT),
OSMO_CC_MSG_PROGRESS_IND, progress_ind},
{SBIT(OSMO_CC_STATE_OVERLAP_OUT),
OSMO_CC_MSG_INFO_REQ, info_req},
{SBIT(OSMO_CC_STATE_PROCEEDING_OUT) | SBIT(OSMO_CC_STATE_ALERTING_OUT),
OSMO_CC_MSG_NOTIFY_IND, notify_ind},
{SBIT(OSMO_CC_STATE_CONNECTING_OUT),
OSMO_CC_MSG_SETUP_COMP_REQ, setup_comp_req},
/* call setup from lower layer protocol */
{SBIT(OSMO_CC_STATE_IDLE),
OSMO_CC_MSG_SETUP_IND, setup_ind},
{SBIT(OSMO_CC_STATE_INIT_IN),
OSMO_CC_MSG_SETUP_ACK_REQ, setup_ack_req},
{SBIT(OSMO_CC_STATE_INIT_IN) | SBIT(OSMO_CC_STATE_OVERLAP_IN),
OSMO_CC_MSG_PROC_REQ, proc_req},
{SBIT(OSMO_CC_STATE_INIT_IN) | SBIT(OSMO_CC_STATE_OVERLAP_IN) |
SBIT(OSMO_CC_STATE_PROCEEDING_IN),
OSMO_CC_MSG_ALERT_REQ, alert_req},
{SBIT(OSMO_CC_STATE_INIT_IN) | SBIT(OSMO_CC_STATE_OVERLAP_IN) |
SBIT(OSMO_CC_STATE_PROCEEDING_IN) | SBIT(OSMO_CC_STATE_ALERTING_IN),
OSMO_CC_MSG_SETUP_RSP, setup_rsp},
{SBIT(OSMO_CC_STATE_OVERLAP_IN) | SBIT(OSMO_CC_STATE_PROCEEDING_IN) |
SBIT(OSMO_CC_STATE_ALERTING_IN),
OSMO_CC_MSG_PROGRESS_REQ, progress_req},
{SBIT(OSMO_CC_STATE_OVERLAP_IN),
OSMO_CC_MSG_INFO_IND, info_ind},
{SBIT(OSMO_CC_STATE_PROCEEDING_IN) | SBIT(OSMO_CC_STATE_ALERTING_IN),
OSMO_CC_MSG_NOTIFY_REQ, notify_req},
{SBIT(OSMO_CC_STATE_CONNECTING_IN),
OSMO_CC_MSG_SETUP_COMP_IND, setup_comp_ind},
/* active state */
{SBIT(OSMO_CC_STATE_ACTIVE),
OSMO_CC_MSG_NOTIFY_IND, notify_ind},
{SBIT(OSMO_CC_STATE_ACTIVE),
OSMO_CC_MSG_NOTIFY_REQ, notify_req},
{SBIT(OSMO_CC_STATE_ACTIVE),
OSMO_CC_MSG_INFO_IND, info_ind},
{SBIT(OSMO_CC_STATE_ACTIVE),
OSMO_CC_MSG_INFO_REQ, info_req},
/* call release */
{SBIT(OSMO_CC_STATE_INIT_OUT) | SBIT(OSMO_CC_STATE_INIT_IN) |
SBIT(OSMO_CC_STATE_OVERLAP_OUT) | SBIT(OSMO_CC_STATE_OVERLAP_IN) |
SBIT(OSMO_CC_STATE_PROCEEDING_OUT) | SBIT(OSMO_CC_STATE_PROCEEDING_IN) |
SBIT(OSMO_CC_STATE_ALERTING_OUT) | SBIT(OSMO_CC_STATE_ALERTING_IN) |
SBIT(OSMO_CC_STATE_CONNECTING_OUT) | SBIT(OSMO_CC_STATE_CONNECTING_IN) |
SBIT(OSMO_CC_STATE_ACTIVE),
OSMO_CC_MSG_DISC_REQ, disc_req},
{SBIT(OSMO_CC_STATE_INIT_OUT) | SBIT(OSMO_CC_STATE_INIT_IN) |
SBIT(OSMO_CC_STATE_OVERLAP_OUT) | SBIT(OSMO_CC_STATE_OVERLAP_IN) |
SBIT(OSMO_CC_STATE_PROCEEDING_OUT) | SBIT(OSMO_CC_STATE_PROCEEDING_IN) |
SBIT(OSMO_CC_STATE_ALERTING_OUT) | SBIT(OSMO_CC_STATE_ALERTING_IN) |
SBIT(OSMO_CC_STATE_CONNECTING_OUT) | SBIT(OSMO_CC_STATE_CONNECTING_IN) |
SBIT(OSMO_CC_STATE_ACTIVE),
OSMO_CC_MSG_DISC_IND, disc_ind},
{SBIT(OSMO_CC_STATE_INIT_OUT),
OSMO_CC_MSG_REJ_IND, rej_ind},
{SBIT(OSMO_CC_STATE_INIT_IN),
OSMO_CC_MSG_REJ_REQ, rej_req},
{SBIT(OSMO_CC_STATE_DISCONNECTING_OUT),
OSMO_CC_MSG_REL_IND, rel_ind},
{SBIT(OSMO_CC_STATE_DISCONNECTING_IN),
OSMO_CC_MSG_REL_REQ, rel_req},
{SBIT(OSMO_CC_STATE_RELEASING_OUT),
OSMO_CC_MSG_REL_CNF, rel_cnf},
/* race condition where disconnect is received after disconnecting (disconnect collision) */
{SBIT(OSMO_CC_STATE_DISCONNECTING_OUT),
OSMO_CC_MSG_DISC_IND, disc_collision_ind},
{SBIT(OSMO_CC_STATE_DISCONNECTING_IN),
OSMO_CC_MSG_DISC_REQ, disc_collision_req},
{SBIT(OSMO_CC_STATE_DISC_COLLISION),
OSMO_CC_MSG_REL_IND, rel_ind},
{SBIT(OSMO_CC_STATE_DISC_COLLISION),
OSMO_CC_MSG_REL_REQ, rel_req},
/* race condition where release is received after releasing (release collision) */
{SBIT(OSMO_CC_STATE_RELEASING_OUT),
OSMO_CC_MSG_REL_IND, rel_collision},
{SBIT(OSMO_CC_STATE_IDLE),
OSMO_CC_MSG_REL_REQ, rel_collision},
/* race condition where reject is received after disconnecting */
{SBIT(OSMO_CC_STATE_DISCONNECTING_OUT),
OSMO_CC_MSG_REJ_IND, rej_ind_disc},
{SBIT(OSMO_CC_STATE_DISCONNECTING_IN),
OSMO_CC_MSG_REJ_REQ, rej_req_disc},
/* turn release into disconnect, so release is possible in any state */
{ALL_STATES,
OSMO_CC_MSG_REL_IND, rel_ind_other},
{ALL_STATES,
OSMO_CC_MSG_REL_REQ, rel_req_other},
};
#define STATEMACHINE_LEN \
(sizeof(statemachine_list) / sizeof(struct statemachine))
static void handle_msg(osmo_cc_call_t *call, osmo_cc_msg_t *msg)
{
int i;
/* Find function for current state and message */
for (i = 0; i < (int)STATEMACHINE_LEN; i++)
if ((msg->type == statemachine_list[i].type)
&& ((1 << call->state) & statemachine_list[i].states))
break;
if (i == STATEMACHINE_LEN) {
PDEBUG(DCC, DEBUG_INFO, "Message %s unhandled at state %s (callref %d)\n",
osmo_cc_msg_value2name(msg->type), state_names[call->state], call->callref);
osmo_cc_free_msg(msg);
return;
}
PDEBUG(DCC, DEBUG_INFO, "Handle message %s at state %s (callref %d)\n",
osmo_cc_msg_value2name(msg->type), state_names[call->state], call->callref);
if (debuglevel <= DEBUG_INFO)
osmo_cc_debug_ie(msg, DEBUG_INFO);
statemachine_list[i].action(call, msg);
}
static int handle_call(osmo_cc_call_t *call)
{
/* may handle only one message, since call may be destroyed when handling */
if (call->sock_queue) {
osmo_cc_msg_t *msg = osmo_cc_msg_list_dequeue(&call->sock_queue, NULL);
handle_msg(call, msg);
return 1;
}
return 0;
}
static int osmo_cc_handle_endpoint(osmo_cc_endpoint_t *ep)
{
int work = 0;
uint32_t callref;
osmo_cc_call_t *call;
/* may handle only one message, since call may be destroyed when handling */
if (ep->ll_queue) {
osmo_cc_msg_t *msg = osmo_cc_msg_list_dequeue(&ep->ll_queue, &callref);
ep->ll_msg_cb(ep, callref, msg);
work |= 1;
}
/* handle only one call, because it might have been removed */
for (call = ep->call_list; call; call = call->next) {
work |= handle_call(call);
if (work)
break;
}
return work;
}
/* main handler
* note that it must be called in a loop (with other handlers) until no work was done
*/
int osmo_cc_handle(void)
{
int work = 0;
osmo_cc_endpoint_t *ep;
for (ep = osmo_cc_endpoint_list; ep; ep = ep->next) {
work |= osmo_cc_handle_endpoint(ep);
work |= osmo_cc_handle_socket(&ep->os);
}
return work;
}
osmo_cc_call_t *osmo_cc_call_by_callref(osmo_cc_endpoint_t *ep, uint32_t callref)
{
osmo_cc_call_t *call;
if (!callref)
return NULL;
for (call = ep->call_list; call; call = call->next) {
if (call->callref == callref) {
return call;
}
}
return NULL;
}
void osmo_cc_ll_msg(osmo_cc_endpoint_t *ep, uint32_t callref, osmo_cc_msg_t *msg)
{
osmo_cc_call_t *call;
if (!(msg->type & 1)) {
PDEBUG(DCC, DEBUG_ERROR, "Received message from lower layer that is not an _IND nor _CNF, please fix!\n");
osmo_cc_free_msg(msg);
return;
}
call = osmo_cc_call_by_callref(ep, callref);
if (call) {
/* complete cause */
osmo_cc_convert_cause_msg(msg);
handle_msg(call, msg);
return;
}
/* if no ref exists */
}
/* message from upper layer (socket) */
void osmo_cc_ul_msg(void *priv, uint32_t callref, osmo_cc_msg_t *msg)
{
osmo_cc_endpoint_t *ep = priv;
osmo_cc_call_t *call;
if ((msg->type & 1)) {
PDEBUG(DCC, DEBUG_ERROR, "Received message from socket that is not an _REQ nor _RSP, please fix!\n");
osmo_cc_free_msg(msg);
return;
}
call = osmo_cc_call_by_callref(ep, callref);
if (call) {
/* if we are not in INIT-IN state, we change a CC-REJ-REQ into CC-REL_REQ.
* this happens, if the socket fails.
*/
if (call->state != OSMO_CC_STATE_INIT_IN
&& msg->type == OSMO_CC_MSG_REJ_REQ)
msg->type = OSMO_CC_MSG_REL_REQ;
osmo_cc_msg_list_enqueue(&call->sock_queue, msg, call->callref);
return;
}
/* if no ref exists */
/* reject and release are ignored */
if (msg->type == OSMO_CC_MSG_REJ_REQ
|| msg->type == OSMO_CC_MSG_REL_REQ) {
osmo_cc_free_msg(msg);
return;
}
/* reject if not a setup/attach or release message */
if (msg->type != OSMO_CC_MSG_SETUP_REQ
&& msg->type != OSMO_CC_MSG_ATTACH_REQ) {
sock_reject_msg(&ep->os, callref, ep->serving_location, 0, OSMO_CC_ISDN_CAUSE_INVAL_CALLREF, 0);
osmo_cc_free_msg(msg);
return;
}
/* create call instance with one socket reference */
call = call_new(ep, callref);
osmo_cc_msg_list_enqueue(&call->sock_queue, msg, call->callref);
}
static void osmo_cc_help_address(void)
{
printf("Address options:\n\n");
printf("local <IPv4 address>:<port>\n");
printf("local [<IPv6 address>]:<port>\n");
printf("remote <IPv4 address>:<port>\n");
printf("remote [<IPv6 address>]:<port>\n\n");
printf("These options can be used to define local and remote IP and port for the socket\n");
printf("interface. Note that IPv6 addresses must be enclosed by '[' and ']'.\n\n");
printf("If no local address was given, the IPv4 loopback IP and port %d is used. If\n", OSMO_CC_DEFAULT_PORT);
printf("this port is already in use, the first free higher port is used.\n\n");
printf("If no remote address is given, the local IP is used. If the local port is %d,\n", OSMO_CC_DEFAULT_PORT);
printf("the remote port will be %d. If not, the remote port will be %d. This way it is\n", OSMO_CC_DEFAULT_PORT + 1, OSMO_CC_DEFAULT_PORT);
printf("possible to link two interfaces without any IP configuration required.\n\n");
}
static int osmo_cc_set_address(osmo_cc_endpoint_t *ep, const char *text)
{
const char **address_p, **host_p;
uint16_t *port_p;
int local = 0;
int rc;
if (!strncasecmp(text, "local", 5)) {
text += 5;
/* remove spaces after keyword */
while (*text) {
if (*text > 32)
break;
text++;
}
address_p = &ep->local_address;
host_p = &ep->local_host;
port_p = &ep->local_port;
local = 1;
} else if (!strncasecmp(text, "remote", 6)) {
text += 6;
/* remove spaces after keyword */
while (*text) {
if (*text > 32)
break;
text++;
}
if (!strcasecmp(text, "auto")) {
PDEBUG(DCC, DEBUG_DEBUG, "setting automatic remote peer selection\n");
ep->remote_auto = 1;
return 0;
}
ep->remote_auto = 0;
address_p = &ep->remote_address;
host_p = &ep->remote_host;
port_p = &ep->remote_port;
} else {
PDEBUG(DCC, DEBUG_ERROR, "Invalid local or remote address definition '%s'\n", text);
return -EINVAL;
}
if (*address_p) {
free((char *)*address_p);
*address_p = NULL;
}
if (*host_p) {
free((char *)*host_p);
*host_p = NULL;
}
rc = split_address(text, host_p, port_p);
if (rc < 0) {
/* unset, so that this is not treated with free() */
*host_p = NULL;
return rc;
}
*address_p = strdup(text);
*host_p = strdup(*host_p);
if (local) {
enum osmo_cc_session_addrtype addrtype;
addrtype = osmo_cc_address_type(*host_p);
if (addrtype == osmo_cc_session_addrtype_unknown) {
PDEBUG(DCC, DEBUG_ERROR, "Given local address '%s' is invalid.\n", *host_p);
return -EINVAL;
}
osmo_cc_set_local_peer(&ep->session_config, osmo_cc_session_nettype_inet, addrtype, *host_p);
return 0;
}
return 0;
}
static void osmo_cc_help_rtp(void)
{
printf("RTP options:\n\n");
printf("rtp-peer <IPv4 address>\n");
printf("rtp-peer <IPv6 address>\n");
printf("rtp-ports <first> <last>\n\n");
printf("These options can be used to alter the local IP and port range for RTP traffic.\n");
printf("By default the local peer is used, which is loopback by default. To connect\n");
printf("interfaces, between machines, local machine's IP must be given.\n\n");
}
static int osmo_cc_set_rtp(osmo_cc_endpoint_t *ep, const char *text)
{
int peer = 0, ports = 0;
if (!strncasecmp(text, "rtp-peer", 8)) {
text += 8;
peer = 1;
} else if (!strncasecmp(text, "rtp-ports", 9)) {
text += 9;
ports = 1;
} else {
PDEBUG(DCC, DEBUG_ERROR, "Invalid RTP definition '%s'\n", text);
return -EINVAL;
}
/* remove spaces after keyword */
while (*text) {
if (*text > 32)
break;
text++;
}
if (peer) {
enum osmo_cc_session_addrtype addrtype;
addrtype = osmo_cc_address_type(text);
if (addrtype == osmo_cc_session_addrtype_unknown) {
PDEBUG(DCC, DEBUG_ERROR, "Given RTP address '%s' is invalid.\n", text);
return -EINVAL;
}
osmo_cc_set_local_peer(&ep->session_config, osmo_cc_session_nettype_inet, addrtype, text);
return 0;
}
if (ports) {
int from = 0, to = 0;
/* from port */
while (*text > ' ') {
if (*text < '0' || *text > '9') {
PDEBUG(DCC, DEBUG_ERROR, "Given 'from' port in '%s' is invalid.\n", text);
return -EINVAL;
}
from = from * 10 + *text - '0';
text++;
}
/* remove spaces after keyword */
while (*text) {
if (*text > 32)
break;
text++;
}
/* to port */
while (*text > ' ') {
if (*text < '0' || *text > '9') {
PDEBUG(DCC, DEBUG_ERROR, "Given 'to' port in '%s' is invalid.\n", text);
return -EINVAL;
}
to = to * 10 + *text - '0';
text++;
}
osmo_cc_set_rtp_ports(&ep->session_config, from, to);
return 0;
}
return -EINVAL;
}
void osmo_cc_help(void)
{
osmo_cc_help_screen();
osmo_cc_help_address();
osmo_cc_help_rtp();
}
/* create a new endpoint instance */
int osmo_cc_new(osmo_cc_endpoint_t *ep, const char *version, const char *name, uint8_t serving_location, void (*ll_msg_cb)(osmo_cc_endpoint_t *ep, uint32_t callref, osmo_cc_msg_t *msg), void (*ul_msg_cb)(osmo_cc_call_t *call, osmo_cc_msg_t *msg), void *priv, int argc, const char *argv[])
{
osmo_cc_endpoint_t **epp;
int rc;
int i;
PDEBUG(DCC, DEBUG_DEBUG, "Creating new endpoint instance.\n");
if (!!strcmp(version, OSMO_CC_VERSION)) {
PDEBUG(DCC, DEBUG_ERROR, "Application was compiled for different Osmo-CC version.\n");
return OSMO_CC_RC_VERSION_MISMATCH;
}
memset(ep, 0, sizeof(*ep));
/* attach to list */
epp = &osmo_cc_endpoint_list;
while (*epp)
epp = &((*epp)->next);
*epp = ep;
if (name)
ep->local_name = strdup(name);
ep->ll_msg_cb = ll_msg_cb;
ep->ul_msg_cb = ul_msg_cb;
ep->serving_location = serving_location;
ep->priv = priv;
osmo_cc_set_local_peer(&ep->session_config, osmo_cc_session_nettype_inet, osmo_cc_session_addrtype_ipv4, "127.0.0.1");
osmo_cc_set_rtp_ports(&ep->session_config, 16384, 32767);
/* apply args */
for (i = 0; i < argc; i++) {
if (!strncasecmp(argv[i], "local", 5)) {
rc = osmo_cc_set_address(ep, argv[i]);
if (rc < 0) {
return rc;
}
} else
if (!strncasecmp(argv[i], "remote", 6)) {
rc = osmo_cc_set_address(ep, argv[i]);
if (rc < 0) {
return rc;
}
} else
if (!strncasecmp(argv[i], "rtp", 3)) {
rc = osmo_cc_set_rtp(ep, argv[i]);
if (rc < 0) {
return rc;
}
} else
if (!strncasecmp(argv[i], "screen", 6)) {
rc = osmo_cc_add_screen(ep, argv[i]);
if (rc < 0) {
return rc;
}
} else {
PDEBUG(DCC, DEBUG_ERROR, "Unknown osmo-cc argument \"%s\"\n", argv[i]);
return -EINVAL;
}
}
/* open socket */
if (!ul_msg_cb) {
char address[256];
const char *host;
uint16_t port;
enum osmo_cc_session_addrtype addrtype;
host = ep->local_host;
port = ep->local_port;
if (!host) {
host = "127.0.0.1";
PDEBUG(DCC, DEBUG_DEBUG, "No local peer set, using default \"%s\"\n", host);
}
rc = osmo_cc_open_socket(&ep->os, host, port, ep, osmo_cc_ul_msg, serving_location);
if (rc < 0) {
return rc;
}
port = rc;
if (!ep->local_host) {
ep->local_host = strdup(host);
/* create address string */
addrtype = osmo_cc_address_type(host);
if (addrtype == osmo_cc_session_addrtype_ipv6)
sprintf(address, "[%s]:%d", host, port);
else
sprintf(address, "%s:%d", host, port);
ep->local_address = strdup(address);
}
ep->local_port = port;
/* auto configure */
if (ep->remote_auto) {
free((char *)ep->remote_host);
ep->remote_host = strdup(ep->local_host);
PDEBUG(DCC, DEBUG_DEBUG, "Remote peer set to auto, using local peer's host \"%s\" for remote peer.\n", ep->remote_host);
if (rc == OSMO_CC_DEFAULT_PORT)
ep->remote_port = OSMO_CC_DEFAULT_PORT + 1;
else
ep->remote_port = OSMO_CC_DEFAULT_PORT;
PDEBUG(DCC, DEBUG_DEBUG, " -> Using remote port %d.\n", ep->remote_port);
/* create address string */
free((char *)ep->remote_address);
addrtype = osmo_cc_address_type(ep->remote_host);
if (addrtype == osmo_cc_session_addrtype_ipv6)
sprintf(address, "[%s]:%d", ep->remote_host, ep->remote_port);
else
sprintf(address, "%s:%d", ep->remote_host, ep->remote_port);
ep->remote_address = strdup(address);
}
/* attach to remote host */
timer_init(&ep->attach_timer, send_attach_ind, ep);
if (ep->remote_host) {
send_attach_ind(&ep->attach_timer);
}
}
return 0;
}
/* destroy an endpoint instance */
void osmo_cc_delete(osmo_cc_endpoint_t *ep)
{
osmo_cc_endpoint_t **epp;
PDEBUG(DCC, DEBUG_DEBUG, "Destroying endpoint instance.\n");
/* detach from list >*/
epp = &osmo_cc_endpoint_list;
while (*epp && *epp != ep)
epp = &((*epp)->next);
if (*epp)
*epp = ep->next;
/* remove timer */
timer_exit(&ep->attach_timer);
/* flush screen lists */
osmo_cc_flush_screen(ep->screen_calling_in);
osmo_cc_flush_screen(ep->screen_called_in);
osmo_cc_flush_screen(ep->screen_calling_out);
osmo_cc_flush_screen(ep->screen_called_out);
/* free local and remote peer */
free((char *)ep->local_name);
free((char *)ep->local_address);
free((char *)ep->local_host);
free((char *)ep->remote_address);
free((char *)ep->remote_host);
/* destroying all child callesses (calls) */
while(ep->call_list)
call_delete(ep->call_list);
/* flush message queue */
while(ep->ll_queue) {
osmo_cc_msg_t *msg = osmo_cc_msg_list_dequeue(&ep->ll_queue, NULL);
osmo_cc_free_msg(msg);
}
/* remove socket */
osmo_cc_close_socket(&ep->os);
memset(ep, 0, sizeof(*ep));
}
/* create new call instance */
osmo_cc_call_t *osmo_cc_call_new(osmo_cc_endpoint_t *ep)
{
return call_new(ep, osmo_cc_new_callref());
}
/* destroy call instance */
void osmo_cc_call_delete(osmo_cc_call_t *call)
{
call_delete(call);
}
/* check valid IP and return address type (protocol) */
enum osmo_cc_session_addrtype osmo_cc_address_type(const char *address)
{
struct sockaddr_storage sa;
int rc;
rc = inet_pton(AF_INET, address, &sa);
if (rc > 0)
return osmo_cc_session_addrtype_ipv4;
rc = inet_pton(AF_INET6, address, &sa);
if (rc > 0)
return osmo_cc_session_addrtype_ipv6;
return osmo_cc_session_addrtype_unknown;
}
/* get host from address */
const char *osmo_cc_host_of_address(const char *address)
{
static char host[256];
char *p;
if (strlen(address) >= sizeof(host)) {
PDEBUG(DCC, DEBUG_ERROR, "String way too long!\n");
return NULL;
}
if (address[0] == '[' && (p = strchr(address, ']'))) {
memcpy(host, address + 1, p - address - 1);
host[p - address - 1] = '\0';
return host;
}
strcpy(host, address);
if ((p = strchr(host, ':')))
*p = '\0';
return host;
}
/* get port from address */
const char *osmo_cc_port_of_address(const char *address)
{
const char *p;
int i;
if (address[0] == '[' && (p = strchr(address, ']')))
address = p + 1;
if (!(p = strchr(address, ':')))
return NULL;
p++;
/* check for zero */
if (p[0] == '0')
return NULL;
/* check for digits */
for (i = 0; i < (int)strlen(p); i++) {
if (p[i] < '0' || p[i] > '9')
return NULL;
}
/* check for magnitude */
if (atoi(p) > 65535)
return NULL;
return p;
}
Reference in New Issue View Git Blame Copy Permalink