sccp: Use the external libosmo-sccp as sccp implementation

Add --enable-nat and --enable-osmo-bsc to build applications
requiring the Osmo SCCP library to be installed. We are not
using autodiscover as this is out of fashion.
changes/88/3188/1
Holger Hans Peter Freyther 13 years ago
parent c44db4a534
commit 30e1ae923d
  1. 24
      openbsc/configure.in
  2. 2
      openbsc/include/Makefile.am
  3. 2
      openbsc/include/sccp/Makefile.am
  4. 177
      openbsc/include/sccp/sccp.h
  5. 420
      openbsc/include/sccp/sccp_types.h
  6. 17
      openbsc/src/Makefile.am
  7. 7
      openbsc/src/bsc/Makefile.am
  8. 5
      openbsc/src/bsc/osmo_bsc_main.c
  9. 6
      openbsc/src/nat/Makefile.am
  10. 1
      openbsc/src/nat/bsc_nat.c
  11. 1425
      openbsc/src/sccp/sccp.c
  12. 6
      openbsc/tests/Makefile.am
  13. 4
      openbsc/tests/bsc-nat/Makefile.am
  14. 3
      openbsc/tests/bsc-nat/bsc_nat_test.c
  15. 8
      openbsc/tests/sccp/Makefile.am
  16. 851
      openbsc/tests/sccp/sccp_test.c

