Renamed tutorials_test to tutorial_tests

data/tutorial_tests/osips/opensips/etc/default/opensips

@@ -0,0 +1,27 @@
+#
+# OpenSIPS startup options
+#
+
+# Set to yes to enable opensips, once configured properly.
+RUN_OPENSIPS=yes
+
+# User to run as
+USER=opensips
+
+# Group to run as
+GROUP=opensips
+
+# Amount of shared memory to allocate for the running OpenSIPS server (in Mb)
+S_MEMORY=64
+
+# Amount of pkg memory to allocate for the running OpenSIPS server (in Mb)
+P_MEMORY=4
+
+# Enable the server to leave a core file when it crashes.
+# Set this to 'yes' to enable OpenSIPS to leave a core file when it crashes
+# or 'no' to disable this feature. This option is case sensitive and only
+# accepts 'yes' and 'no' and only in lowercase letters.
+# On some systems (e.g. Ubuntu 6.10, Debian 4.0) it is necessary to specify
+# a directory for the core files to get a dump. Look into the opensips
+# init file for an example configuration.
+DUMP_CORE=no

data/tutorial_tests/osips/opensips/etc/init.d/opensips

@@ -0,0 +1,199 @@
+#! /bin/sh
+#
+### BEGIN INIT INFO
+# Provides:          opensips
+# Required-Start:    $syslog $network $local_fs $time
+# Required-Stop:     $syslog $network $local_fs
+# Default-Start:     2 3 4 5
+# Default-Stop:      0 1 6
+# Short-Description: Start the OpenSIPS SIP server
+# Description:       Start the OpenSIPS SIP server
+### END INIT INFO
+#
+# TODO:
+# The following fields should be added (and completed):
+# Should-Start:      postgresql mysql radius
+# Should-Stop:       postgresql mysql radius
+
+PATH=/sbin:/bin:/usr/sbin:/usr/bin
+DAEMON=/usr/sbin/opensips
+NAME=opensips
+DESC=opensips
+TUTDIR=/usr/share/cgrates/tutorial_tests/osips/$NAME
+SCRIPTNAME=$TUTDIR/etc/init.d/$NAME
+TMP_DIR=/tmp/cgr_osipsnative/$NAME
+CFGFILE=$TUTDIR/etc/$NAME/opensips.cfg
+M4CFGFILE=/etc/opensips/opensips.m4
+M4ARCHIVEDIR=/etc/opensips/archive
+HOMEDIR=$TMP_DIR/run/opensips
+PIDFILE=$HOMEDIR/$NAME.pid
+DEFAULTS=$TUTDIR/etc/default/opensips
+RUN_OPENSIPS=no
+
+if [ ! -d $HOMEDIR ]; then
+  mkdir -p $HOMEDIR
+  chown -R $USER:$GROUP $HOMEDIR
+fi
+
+# Do not start opensips if fork=no is set in the config file
+# otherwise the boot process will just stop
+check_fork ()
+{
+    if grep -q "^[[:space:]]*fork[[:space:]]*=[[:space:]]*no.*" $CFGFILE; then
+	echo "Not starting $DESC: fork=no specified in config file; run /etc/init.d/opensips debug instead"
+	exit 1
+    fi
+}
+
+check_opensips_config ()
+{
+	# Check if opensips configuration is valid before starting the server
+	set +e
+	out=$($DAEMON -c 2>&1 > /dev/null)
+	retcode=$?
+	set -e
+	if [ "$retcode" != '0' ]; then
+	    echo "Not starting $DESC: invalid configuration file!"
+	    echo -e "\n$out\n"
+	    exit 1
+	fi
+}
+
+create_radius_seqfile ()
+{
+    # Create a radius sequence file to be used by the radius client if
+    # radius accounting is enabled. This is needed to avoid any issue
+    # with the file not being writable if opensips first starts as user
+    # root because DUMP_CORE is enabled and creates this file as user
+    # root and then later it switches back to user opensips and cannot
+    # write to the file. If the file exists before opensips starts, it
+    # won't change it's ownership and will be writable for both root
+    # and opensips, no matter what options are chosen at install time
+    RADIUS_SEQ_FILE=/var/run/opensips/opensips_radius.seq
+    if [ -d /var/run/opensips ]; then
+	chown ${USER}:${GROUP} /var/run/opensips
+
+	if [ ! -f $RADIUS_SEQ_FILE ]; then
+	    touch $RADIUS_SEQ_FILE
+	fi
+
+	chown ${USER}:${GROUP} $RADIUS_SEQ_FILE
+	chmod 660 $RADIUS_SEQ_FILE
+    fi
+}
+
+test -f $DAEMON || exit 0
+
+# Load startup options if available
+if [ -f $DEFAULTS ]; then
+   . $DEFAULTS || true
+fi
+
+if [ "$RUN_OPENSIPS" != "yes" ]; then
+    echo "OpenSIPS not yet configured. Edit /etc/default/opensips first."
+    exit 0
+fi
+
+set -e
+
+S_MEMORY=$((`echo $S_MEMORY | sed -e 's/[^0-9]//g'`))
+P_MEMORY=$((`echo $P_MEMORY | sed -e 's/[^0-9]//g'`))
+[ -z "$USER" ]  && USER=opensips
+[ -z "$GROUP" ] && GROUP=opensips
+[ $S_MEMORY -le 0 ] && S_MEMORY=32
+[ $P_MEMORY -le 0 ] && P_MEMORY=32
+
+if test "$DUMP_CORE" = "yes" ; then
+    # set proper ulimit
+    ulimit -c unlimited
+    
+    # directory for the core dump files
+    # COREDIR=/home/corefiles
+    # [ -d $COREDIR ] || mkdir $COREDIR
+    # chmod 777 $COREDIR
+    # echo "$COREDIR/core.%e.sig%s.%p" > /proc/sys/kernel/core_pattern
+fi
+
+OPTIONS="-f $CFGFILE -P $PIDFILE -m $S_MEMORY -M $P_MEMORY -u $USER -g $GROUP -w $HOMEDIR"
+
+case "$1" in
+  start|debug)
+	check_opensips_config
+	create_radius_seqfile
+
+	if [ "$1" != "debug" ]; then
+	    check_fork
+	fi
+
+	# dirs under /var/run can go away on reboots.
+	mkdir -p "$HOMEDIR"
+	chmod 775 "$HOMEDIR"
+	chown "$USER:$GROUP" "$HOMEDIR" >/dev/null 2>&1 || true
+
+	# Generate config from M4
+	if [ -f $M4CFGFILE ]; then
+		m4 -Q $M4CFGFILE >$CFGFILE.tmp
+		if [ $? != 0 ]; then
+			echo "Cannot process m4 macro"
+			rm "$CFGFILE.tmp"
+			exit 1
+		fi
+
+		[ -e $CFGFILE ] || touch $CFGFILE
+
+		# compare configs
+		if [ `md5sum $CFGFILE|awk '{print $1}'` != `md5sum $CFGFILE.tmp|awk '{print $1}'` ]; then
+			mkdir -p "$M4ARCHIVEDIR"
+			mv "$CFGFILE" "$M4ARCHIVEDIR/$NAME.cfg-`date +%Y%m%d_%H%M%S`"
+		fi
+
+		mv "$CFGFILE.tmp" "$CFGFILE"
+		chown $USER:$GROUP $CFGFILE
+		chmod 640 $CFGFILE
+	fi
+
+	echo -n "Starting $DESC: $NAME"
+	start-stop-daemon --start --quiet --pidfile $PIDFILE \
+		--exec $DAEMON -- $OPTIONS || echo -n " already running"
+	echo "."
+	;;
+  stop)
+	echo -n "Stopping $DESC: $NAME"
+	start-stop-daemon --oknodo --stop --quiet --pidfile $PIDFILE \
+		--exec $DAEMON
+	echo "."
+	;;
+  restart|force-reload)
+	check_opensips_config
+	create_radius_seqfile
+
+	echo -n "Restarting $DESC: $NAME"
+	start-stop-daemon --oknodo --stop --quiet --pidfile \
+		$PIDFILE --exec $DAEMON
+	sleep 1
+	start-stop-daemon --start --quiet --pidfile \
+		$PIDFILE --exec $DAEMON  -- $OPTIONS
+	echo "."
+	;;
+  status)
+	echo -n "Status of $DESC: "
+	if [ ! -r "$PIDFILE" ]; then
+		echo "$NAME is not running."
+		exit 3
+	fi
+	if read pid < "$PIDFILE" && ps -p "$pid" > /dev/null 2>&1; then
+		echo "$NAME is running."
+		exit 0
+	else
+		echo "$NAME is not running but $PIDFILE exists."
+		exit 1
+	fi
+	;;
+  *)
+	N=/etc/init.d/$NAME
+	echo "Usage: $N {start|stop|restart|force-reload|debug|status}" >&2
+	exit 1
+	;;
+esac
+
+exit 0

