tree baa2df74f9aa61aeaff6b8e852c2b27dcf0c3060
parent 5e186d3d1f467eb4ea95bc27475fdf20a8db5ee9
author Holger Hans Peter Freyther <holger@moiji-mobile.com> 1412268674 +0200
committer Holger Hans Peter Freyther <holger@moiji-mobile.com> 1412694261 +0200

libosmo-abis: Revert parts of the multi-TRX support in libosmo-abis

The line doesn't have the signalling type set yet. It will be set
_after_ the rsl connection is considered up. This is addressing
RSL Connection failures like:

<0001> oml.c:1026 Rx IPA RSL CONNECT IP=1.2.3.4 PORT=3003 STREAM=0x00
<000f> input/ipaccess.c:921 cannot create RSL BTS link: trx_nr (0) does not refer to a signalling link
<0001> oml.c:1030 Error in abis_open(RSL): -22
<0001> oml.c:341 Sending FOM NACK with cause Message cannot be performed.