@ -22,6 +22,27 @@ AC_SEARCH_LIBS(gtp_new, gtp,
AM_CONDITIONAL(HAVE_LIBGTP, test "x$GPRS_LIBGTP" != "x")
AC_ARG_ENABLE([nat], [AS_HELP_STRING([--enable-nat], [Build the BSC NAT. Requires SCCP])],
[
PKG_CHECK_MODULES(LIBOSMOSCCP, libosmo-sccp)
osmo_ac_build_nat="yes"
],
[
osmo_ac_build_nat="no"
])
AM_CONDITIONAL(BUILD_NAT, test "x$osmo_ac_build_nat" = "xyes")
AC_ARG_ENABLE([osmo-bsc], [AS_HELP_STRING([--enable-bsc], [Build the Osmo BSC])],
[
PKG_CHECK_MODULES(LIBOSMOSCCP, libosmo-sccp)
osmo_ac_build_bsc="yes"
],
[
osmo_ac_build_bsc="no"
])
AM_CONDITIONAL(BUILD_BSC, test "x$osmo_ac_build_bsc" = "xyes")
PKG_CHECK_MODULES(LIBOSMOCORE, libosmocore >= 0.1.15)
PKG_CHECK_MODULES(LIBOSMOVTY, libosmovty >= 0.1.9)
@ -47,9 +68,7 @@ AM_CONFIG_HEADER(bscconfig.h)
AC_OUTPUT(
openbsc.pc
libsccp.pc
include/openbsc/Makefile
include/sccp/Makefile
include/Makefile
src/Makefile
src/ipaccess/Makefile
@ -61,6 +80,5 @@ AC_OUTPUT(
tests/gsm0408/Makefile
tests/db/Makefile
tests/channel/Makefile
tests/sccp/Makefile
tests/bsc-nat/Makefile
Makefile)

@ -1,3 +1,3 @@
SUBDIRS = openbsc sccp
SUBDIRS = openbsc
noinst_HEADERS = mISDNif.h compat_af_isdn.h

@ -1,2 +0,0 @@
sccp_HEADERS = sccp_types.h sccp.h
sccpdir = $(includedir)/sccp

@ -1,177 +0,0 @@
/*
* SCCP management code
*
* (C) 2009, 2010 by Holger Hans Peter Freyther <zecke@selfish.org>
*
* 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 2 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, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
*/
#ifndef SCCP_H
#define SCCP_H
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/types.h>
#include "sccp_types.h"
struct msgb;
struct sccp_system;
enum {
SCCP_CONNECTION_STATE_NONE,
SCCP_CONNECTION_STATE_REQUEST,
SCCP_CONNECTION_STATE_CONFIRM,
SCCP_CONNECTION_STATE_ESTABLISHED,
SCCP_CONNECTION_STATE_RELEASE,
SCCP_CONNECTION_STATE_RELEASE_COMPLETE,
SCCP_CONNECTION_STATE_REFUSED,
SCCP_CONNECTION_STATE_SETUP_ERROR,
};
struct sockaddr_sccp {
sa_family_t sccp_family; /* AF_SCCP in the future??? */
uint8_t sccp_ssn; /* subssystem number for routing */
/* TODO fill in address indicator... if that is ever needed */
/* not sure about these */
/* uint8_t sccp_class; */
};
/*
* parsed structure of an address
*/
struct sccp_address {
struct sccp_called_party_address address;
uint8_t ssn;
uint8_t poi[2];
};
struct sccp_optional_data {
uint8_t data_len;
uint8_t data_start;
};
struct sccp_connection {
/* public */
void *data_ctx;
void (*data_cb)(struct sccp_connection *conn, struct msgb *msg, unsigned int len);
void *state_ctx;
void (*state_cb)(struct sccp_connection *, int old_state);
struct sccp_source_reference source_local_reference;
struct sccp_source_reference destination_local_reference;
int connection_state;
/* private */
/* list of active connections */
struct llist_head list;
struct sccp_system *system;
int incoming;
};
/**
* system functionality to implement on top of any other transport layer:
* call sccp_system_incoming for incoming data (from the network)
* sccp will call outgoing whenever outgoing data exists
*/
int sccp_system_init(void (*outgoing)(struct msgb *data, void *ctx), void *context);
int sccp_system_incoming(struct msgb *data);
/**
* Send data on an existing connection
*/
int sccp_connection_write(struct sccp_connection *connection, struct msgb *data);
int sccp_connection_send_it(struct sccp_connection *connection);
int sccp_connection_close(struct sccp_connection *connection, int cause);
int sccp_connection_free(struct sccp_connection *connection);
/**
* internal..
*/
int sccp_connection_force_free(struct sccp_connection *conn);
/**
* Create a new socket. Set your callbacks and then call bind to open
* the connection.
*/
struct sccp_connection *sccp_connection_socket(void);
/**
* Open the connection and send additional data
*/
int sccp_connection_connect(struct sccp_connection *conn,
const struct sockaddr_sccp *sccp_called,
struct msgb *data);
/**
* mostly for testing purposes only. Set the accept callback.
* TODO: add true routing information... in analogy to socket, bind, accept
*/
int sccp_connection_set_incoming(const struct sockaddr_sccp *sock,
int (*accept_cb)(struct sccp_connection *connection, void *data),
void *user_data);
/**
* Send data in terms of unit data. A fixed address indicator will be used.
*/
int sccp_write(struct msgb *data,
const struct sockaddr_sccp *sock_sender,
const struct sockaddr_sccp *sock_target, int class);
int sccp_set_read(const struct sockaddr_sccp *sock,
int (*read_cb)(struct msgb *msgb, unsigned int, void *user_data),
void *user_data);
/* generic sock addresses */
extern const struct sockaddr_sccp sccp_ssn_bssap;
/* helpers */
uint32_t sccp_src_ref_to_int(struct sccp_source_reference *ref);
struct sccp_source_reference sccp_src_ref_from_int(uint32_t);
struct msgb *sccp_create_refuse(struct sccp_source_reference *src_ref, int cause, uint8_t *data, int length);
struct msgb *sccp_create_cc(struct sccp_source_reference *src_ref, struct sccp_source_reference *dst_ref);
struct msgb *sccp_create_rlsd(struct sccp_source_reference *src_ref, struct sccp_source_reference *dst_ref, int cause);
struct msgb *sccp_create_dt1(struct sccp_source_reference *dst_ref, uint8_t *data, uint8_t len);
/**
* Below this are helper functions and structs for parsing SCCP messages
*/
struct sccp_parse_result {
struct sccp_address called;
struct sccp_address calling;
/* point to the msg packet */
struct sccp_source_reference *source_local_reference;
struct sccp_source_reference *destination_local_reference;
/* data pointer */
int data_len;
};
/*
* helper functions for the nat code
*/
int sccp_determine_msg_type(struct msgb *msg);
int sccp_parse_header(struct msgb *msg, struct sccp_parse_result *result);
#endif

@ -1,420 +0,0 @@
/*
* ITU Q.713 defined types for SCCP
*
* (C) 2009 by Holger Hans Peter Freyther <zecke@selfish.org>
*
* 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 2 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, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
*/
#ifndef SCCP_TYPES_H
#define SCCP_TYPES_H
#include <endian.h>
/* Table 1/Q.713 - SCCP message types */
enum sccp_message_types {
SCCP_MSG_TYPE_CR = 1,
SCCP_MSG_TYPE_CC = 2,
SCCP_MSG_TYPE_CREF = 3,
SCCP_MSG_TYPE_RLSD = 4,
SCCP_MSG_TYPE_RLC = 5,
SCCP_MSG_TYPE_DT1 = 6,
SCCP_MSG_TYPE_DT2 = 7,
SCCP_MSG_TYPE_AK = 8,
SCCP_MSG_TYPE_UDT = 9,
SCCP_MSG_TYPE_UDTS = 10,
SCCP_MSG_TYPE_ED = 11,
SCCP_MSG_TYPE_EA = 12,
SCCP_MSG_TYPE_RSR = 13,
SCCP_MSG_TYPE_RSC = 14,
SCCP_MSG_TYPE_ERR = 15,
SCCP_MSG_TYPE_IT = 16,
SCCP_MSG_TYPE_XUDT = 17,
SCCP_MSG_TYPE_XUDTS = 18,
SCCP_MSG_TYPE_LUDT = 19,
SCCP_MSG_TYPE_LUDTS = 20
};
/* Table 2/Q.713 - SCCP parameter name codes */
enum sccp_parameter_name_codes {
SCCP_PNC_END_OF_OPTIONAL = 0,
SCCP_PNC_DESTINATION_LOCAL_REFERENCE = 1,
SCCP_PNC_SOURCE_LOCAL_REFERENCE = 2,
SCCP_PNC_CALLED_PARTY_ADDRESS = 3,
SCCP_PNC_CALLING_PARTY_ADDRESS = 4,
SCCP_PNC_PROTOCOL_CLASS = 5,
SCCP_PNC_SEGMENTING = 6,
SCCP_PNC_RECEIVE_SEQ_NUMBER = 7,
SCCP_PNC_SEQUENCING = 8,
SCCP_PNC_CREDIT = 9,
SCCP_PNC_RELEASE_CAUSE = 10,
SCCP_PNC_RETURN_CAUSE = 11,
SCCP_PNC_RESET_CAUSE = 12,
SCCP_PNC_ERROR_CAUSE = 13,
SCCP_PNC_REFUSAL_CAUSE = 14,
SCCP_PNC_DATA = 15,
SCCP_PNC_SEGMENTATION = 16,
SCCP_PNC_HOP_COUNTER = 17,
SCCP_PNC_IMPORTANCE = 18,
SCCP_PNC_LONG_DATA = 19,
};
/* Figure 3/Q.713 Called/calling party address */
enum {
SCCP_TITLE_IND_NONE = 0,
SCCP_TITLE_IND_NATURE_ONLY = 1,
SCCP_TITLE_IND_TRANSLATION_ONLY = 2,
SCCP_TITLE_IND_TRANS_NUM_ENC = 3,
SCCP_TITLE_IND_TRANS_NUM_ENC_NATURE = 4,
};
enum {
SCCP_CALL_ROUTE_ON_SSN = 1,
SCCP_CALL_ROUTE_ON_GT = 0,
};
struct sccp_called_party_address {
#if __BYTE_ORDER == __LITTLE_ENDIAN
uint8_t point_code_indicator : 1,
ssn_indicator : 1,
global_title_indicator : 4,
routing_indicator : 1,
reserved : 1;
#elif __BYTE_ORDER == __BIG_ENDIAN
uint8_t reserved : 1,
routing_indicator : 1,
global_title_indicator : 4,
ssn_indicator : 1,
point_code_indicator : 1;
#endif
uint8_t data[0];
} __attribute__((packed));
/* indicator indicates presence in the above order */
/* Figure 6/Q.713 */
struct sccp_signalling_point_code {
uint8_t lsb;
#if __BYTE_ORDER == __LITTLE_ENDIAN
uint8_t msb : 6,
reserved : 2;
#elif __BYTE_ORDER == __BIG_ENDIAN
uint8_t reserved : 2,
msb : 6;
#endif
} __attribute__((packed));
/* SSN == subsystem number */
enum sccp_subsystem_number {
SCCP_SSN_NOT_KNOWN_OR_USED = 0,
SCCP_SSN_MANAGEMENT = 1,
SCCP_SSN_RESERVED_ITU = 2,
SCCP_SSN_ISDN_USER_PART = 3,
SCCP_SSN_OMAP = 4, /* operation, maint and administration part */
SCCP_SSN_MAP = 5, /* mobile application part */
SCCP_SSN_HLR = 6,
SCCP_SSN_VLR = 7,
SCCP_SSN_MSC = 8,
SCCP_SSN_EIC = 9, /* equipent identifier centre */
SCCP_SSN_AUC = 10, /* authentication centre */
SCCP_SSN_ISDN_SUPPL_SERVICES = 11,
SCCP_SSN_RESERVED_INTL = 12,
SCCP_SSN_ISDN_EDGE_TO_EDGE = 13,
SCCP_SSN_TC_TEST_RESPONDER = 14,
/* From GSM 03.03 8.2 */
SCCP_SSN_BSSAP = 254,
SCCP_SSN_BSSOM = 253,
};
/* Q.713, 3.4.2.3 */
enum {
SCCP_NAI_UNKNOWN = 0,
SCCP_NAI_SUBSCRIBER_NUMBER = 1,
SCCP_NAI_RESERVED_NATIONAL = 2,
SCCP_NAI_NATIONAL_SIGNIFICANT = 3,
SCCP_NAI_INTERNATIONAL = 4,
};
struct sccp_global_title {
#if __BYTE_ORDER == __LITTLE_ENDIAN
uint8_t nature_of_addr_ind : 7,
odd_even : 1;
#elif __BYTE_ORDER == __BIG_ENDIAN
uint8_t odd_even : 1,
nature_of_addr_ind : 7;
#endif
uint8_t data[0];
} __attribute__((packed));
/* Q.713, 3.3 */
struct sccp_source_reference {
uint8_t octet1;
uint8_t octet2;
uint8_t octet3;
} __attribute__((packed));
/* Q.714, 3.6 */
enum sccp_protocol_class {
SCCP_PROTOCOL_CLASS_0 = 0,
SCCP_PROTOCOL_CLASS_1 = 1,
SCCP_PROTOCOL_CLASS_2 = 2,
SCCP_PROTOCOL_CLASS_3 = 3,
};
/* bits 5-8 when class0, class1 is used */
enum sccp_protocol_options {
SCCP_PROTOCOL_NO_SPECIAL = 0,
SCCP_PROTOCOL_RETURN_MESSAGE = 8,
};
enum sccp_release_cause {
SCCP_RELEASE_CAUSE_END_USER_ORIGINATED = 0,
SCCP_RELEASE_CAUSE_END_USER_CONGESTION = 1,
SCCP_RELEASE_CAUSE_END_USER_FAILURE = 2,
SCCP_RELEASE_CAUSE_SCCP_USER_ORIGINATED = 3,
SCCP_RELEASE_CAUSE_REMOTE_PROCEDURE_ERROR = 4,
SCCP_RELEASE_CAUSE_INCONSISTENT_CONN_DATA = 5,
SCCP_RELEASE_CAUSE_ACCESS_FAILURE = 6,
SCCP_RELEASE_CAUSE_ACCESS_CONGESTION = 7,
SCCP_RELEASE_CAUSE_SUBSYSTEM_FAILURE = 8,
SCCP_RELEASE_CAUSE_SUBSYSTEM_CONGESTION = 9,
SCCP_RELEASE_CAUSE_MTP_FAILURE = 10,
SCCP_RELEASE_CAUSE_NETWORK_CONGESTION = 11,
SCCP_RELEASE_CAUSE_EXPIRATION_RESET = 12,
SCCP_RELEASE_CAUSE_EXPIRATION_INACTIVE = 13,
SCCP_RELEASE_CAUSE_RESERVED = 14,
SCCP_RELEASE_CAUSE_UNQUALIFIED = 15,
SCCP_RELEASE_CAUSE_SCCP_FAILURE = 16,
};
enum sccp_return_cause {
SCCP_RETURN_CAUSE_NO_TRANSLATION_NATURE = 0,
SCCP_RETURN_CAUSE_NO_TRANSLATION = 1,
SCCP_RETURN_CAUSE_SUBSYSTEM_CONGESTION = 2,
SCCP_RETURN_CAUSE_SUBSYSTEM_FAILURE = 3,
SCCP_RETURN_CAUSE_UNEQUIPPED_USER = 4,
SCCP_RETURN_CAUSE_MTP_FAILURE = 5,
SCCP_RETURN_CAUSE_NETWORK_CONGESTION = 6,
SCCP_RETURN_CAUSE_UNQUALIFIED = 7,
SCCP_RETURN_CAUSE_ERROR_IN_MSG_TRANSPORT = 8,
SCCP_RETURN_CAUSE_ERROR_IN_LOCAL_PROCESSING = 9,
SCCP_RETURN_CAUSE_DEST_CANNOT_PERFORM_REASSEMBLY = 10,
SCCP_RETURN_CAUSE_SCCP_FAILURE = 11,
SCCP_RETURN_CAUSE_HOP_COUNTER_VIOLATION = 12,
SCCP_RETURN_CAUSE_SEGMENTATION_NOT_SUPPORTED= 13,
SCCP_RETURN_CAUSE_SEGMENTATION_FAOLURE = 14
};
enum sccp_reset_cause {
SCCP_RESET_CAUSE_END_USER_ORIGINATED = 0,
SCCP_RESET_CAUSE_SCCP_USER_ORIGINATED = 1,
SCCP_RESET_CAUSE_MSG_OUT_OF_ORDER_PS = 2,
SCCP_RESET_CAUSE_MSG_OUT_OF_ORDER_PR = 3,
SCCP_RESET_CAUSE_RPC_OUT_OF_WINDOW = 4,
SCCP_RESET_CAUSE_RPC_INCORRECT_PS = 5,
SCCP_RESET_CAUSE_RPC_GENERAL = 6,
SCCP_RESET_CAUSE_REMOTE_END_USER_OPERATIONAL= 7,
SCCP_RESET_CAUSE_NETWORK_OPERATIONAL = 8,
SCCP_RESET_CAUSE_ACCESS_OPERATIONAL = 9,
SCCP_RESET_CAUSE_NETWORK_CONGESTION = 10,
SCCP_RESET_CAUSE_RESERVED = 11,
};
enum sccp_error_cause {
SCCP_ERROR_LRN_MISMATCH_UNASSIGNED = 0, /* local reference number */
SCCP_ERROR_LRN_MISMATCH_INCONSISTENT = 1,
SCCP_ERROR_POINT_CODE_MISMATCH = 2,
SCCP_ERROR_SERVICE_CLASS_MISMATCH = 3,
SCCP_ERROR_UNQUALIFIED = 4,
};
enum sccp_refusal_cause {
SCCP_REFUSAL_END_USER_ORIGINATED = 0,
SCCP_REFUSAL_END_USER_CONGESTION = 1,
SCCP_REFUSAL_END_USER_FAILURE = 2,
SCCP_REFUSAL_SCCP_USER_ORIGINATED = 3,
SCCP_REFUSAL_DESTINATION_ADDRESS_UKNOWN = 4,
SCCP_REFUSAL_DESTINATION_INACCESSIBLE = 5,
SCCP_REFUSAL_NET_QOS_NON_TRANSIENT = 6,
SCCP_REFUSAL_NET_QOS_TRANSIENT = 7,
SCCP_REFUSAL_ACCESS_FAILURE = 8,
SCCP_REFUSAL_ACCESS_CONGESTION = 9,
SCCP_REFUSAL_SUBSYSTEM_FAILURE = 10,
SCCP_REFUSAL_SUBSYTEM_CONGESTION = 11,
SCCP_REFUSAL_EXPIRATION = 12,
SCCP_REFUSAL_INCOMPATIBLE_USER_DATA = 13,
SCCP_REFUSAL_RESERVED = 14,
SCCP_REFUSAL_UNQUALIFIED = 15,
SCCP_REFUSAL_HOP_COUNTER_VIOLATION = 16,
SCCP_REFUSAL_SCCP_FAILURE = 17,
SCCP_REFUSAL_UNEQUIPPED_USER = 18,
};
/*
* messages... as of Q.713 Chapter 4
*/
struct sccp_connection_request {
/* mandantory */
uint8_t type;
struct sccp_source_reference source_local_reference;
uint8_t proto_class;
/* variable */
uint8_t variable_called;
#if VARIABLE
called_party_address
#endif
/* optional */
uint8_t optional_start;
#if OPTIONAL
credit 3
callingparty var 4-n
data 3-130
hop_counter 3
importance 3
end_of_optional 1
#endif
uint8_t data[0];
} __attribute__((packed));
struct sccp_connection_confirm {
/* mandantory */
uint8_t type;
struct sccp_source_reference destination_local_reference;
struct sccp_source_reference source_local_reference;
uint8_t proto_class;
/* optional */
uint8_t optional_start;
/* optional */
#if OPTIONAL
credit 3
called party 4
data 3-130
importance 3
end_of_optional 1
#endif
uint8_t data[0];
} __attribute__((packed));
struct sccp_connection_refused {
/* mandantory */
uint8_t type;
struct sccp_source_reference destination_local_reference;
uint8_t cause;
/* optional */
uint8_t optional_start;
/* optional */
#if OPTIONAL
called party 4
data 3-130
importance 3
end_of_optional 1
#endif
uint8_t data[0];
} __attribute__((packed));
struct sccp_connection_released {
/* mandantory */
uint8_t type;
struct sccp_source_reference destination_local_reference;
struct sccp_source_reference source_local_reference;
uint8_t release_cause;
/* optional */
uint8_t optional_start;
#if OPTIONAL
data 3-130
importance 3
end_of_optional 1
#endif
uint8_t data[0];
} __attribute__((packed));
struct sccp_connection_release_complete {
uint8_t type;
struct sccp_source_reference destination_local_reference;
struct sccp_source_reference source_local_reference;
} __attribute__((packed));
struct sccp_data_form1 {
/* mandantory */
uint8_t type;
struct sccp_source_reference destination_local_reference;
uint8_t segmenting;
/* variable */
uint8_t variable_start;
#if VARIABLE
data 2-256;
#endif
uint8_t data[0];
} __attribute__((packed));
struct sccp_data_unitdata {
/* mandantory */
uint8_t type;
uint8_t proto_class;
/* variable */
uint8_t variable_called;
uint8_t variable_calling;
uint8_t variable_data;
#if VARIABLE
called party address
calling party address
#endif
uint8_t data[0];
} __attribute__((packed));
struct sccp_data_it {
/* mandantory */
uint8_t type;
struct sccp_source_reference destination_local_reference;
struct sccp_source_reference source_local_reference;
uint8_t proto_class;
uint8_t sequencing[2];
uint8_t credit;
} __attribute__((packed));
struct sccp_proto_err {
uint8_t type;
struct sccp_source_reference destination_local_reference;
uint8_t error_cause;
};
#endif

@ -3,13 +3,18 @@ AM_CFLAGS=-Wall $(LIBOSMOCORE_CFLAGS) $(LIBOSMOVTY_CFLAGS)
AM_LDFLAGS = $(LIBOSMOCORE_LIBS)
# build current directory before building gprs
SUBDIRS = . ipaccess gprs nat bsc
SUBDIRS = . ipaccess gprs
sbin_PROGRAMS = bsc_hack bs11_config isdnsync bsc_mgcp
noinst_LIBRARIES = libbsc.a libmsc.a libvty.a libsccp.a libmgcp.a
# Conditional modules
if BUILD_NAT
SUBDIRS += nat
endif
if BUILD_BSC
SUBDIRS += bsc
endif
bscdir = $(libdir)
bsc_LIBRARIES = libsccp.a
sbin_PROGRAMS = bsc_hack bs11_config isdnsync bsc_mgcp
noinst_LIBRARIES = libbsc.a libmsc.a libvty.a libmgcp.a
libbsc_a_SOURCES = abis_rsl.c abis_nm.c gsm_data.c gsm_04_08_utils.c \
chan_alloc.c debug.c socket.c abis_nm_vty.c \
@ -28,8 +33,6 @@ libmsc_a_SOURCES = gsm_subscriber.c db.c \
libvty_a_SOURCES = common_vty.c
libsccp_a_SOURCES = sccp/sccp.c
libmgcp_a_SOURCES = mgcp/mgcp_protocol.c mgcp/mgcp_network.c mgcp/mgcp_vty.c
bsc_hack_SOURCES = bsc_hack.c bsc_init.c bsc_vty.c vty_interface_layer3.c

@ -1,5 +1,5 @@
INCLUDES = $(all_includes) -I$(top_srcdir)/include -I$(top_builddir)
AM_CFLAGS=-Wall $(LIBOSMOCORE_CFLAGS) $(LIBOSMOVTY_CFLAGS)
AM_CFLAGS=-Wall $(LIBOSMOCORE_CFLAGS) $(LIBOSMOVTY_CFLAGS) $(LIBOSMOSCCP_CFLAGS)
AM_LDFLAGS = $(LIBOSMOCORE_LIBS) $(LIBOSMOVTY_LIBS)
bin_PROGRAMS = osmo-bsc
@ -8,5 +8,6 @@ bin_PROGRAMS = osmo-bsc
osmo_bsc_SOURCES = osmo_bsc_main.c osmo_bsc_rf.c osmo_bsc_vty.c osmo_bsc_api.c \
$(top_srcdir)/src/debug.c $(top_srcdir)/src/bsc_msc.c \
$(top_srcdir)/src/bsc_init.c
osmo_bsc_LDADD = $(top_builddir)/src/libvty.a $(top_builddir)/src/libsccp.a \
$(top_builddir)/src/libmgcp.a $(top_builddir)/src/libbsc.a
osmo_bsc_LDADD = $(top_builddir)/src/libvty.a \
$(top_builddir)/src/libmgcp.a $(top_builddir)/src/libbsc.a \
$(LIBOSMOSCCP_LIBS)

@ -26,6 +26,8 @@
#include <osmocom/vty/command.h>
#include <osmocore/talloc.h>
#include <sccp/sccp.h>
#define _GNU_SOURCE
#include <getopt.h>
@ -158,6 +160,9 @@ int main(int argc, char **argv)
/* seed the PRNG */
srand(time(NULL));
/* initialize SCCP */
sccp_set_log_area(DSCCP);
rc = bsc_bootstrap_network(NULL, config_file);
if (rc < 0) {

@ -1,5 +1,5 @@
INCLUDES = $(all_includes) -I$(top_srcdir)/include -I$(top_builddir)
AM_CFLAGS=-Wall $(LIBOSMOCORE_CFLAGS) $(LIBOSMOVTY_CFLAGS)
AM_CFLAGS=-Wall $(LIBOSMOCORE_CFLAGS) $(LIBOSMOVTY_CFLAGS) $(LIBOSMOSCCP_CFLAGS)
AM_LDFLAGS = $(LIBOSMOCORE_LIBS) $(LIBOSMOVTY_LIBS)
bin_PROGRAMS = bsc_nat
@ -8,6 +8,6 @@ bin_PROGRAMS = bsc_nat
bsc_nat_SOURCES = bsc_filter.c bsc_mgcp_utils.c bsc_nat.c bsc_nat_utils.c \
bsc_nat_vty.c bsc_sccp.c \
$(top_srcdir)/src/debug.c $(top_srcdir)/src/bsc_msc.c
bsc_nat_LDADD = $(top_builddir)/src/libvty.a $(top_builddir)/src/libsccp.a \
bsc_nat_LDADD = $(top_builddir)/src/libvty.a \
$(top_builddir)/src/libmgcp.a $(top_builddir)/src/libbsc.a \
-lrt
-lrt $(LIBOSMOSCCP_LIBS)

@ -1178,6 +1178,7 @@ int main(int argc, char** argv)
signal(SIGPIPE, SIG_IGN);
/* recycle timer */
sccp_set_log_area(DSCCP);
sccp_close.cb = sccp_close_unconfirmed;
sccp_close.data = NULL;
bsc_schedule_timer(&sccp_close, SCCP_CLOSE_TIME, 0);

File diff suppressed because it is too large Load Diff

@ -1 +1,5 @@
SUBDIRS = debug gsm0408 db channel sccp bsc-nat
SUBDIRS = debug gsm0408 db channel
if BUILD_NAT
SUBDIRS += bsc-nat
endif

@ -1,5 +1,5 @@
INCLUDES = $(all_includes) -I$(top_srcdir)/include
AM_CFLAGS=-Wall -ggdb3 $(LIBOSMOCORE_CFLAGS)
AM_CFLAGS=-Wall -ggdb3 $(LIBOSMOCORE_CFLAGS) $(LIBOSMOSCCP_CFLAGS)
EXTRA_DIST = bsc_data.c
@ -12,4 +12,4 @@ bsc_nat_test_SOURCES = bsc_nat_test.c \
$(top_srcdir)/src/nat/bsc_mgcp_utils.c \
$(top_srcdir)/src/mgcp/mgcp_protocol.c \
$(top_srcdir)/src/mgcp/mgcp_network.c
bsc_nat_test_LDADD = $(top_builddir)/src/libbsc.a $(top_builddir)/src/libsccp.a $(LIBOSMOCORE_LIBS) -lrt
bsc_nat_test_LDADD = $(top_builddir)/src/libbsc.a $(LIBOSMOCORE_LIBS) -lrt $(LIBOSMOSCCP_LIBS)

@ -29,6 +29,8 @@
#include <osmocore/talloc.h>
#include <sccp/sccp.h>
#include <stdio.h>
/* test messages for ipa */
@ -699,6 +701,7 @@ int main(int argc, char **argv)
{
struct log_target *stderr_target;
sccp_set_log_area(DSCCP);
log_init(&log_info);
stderr_target = log_target_create_stderr();
log_add_target(stderr_target);

@ -1,8 +0,0 @@
INCLUDES = $(all_includes) -I$(top_srcdir)/include
AM_CFLAGS=-Wall -ggdb3 $(LIBOSMOCORE_CFLAGS)
noinst_PROGRAMS = sccp_test
sccp_test_SOURCES = sccp_test.c
sccp_test_LDADD = $(top_builddir)/src/libsccp.a $(top_builddir)/src/libbsc.a $(LIBOSMOCORE_LIBS)

@ -1,851 +0,0 @@
/*
* SCCP testing code
*
* (C) 2009 by Holger Hans Peter Freyther <zecke@selfish.org>
* (C) 2009 by On-Waves
*
* 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 2 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, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
*/
#include <stdio.h>
#include <arpa/inet.h>
#include <openbsc/gsm_data.h>
#include <openbsc/debug.h>
#include <osmocore/msgb.h>
#include <sccp/sccp.h>
#define MIN(x, y) ((x) < (y) ? (x) : (y))
/* BSC -> MSC */
static const uint8_t bssmap_reset[] = {
0x09, 0x00, 0x03, 0x05, 0x07, 0x02, 0x42, 0xfe,
0x02, 0x42, 0xfe, 0x06, 0x00, 0x04, 0x30, 0x04,
0x01, 0x20,
};
/* MSC -> BSC reset ack */
static const uint8_t bssmap_reset_ack[] = {
0x09, 0x00, 0x03, 0x07, 0x0b, 0x04, 0x43, 0x01,
0x00, 0xfe, 0x04, 0x43, 0x5c, 0x00, 0xfe, 0x03,
0x00, 0x01, 0x31,
};
/* MSC -> BSC paging, connection less */
static const uint8_t bssmap_paging[] = {
0x09, 0x00, 0x03, 0x07, 0x0b, 0x04, 0x43, 0x01,
0x00, 0xfe, 0x04, 0x43, 0x5c, 0x00, 0xfe, 0x10,
0x00, 0x0e, 0x52, 0x08, 0x08, 0x29, 0x47, 0x10,
0x02, 0x01, 0x31, 0x97, 0x61, 0x1a, 0x01, 0x06,
};
/* MSC -> BSC paging, UDT without PC */
static const uint8_t bssmap_udt[] = {
0x09, 0x00, 0x03, 0x05, 0x07, 0x02, 0x42, 0xfe,
0x02, 0x42, 0xfe, 0x10, 0x00, 0x0e, 0x52, 0x08,
0x08, 0x29, 0x47, 0x10, 0x02, 0x01, 0x31, 0x97,
0x61, 0x1a, 0x01, 0x06,
};
/* BSC -> MSC connection open */
static const uint8_t bssmap_cr[] = {
0x01, 0x01, 0x02, 0x03, 0x02, 0x02, 0x04, 0x02,
0x42, 0xfe, 0x0f, 0x1f, 0x00, 0x1d, 0x57, 0x05,
0x08, 0x00, 0x72, 0xf4, 0x80, 0x20, 0x12, 0xc3,
0x50, 0x17, 0x10, 0x05, 0x24, 0x11, 0x03, 0x33,
0x19, 0xa2, 0x08, 0x29, 0x47, 0x10, 0x02, 0x01,
0x31, 0x97, 0x61, 0x00
};
/* MSC -> BSC connection confirm */
static const uint8_t bssmap_cc[] = {
0x02, 0x01, 0x02, 0x03, 0x00, 0x00, 0x03, 0x02, 0x01, 0x00,
};
/* MSC -> BSC DTAP
*
* we fake a bit and make it BSC -> MSC... so the
* payload does not make any sense..
*/
static const uint8_t bssmap_dtap[] = {
0x06, 0x00, 0x00, 0x03, 0x00, 0x01, 0x0f, 0x01, 0x00, 0x0c,
0x03, 0x05, 0x5c, 0x08, 0x11, 0x81, 0x33, 0x66, 0x02, 0x13,
0x45, 0xf4,
};
/* MSC -> BSC clear command */
static const uint8_t bssmap_clear[] = {
0x06, 0x00, 0x00, 0x03, 0x00, 0x01, 0x06, 0x00, 0x04, 0x20,
0x04, 0x01, 0x09,
};
/* MSC -> BSC released */
static const uint8_t bssmap_released[] = {
0x04, 0x00, 0x00, 0x03, 0x01, 0x02, 0x03, 0x00, 0x01, 0x0f,
0x02, 0x23, 0x42, 0x00,
};
/* BSC -> MSC released */
static const uint8_t bssmap_release_complete[] = {
0x05, 0x01, 0x02, 0x03, 0x00, 0x00, 0x03
};
struct test_data {
int length;
const uint8_t *data;
int payload_start;
int payload_length;
uint8_t first_byte;
/* in case it should trigger a sccp response */
int write;
const uint8_t *response;
int response_length;
};
static const struct test_data test_data[] = {
{
.length = ARRAY_SIZE(bssmap_reset),
.data = &bssmap_reset[0],
.payload_start = 12,
.payload_length = ARRAY_SIZE(bssmap_reset) - 12,
.first_byte = 0x0,
},
{
.length = ARRAY_SIZE(bssmap_reset_ack),
.data = &bssmap_reset_ack[0],
.payload_start = 16,
.payload_length = ARRAY_SIZE(bssmap_reset_ack) - 16,
.first_byte = 0x0,
},
{
.length = ARRAY_SIZE(bssmap_paging),
.data = &bssmap_paging[0],
.payload_start = 16,
.payload_length = ARRAY_SIZE(bssmap_paging) - 16,
.first_byte = 0x0,
},
{
.length = ARRAY_SIZE(bssmap_cr),
.data = &bssmap_cr[0],
.payload_start = 12,
/* 0x00 is end of optional data, subtract this byte */
.payload_length = 31,
.first_byte = 0x0,
/* the connection request should trigger a connection confirm */
.write = 1,
.response = &bssmap_cc[0],
.response_length= ARRAY_SIZE(bssmap_cc),
},
{
.length = ARRAY_SIZE(bssmap_dtap),
.data = &bssmap_dtap[0],
.payload_start = 7,
.payload_length = 15,
.first_byte = 0x01,
},
{
.length = ARRAY_SIZE(bssmap_clear),
.data = &bssmap_clear[0],
.payload_start = 7,
.payload_length = 6,
.first_byte = 0x00,
},
{
.length = ARRAY_SIZE(bssmap_released),
.data = &bssmap_released[0],
.payload_length = 2,
.payload_start = 11,
.first_byte = 0x23,
.write = 1,
.response = &bssmap_release_complete[0],
.response_length= ARRAY_SIZE(bssmap_release_complete),
},
};
/* we will send UDTs and verify they look like this */
static const struct test_data send_data[] = {
{
.length = ARRAY_SIZE(bssmap_udt),
.data = &bssmap_udt[0],
.payload_start = 12,
.payload_length = ARRAY_SIZE(bssmap_udt) - 12,
.first_byte = 0x0,
},
{
.length = ARRAY_SIZE(bssmap_reset),
.data = &bssmap_reset[0],
.payload_start = 12,
.payload_length = ARRAY_SIZE(bssmap_reset) - 12,
.first_byte = 0x0,
},
};
struct connection_test {
/* should the connection be refused? */
int refuse;
int with_data;
/* on which side to close the connection? */
int close_side;
int close_cause;
};
/* sccp connection handling we want to test */
static const struct connection_test connection_tests[] = {
{
.refuse = 1,
},
{
.refuse = 1,
.with_data = 1,
},
{
.refuse = 0,
.close_side = 0,
.close_cause = 5,
},
{
.refuse = 0,
.close_side = 0,
.close_cause = 5,
.with_data = 1,
},
{
.refuse = 0,
.close_side = 1,
.close_cause = 5,
},
{
.refuse = 0,
.close_side = 1,
.close_cause = 5,
.with_data = 1,
},
};
struct sccp_parse_header_result {
/* results */
int msg_type;
int wanted_len;
int src_ssn;
int dst_ssn;
int has_src_ref, has_dst_ref;
struct sccp_source_reference src_ref;
struct sccp_source_reference dst_ref;
/* the input */
const uint8_t *input;
int input_len;
};
static const uint8_t it_test[] = {
0x10, 0x01, 0x07,
0x94, 0x01, 0x04, 0x00, 0x02, 0x00, 0x00, 0x00 };
static const uint8_t proto_err[] = {
0x0f, 0x0c, 0x04, 0x00, 0x00,
};
static const struct sccp_parse_header_result parse_result[] = {
{
.msg_type = SCCP_MSG_TYPE_IT,
.wanted_len = 0,
.src_ssn = -1,
.dst_ssn = -1,
.has_src_ref = 1,
.has_dst_ref = 1,
.src_ref = {
.octet1 = 0x01,
.octet2 = 0x04,
.octet3 = 0x00
},
.dst_ref = {
.octet1 = 0x01,
.octet2 = 0x07,
.octet3 = 0x94,
},
.input = it_test,
.input_len = sizeof(it_test),
},
{
.msg_type = SCCP_MSG_TYPE_ERR,
.wanted_len = 0,
.src_ssn = -1,
.dst_ssn = -1,
.has_src_ref = 0,
.has_dst_ref = 1,
.dst_ref = {
.octet1 = 0x0c,
.octet2 = 0x04,
.octet3 = 0x00,
},
.input = proto_err,
.input_len = sizeof(proto_err),
},
};
/* testing procedure:
* - we will use sccp_write and see what will be set in the
* outgoing callback
* - we will call sccp_system_incoming and see which calls
* are made. And then compare it to the ones we expect. We
* want the payload to arrive, or callbacks to be called.
* - we will use sccp_connection_socket and sccp_connection_write
* and verify state handling of connections
*/
static int current_test;
/*
* test state...
*/
static int called = 0;
static int matched = 0;
static int write_called = 0;
#define FAIL(x, args...) printf("FAILURE in %s:%d: " x, __FILE__, __LINE__, ## args)
/*
* writing these packets and expecting a result
*/
int sccp_read_cb(struct msgb *data, unsigned len, void *context)
{
uint16_t payload_length = test_data[current_test].payload_length;
const uint8_t *got, *wanted;
int i;
called = 1;
if (msgb_l3len(data) < len) {
/* this should never be reached */
FAIL("Something horrible happened.. invalid packet..\n");
exit(-1);
}
if (len == 0 || len != payload_length) {
FAIL("length mismatch: got: %d wanted: %d\n", msgb_l3len(data), payload_length);
return -1;
}
if (data->l3h[0] != test_data[current_test].first_byte) {
FAIL("The first bytes of l3 do not match: 0x%x 0x%x\n",
data->l3h[0], test_data[current_test].first_byte);
return -1;
}
got = &data->l3h[0];
wanted = test_data[current_test].data + test_data[current_test].payload_start;
for (i = 0; i < len; ++i) {
if (got[i] != wanted[i]) {
FAIL("Failed to compare byte. Got: 0x%x Wanted: 0x%x at %d\n",
got[i], wanted[i], i);
return -1;
}
}
matched = 1;
return 0;
}
void sccp_write_cb(struct msgb *data, void *ctx)
{
int i = 0;
const uint8_t *got, *wanted;
if (test_data[current_test].response == NULL) {
FAIL("Didn't expect write callback\n");
goto exit;
} else if (test_data[current_test].response_length != msgb_l2len(data)) {
FAIL("Size does not match. Got: %d Wanted: %d\n",
msgb_l2len(data), test_data[current_test].response_length);
}
got = &data->l2h[0];
wanted = test_data[current_test].response;
for (i = 0; i < msgb_l2len(data); ++i) {
if (got[i] != wanted[i]) {
FAIL("Failed to compare byte. Got: 0x%x Wanted: 0x%x at %d\n",
got[i], wanted[i], i);
goto exit;
}
}
write_called = 1;
exit:
msgb_free(data);
}
void sccp_c_read(struct sccp_connection *connection, struct msgb *msgb, unsigned int len)
{
sccp_read_cb(msgb, len, connection->data_ctx);
}
void sccp_c_state(struct sccp_connection *connection, int old_state)
{
if (connection->connection_state >= SCCP_CONNECTION_STATE_RELEASE_COMPLETE)
sccp_connection_free(connection);
}
int sccp_accept_cb(struct sccp_connection *connection, void *user_data)
{
called = 1;
unsigned int ref = 0;
ref |= connection->destination_local_reference.octet1 << 24;
ref |= connection->destination_local_reference.octet2 << 16;
ref |= connection->destination_local_reference.octet3 << 8;
ref = ntohl(ref);
connection->data_cb = sccp_c_read;
connection->state_cb = sccp_c_state;
/* accept this */
return 0;
}
static void sccp_udt_write_cb(struct msgb *data, void *context)
{
const uint8_t *got, *wanted;
int i;
write_called = 1;
if (send_data[current_test].length != msgb_l2len(data)) {
FAIL("Size does not match. Got: %d Wanted: %d\n",
msgb_l2len(data), send_data[current_test].length);
goto exit;
}
got = &data->l2h[0];
wanted = send_data[current_test].data;
for (i = 0; i < msgb_l2len(data); ++i) {
if (got[i] != wanted[i]) {
FAIL("Failed to compare byte. Got: 0x%x Wanted: 0x%x at %d\n",
got[i], wanted[i], i);
goto exit;
}
}
matched = 1;
exit:
msgb_free(data);
}
static void test_sccp_system(void)
{
sccp_system_init(sccp_write_cb, NULL);
sccp_set_read(&sccp_ssn_bssap, sccp_read_cb, NULL);
sccp_connection_set_incoming(&sccp_ssn_bssap, sccp_accept_cb, NULL);
for (current_test = 0; current_test < ARRAY_SIZE(test_data); ++current_test) {
unsigned int length = test_data[current_test].length;
struct msgb *msg = msgb_alloc_headroom(length + 2, 2, __func__);
msg->l2h = msgb_put(msg, length);
memcpy(msg->l2h, test_data[current_test].data, length);
called = matched = write_called = 0;
printf("Testing packet: %d\n", current_test);
sccp_system_incoming(msg);
if (!called || !matched || (test_data[current_test].write != write_called))
FAIL("current test: %d called: %d matched: %d write: %d\n",
current_test, called, matched, write_called);
msgb_free(msg);
}
}
/* test sending of udt */
static void test_sccp_send_udt(void)
{
sccp_system_init(sccp_udt_write_cb, NULL);
sccp_set_read(NULL, NULL, NULL);
sccp_connection_set_incoming(NULL, NULL, NULL);
for (current_test = 0; current_test < ARRAY_SIZE(send_data); ++current_test) {
const struct test_data *test = &send_data[current_test];
struct msgb *msg = msgb_alloc(test->payload_length, __func__);
msg->l3h = msgb_put(msg, test->payload_length);
memcpy(msg->l3h, test->data + test->payload_start, test->payload_length);
matched = write_called = 0;
printf("Testing packet: %d\n", current_test);
sccp_write(msg, &sccp_ssn_bssap, &sccp_ssn_bssap, 0);
if (!matched || !write_called)
FAIL("current test: %d matched: %d write: %d\n",
current_test, matched, write_called);
msgb_free(msg);
}
}
/* send udt from one end to another */
static unsigned int test_value = 0x2442;
static int sccp_udt_read(struct msgb *data, unsigned int len, void *context)
{
unsigned int *val;
if (len != 4) {
FAIL("Wrong size: %d\n", msgb_l3len(data));
return -1;
}
val = (unsigned int*)data->l3h;
matched = test_value == *val;
return 0;
}
static void sccp_write_loop(struct msgb *data, void *context)
{
/* send it back to us */
sccp_system_incoming(data);
msgb_free(data);
}
static void test_sccp_udt_communication(void)
{
struct msgb *data;
unsigned int *val;
sccp_system_init(sccp_write_loop, NULL);
sccp_set_read(&sccp_ssn_bssap, sccp_udt_read, NULL);
sccp_connection_set_incoming(NULL, NULL, NULL);
data = msgb_alloc(4, "test data");
data->l3h = &data->data[0];
val = (unsigned int *)msgb_put(data, 4);
*val = test_value;
matched = 0;
sccp_write(data, &sccp_ssn_bssap, &sccp_ssn_bssap, 0);
if (!matched)
FAIL("Talking with us didn't work\n");
msgb_free(data);
}
/* connection testing... open, send, close */
static const struct connection_test *current_con_test;
static struct sccp_connection *outgoing_con;
static struct sccp_connection *incoming_con;
static int outgoing_data, incoming_data, incoming_state, outgoing_state;
static struct msgb *test_data1, *test_data2, *test_data3;
static void sccp_conn_in_state(struct sccp_connection *conn, int old_state)
{
printf("\tincome: %d -> %d\n", old_state, conn->connection_state);
if (conn->connection_state >= SCCP_CONNECTION_STATE_RELEASE_COMPLETE) {
if (conn == incoming_con) {
sccp_connection_free(conn);
incoming_con = NULL;
}
}
}
static void sccp_conn_in_data(struct sccp_connection *conn, struct msgb *msg, unsigned int len)
{
/* compare the data */
++incoming_data;
printf("\tincoming data: %d\n", len);
/* compare the data */
if (len != 4) {
FAIL("Length of packet is wrong: %u %u\n", msgb_l3len(msg), len);
return;
}
if (incoming_data == 1) {
if (memcmp(msg->l3h, test_data1->l3h, len) != 0) {
</