data/tutorial_tests/osips/opensips/etc/opensips/opensips.cfg

@@ -0,0 +1,269 @@
+#
+# OpenSIPS residential configuration script
+#     by OpenSIPS Solutions <team@opensips-solutions.com>
+#
+# This script was generated via "make menuconfig", from
+#   the "Residential" scenario.
+# You can enable / disable more features / functionalities by
+#   re-generating the scenario with different options.#
+#
+# Please refer to the Core CookBook at:
+#      http://www.opensips.org/Resources/DocsCookbooks
+# for a explanation of possible statements, functions and parameters.
+#
+
+
+####### Global Parameters #########
+
+log_level=3
+log_stderror=no
+log_facility=LOG_LOCAL0
+
+udp_workers=4
+
+auto_aliases=no
+
+listen=udp:enp0s3:5060
+listen=udp:127.0.0.1:5080
+listen=udp:127.0.0.1:5060
+listen=udp:enp0s3:5080
+
+
+
+####### Modules Section ########
+
+#set module path
+mpath="/usr/lib/x86_64-linux-gnu/opensips/modules/"
+
+#### SIGNALING module
+loadmodule "signaling.so"
+
+#### StateLess module
+loadmodule "sl.so"
+
+#### Transaction Module
+loadmodule "tm.so"
+modparam("tm", "fr_timeout", 5)
+modparam("tm", "fr_inv_timeout", 30)
+modparam("tm", "restart_fr_on_each_reply", 0)
+modparam("tm", "onreply_avp_mode", 1)
+
+#### Record Route Module
+loadmodule "rr.so"
+/* do not append from tag to the RR (no need for this script) */
+modparam("rr", "append_fromtag", 0)
+
+#### MAX ForWarD module
+loadmodule "maxfwd.so"
+
+#### SIP MSG OPerationS module
+loadmodule "sipmsgops.so"
+
+#### FIFO Management Interface
+loadmodule "mi_fifo.so"
+modparam("mi_fifo", "fifo_name", "/tmp/opensips_fifo")
+modparam("mi_fifo", "fifo_mode", 0666)
+
+#### USeR LOCation module
+loadmodule "usrloc.so"
+modparam("usrloc", "nat_bflag", "NAT")
+modparam("usrloc", "db_mode",   0)
+
+#### REGISTRAR module
+loadmodule "registrar.so"
+modparam("registrar", "tcp_persistent_flag", "TCP_PERSISTENT")
+
+#### ACCounting module
+loadmodule "acc.so"
+modparam("acc", "early_media", 0)
+modparam("acc", "report_cancels", 0)
+modparam("acc", "detect_direction", 0)
+
+loadmodule "proto_udp.so"
+
+
+#### CGRateS module
+loadmodule "dialog.so"
+loadmodule "cgrates.so"
+modparam("cgrates", "cgrates_engine", "127.0.0.1:2014")
+
+
+####### Routing Logic ########
+
+# main request routing logic
+
+route{
+
+	if (!mf_process_maxfwd_header(10)) {
+		send_reply(483,"Too Many Hops");
+		exit;
+	}
+
+	if (has_totag()) {
+
+		# handle hop-by-hop ACK (no routing required)
+		if ( is_method("ACK") && t_check_trans() ) {
+			t_relay();
+			exit;
+		}
+
+		# sequential request within a dialog should
+		# take the path determined by record-routing
+		if ( !loose_route() ) {
+			# we do record-routing for all our traffic, so we should not
+			# receive any sequential requests without Route hdr.
+			send_reply(404, "Not here");
+			exit;
+		}
+
+		if (is_method("BYE")) {
+			# do accounting even if the transaction fails
+			do_accounting("log","failed");
+		}
+
+		# route it out to whatever destination was set by loose_route()
+		# in $du (destination URI).
+		route(relay);
+		exit;
+	}
+
+	# CANCEL processing
+	if (is_method("CANCEL")) {
+		if (t_check_trans())
+			t_relay();
+		exit;
+	}
+
+	# absorb retransmissions, but do not create transaction
+	t_check_trans();
+
+	if ( !(is_method("REGISTER")  ) ) {
+		
+		if (is_myself("$fd")) {
+					
+		} else {
+			# if caller is not local, then called number must be local
+			
+			if (!is_myself("$rd")) {
+				send_reply(403,"Relay Forbidden");
+				exit;
+			}
+		}
+
+	}
+
+	# preloaded route checking
+	if (loose_route()) {
+		xlog("L_ERR",
+			"Attempt to route with preloaded Route's [$fu/$tu/$ru/$ci]");
+		if (!is_method("ACK"))
+			send_reply(403, "Preload Route denied");
+		exit;
+	}
+
+	# record routing
+	if (!is_method("REGISTER|MESSAGE"))
+		record_route();
+
+	if (!is_myself("$rd")) {
+		append_hf("P-hint: outbound\r\n"); 
+		
+		route(relay);
+	}
+
+	# requests for my domain
+	
+	if (is_method("PUBLISH|SUBSCRIBE")) {
+		send_reply(503, "Service Unavailable");
+		exit;
+	}
+
+	if (is_method("REGISTER")) {
+				
+		if (!save("location"))
+			sl_reply_error();
+
+		exit;
+	}
+
+	if ($rU==NULL) {
+		# request with no Username in RURI
+		send_reply(484,"Address Incomplete");
+		exit;
+	}
+
+	# do lookup with method filtering
+	if (!lookup("location","m")) {
+		t_reply(404, "Not Found");
+		exit;
+	}
+
+	# check auth with CGRateS
+	$cgr_opt(GetMaxUsage) = 1; # also retrieve the max usage
+	$cgr_opt(GetAttributes) = 1;
+	$cgr_opt(GetSuppliers) = 1;
+	$cgr_opt(AuthorizeResources) = 1;
+	$cgr_opt(AllocateResources) = 1;
+	$cgr_opt(ReleaseResources) = 1;
+	$cgr_opt(ProcessThresholds) = 1;
+	$cgr_opt(ProcessStatQueues) = 1;
+	$cgr(RequestType) = "*prepaid";
+	$cgr(OriginHost) = "127.0.0.1";
+	$cgr(Source) = "OpenSIPS";
+	
+    if (!async(cgrates_auth("$fU", "$rU"), resume_cgr_auth)) {
+        sl_send_reply(503, "Service Unavailable");
+        exit;
+    }
+}
+
+route [resume_cgr_auth] {
+	if ($rc != 1) {
+		xlog("Call not authorized: code=$cgrret!\n");
+		send_reply(403, "Forbidden");
+		exit;
+	}
+	$var(idx) = 0;
+	while ($(cgr_ret(AttributesDigest){s.select,$var(idx),,}) != NULL) {
+		$avp($(cgr_ret(AttributesDigest){s.select,$var(idx),,}{s.select,0,:}))
+			= $(cgr_ret(AttributesDigest){s.select,$var(idx),,}{s.select,1,:});
+		$var(idx) = $var(idx) + 1;
+	}
+    cgrates_acc("cdr|missed", "$fU", "$rU");
+    xlog("### Have authorized the call and it should go through");
+    route(relay);
+}
+
+
+route[relay] {
+	# for INVITEs enable some additional helper routes
+	if (is_method("INVITE")) {
+		t_on_branch("per_branch_ops");
+		t_on_reply("handle_nat");
+		t_on_failure("missed_call");
+	}
+
+	if (!t_relay()) {
+		send_reply(500,"Internal Error");
+	}
+	exit;
+}
+
+
+
+
+branch_route[per_branch_ops] {
+	xlog("new branch at $ru\n");
+}
+
+
+onreply_route[handle_nat] {
+	xlog("incoming reply\n");
+}
+
+
+failure_route[missed_call] {
+	if (t_was_cancelled()) {
+		exit;
+	}
+}